LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::Init()
void AllMaximalSetsLexicographic::Init() {
  maximal_sets_count_ = input_sets_count_ = canidate_seek_count_ = 0;
  std::cerr << "; Finding all maximal itemsets.\n"
            << "; Limit on number of items in main memory: "
            << max_items_in_ram_ << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x590e(%rip), %r14      # 0x7ff0
leaq 0x2975(%rip), %rsi      # 0x505e
movl $0x20, %edx
movq %r14, %rdi
callq 0x21e0
leaq 0x2982(%rip), %rsi      # 0x507f
movl $0x2b, %edx
movq %r14, %rdi
callq 0x21e0
movl 0x54(%rbx), %esi
movq %r14, %rdi
callq 0x20f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::ReadNextChunk(google_extremal_sets::DataSourceIterator*, long*)
bool AllMaximalSetsLexicographic::ReadNextChunk(
    DataSourceIterator* data, off_t* resume_offset) {
  *resume_offset = 0;
  items_in_ram_ = 0;
  ItemSet current_set;
  uint32_t set_id;
  bool result;
  while ((result = data->Next(&set_id, &current_set)) > 0) {
    candidates_.push_back(SetProperties::Create(set_id, current_set));
    items_in_ram_ += current_set.size();
    ++input_sets_count_;
    // Check if we've exceeded the RAM limit and if so stop
    // retaining any further itemsets in memory until the next
    // scan.
    if (items_in_ram_ >= max_items_in_ram_) {
      *resume_offset = data->Tell();
      std::cerr << "; Halted scan at input set number "
                << input_sets_count_ << " with id " << set_id << std::endl;
      return true;
    }
  }  // while ((result = data->Next() ...
  return result == 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
movq %rdx, 0x28(%rsp)
movq %rax, (%rdx)
movl $0x0, 0x50(%rdi)
leaq 0x10(%rsp), %r12
movq %rax, 0x10(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
leaq 0x18(%rdi), %r13
leaq 0xc(%rsp), %rbp
leaq 0x30(%rsp), %r14
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x3b20
testl %eax, %eax
je 0x28cb
movl 0xc(%rsp), %edi
movq %r12, %rsi
callq 0x45f0
movq %rax, 0x30(%rsp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x30e2
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
shrq $0x2, %rax
addl 0x50(%rbx), %eax
movl %eax, 0x50(%rbx)
incq 0x8(%rbx)
cmpl 0x54(%rbx), %eax
jb 0x27f7
movq %r15, %rdi
callq 0x3b18
movq 0x28(%rsp), %rcx
movq %rax, (%rcx)
movq 0x5793(%rip), %rdi      # 0x7ff0
leaq 0x286f(%rip), %rsi      # 0x50d3
movl $0x22, %edx
callq 0x21e0
movq 0x8(%rbx), %rsi
movq 0x5777(%rip), %rdi      # 0x7ff0
callq 0x2170
movq %rax, %rbx
leaq 0x286e(%rip), %rsi      # 0x50f6
movl $0x9, %edx
movq %rax, %rdi
callq 0x21e0
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x28e2
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28f7
jmp 0x28f7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2911
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::DeleteTriviallySubsumedCandidates()
void AllMaximalSetsLexicographic::DeleteTriviallySubsumedCandidates() {
  // Now iterate over the current chunk backwards and delete
  // itemsets that are tivially subsumed based on prefix comparison.
  std::cerr << "; Deleting trivially subsumed itemsets..." << std::endl;
  assert(candidates_.size());
  SetProperties* not_a_prefix_itemset = candidates_.back();
  for (int i = candidates_.size() - 2; i >= 0; --i) {
    SetProperties* candidate = candidates_[i];
    bool subsumed = false;
    if (candidate->size < not_a_prefix_itemset->size) {
      subsumed = true;
      for (unsigned int j = 0; j < candidate->size; ++j) {
        if (candidate->item[j] != not_a_prefix_itemset->item[j]) {
          subsumed = false;
          break;
        }
      }
    }
    if (subsumed) {
      items_in_ram_ -= candidate->size;
      SetProperties::Delete(candidate);
      candidates_[i] = 0;
    } else {
      not_a_prefix_itemset = candidate;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x56c7(%rip), %r14      # 0x7ff0
leaq 0x27d0(%rip), %rsi      # 0x5100
movl $0x29, %edx
movq %r14, %rdi
callq 0x21e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x20(%rbx), %rax
movq %rax, %rcx
subq 0x18(%rbx), %rcx
je 0x29d7
shrq $0x3, %rcx
addl $-0x2, %ecx
js 0x29d1
movq -0x8(%rax), %r15
movl %ecx, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
movl 0x4(%rdi), %eax
cmpl 0x4(%r15), %eax
jae 0x29c2
testq %rax, %rax
je 0x29ac
xorl %ecx, %ecx
movl 0x8(%rdi,%rcx,4), %edx
cmpl 0x8(%r15,%rcx,4), %edx
jne 0x29c2
incq %rcx
cmpq %rcx, %rax
jne 0x2999
subl %eax, 0x50(%rbx)
callq 0x4634
movq 0x18(%rbx), %rax
movq $0x0, (%rax,%r14,8)
jmp 0x29c5
movq %rdi, %r15
leaq -0x1(%r14), %rax
testq %r14, %r14
movq %rax, %r14
jg 0x2981
popq %rbx
popq %r14
popq %r15
retq
leaq 0x274c(%rip), %rdi      # 0x512a
leaq 0x2758(%rip), %rsi      # 0x513d
leaq 0x2773(%rip), %rcx      # 0x515f
movl $0xa6, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::DumpMaximalSets()
void AllMaximalSetsLexicographic::DumpMaximalSets() {
  for (unsigned int i = 0; i < candidates_.size(); ++i) {
    SetProperties* maximal_set = candidates_[i];
    if (maximal_set) {
      FoundMaximalSet(*maximal_set);
      SetProperties::Delete(maximal_set);
    }
  }
  candidates_.clear();
  std::cout << std::flush;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
cmpq %rax, %rcx
je 0x2bec
movl $0x1, %ebp
xorl %edx, %edx
movq (%rax,%rdx,8), %r14
testq %r14, %r14
je 0x2bd9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2efa
movq %r14, %rdi
callq 0x4634
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movl %ebp, %edx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rdx, %rsi
ja 0x2bb5
cmpq %rax, %rcx
je 0x2bf5
movq %rax, 0x20(%rbx)
movq 0x53d4(%rip), %rdi      # 0x7fd0
popq %rbx
popq %r14
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::FoundMaximalSet(google_extremal_sets::SetProperties const&)
void AllMaximalSetsLexicographic::FoundMaximalSet(const SetProperties& maximal_set) {
  ++maximal_sets_count_;
  switch (output_mode_) {
    case COUNT_ONLY:
      break;
    case ID:
      std::cout << maximal_set.set_id << '\n';
      break;
    case ID_AND_ITEMS:
      std::cout << maximal_set << '\n';
      break;
    default:
      std::cout << "Huh?\n";
      assert(0);
      break;
  }
}

// Assembly:
pushq %rax
incq (%rdi)
movl 0x58(%rdi), %eax
testl %eax, %eax
je 0x2f45
cmpl $0x2, %eax
je 0x2f24
cmpl $0x1, %eax
jne 0x2f47
movl (%rsi), %esi
movq 0x50b8(%rip), %rdi      # 0x7fd0
callq 0x20f0
leaq 0x6(%rsp), %rsi
jmp 0x2f35
movq 0x50a5(%rip), %rdi      # 0x7fd0
callq 0x4639
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x21e0
popq %rax
retq
movq 0x5082(%rip), %rdi      # 0x7fd0
leaq 0x2412(%rip), %rsi      # 0x5367
callq 0x2190
leaq 0x240c(%rip), %rdi      # 0x536d
leaq 0x21d5(%rip), %rsi      # 0x513d
leaq 0x2400(%rip), %rcx      # 0x536f
movl $0x19b, %edx            # imm = 0x19B
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::GetNewEndRangeIt(__gnu_cxx::__normal_iterator<google_extremal_sets::SetProperties**, std::vector<google_extremal_sets::SetProperties*, std::allocator<google_extremal_sets::SetProperties*>>>, __gnu_cxx::__normal_iterator<google_extremal_sets::SetProperties**, std::vector<google_extremal_sets::SetProperties*, std::allocator<google_extremal_sets::SetProperties*>>>, unsigned int, unsigned int)
inline
AllMaximalSetsLexicographic::CandidateList::iterator AllMaximalSetsLexicographic::GetNewEndRangeIt(
    CandidateList::iterator begin_range_it,
    CandidateList::iterator end_range_it,
    uint32_t current_item,
    unsigned int depth) {
  ++canidate_seek_count_;
  CandidateList::iterator new_end_range_it;
  if (depth == 0) {
    // At depth 0 we can use the index rather than binary search.
    if (current_item + 1 < index_.size()) {
      new_end_range_it = candidates_.begin() + index_[current_item + 1];
      assert(new_end_range_it <= end_range_it);
    } else {
      new_end_range_it = end_range_it;
    }
  } else {
    new_end_range_it = find_new_it(
        begin_range_it,
        end_range_it,
        current_item,
        depth,
        std::equal_to<uint32_t>());
  }
  return new_end_range_it;
}

// Assembly:
pushq %rax
incq 0x10(%rdi)
testl %r8d, %r8d
je 0x3094
cmpq %rdx, %rsi
je 0x2ffd
cmpq $0x0, (%rsi)
jne 0x2ffd
addq $0x8, %rsi
jmp 0x2fec
movq %rdx, %rdi
subq %rsi, %rdi
shrq $0x3, %rdi
testl %edi, %edi
jle 0x306c
movl %r8d, %eax
movl %edi, %r8d
shrl %r8d
leaq (%rsi,%r8,8), %r9
cmpq %rdx, %r9
jae 0x3029
cmpq $0x0, (%r9)
jne 0x3029
addq $0x8, %r9
jmp 0x3018
cmpq %rdx, %r9
je 0x3064
movq (%r9), %r9
cmpl %ecx, 0x8(%r9,%rax,4)
jne 0x3064
movl %r8d, %r9d
leaq (%rsi,%r9,8), %rsi
addq $0x8, %rsi
notl %r8d
addl %r8d, %edi
cmpq %rdx, %rsi
jae 0x305c
cmpq $0x0, (%rsi)
jne 0x305c
addq $0x8, %rsi
decl %edi
jmp 0x3049
movl %edi, %r8d
cmpq %rdx, %rsi
je 0x30be
movl %r8d, %edi
testl %r8d, %r8d
jg 0x300e
cmpq $0x0, (%rsi)
movq %rsi, %rdx
jne 0x30be
leaq 0x2436(%rip), %rdi      # 0x54b2
leaq 0x20ba(%rip), %rsi      # 0x513d
leaq 0x242f(%rip), %rcx      # 0x54b9
movl $0x46, %edx
callq 0x20e0
incl %ecx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rsi
subq %rax, %rsi
sarq $0x3, %rsi
cmpq %rcx, %rsi
jbe 0x30be
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq 0x18(%rdi), %rax
cmpq %rdx, %rax
movq %rax, %rdx
ja 0x30c3
movq %rdx, %rax
popq %rcx
retq
leaq 0x2304(%rip), %rdi      # 0x53ce
leaq 0x206c(%rip), %rsi      # 0x513d
leaq 0x2317(%rip), %rcx      # 0x53ef
movl $0x13f, %edx            # imm = 0x13F
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/roberto-bayardo[P]google-extremal-sets/set-properties.cc
// Function: google_extremal_sets::operator<<(std::ostream&, google_extremal_sets::SetProperties const&)
std::ostream& operator<<(std::ostream& os, const SetProperties& output_me) {
  os << output_me.set_id << ": ";
  for (uint32_t i = 0; i < output_me.size; ++i) {
    if (i != 0)
      os << ' ';
    os << output_me.item[i];
  }
  return os;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x20f0
leaq 0x11e3(%rip), %rsi      # 0x5838
movl $0x2, %edx
movq %rax, %rdi
callq 0x21e0
cmpl $0x0, 0x4(%r14)
je 0x46a4
xorl %r12d, %r12d
leaq 0x7(%rsp), %r15
testq %r12, %r12
je 0x468b
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
movl 0x8(%r14,%r12,4), %esi
movq %rbx, %rdi
callq 0x20f0
incq %r12
movl 0x4(%r14), %eax
cmpq %rax, %r12
jb 0x4671
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/akojo[P]quickfind/qfind.cpp
// Function: usage()
void usage(void)
{
    cerr << "Quickfind version 1.0" << endl;
    cerr << "Usage: qfind [-adf] <pattern> [path...]" << endl;
    cerr << "       qfind -h" << endl;
    cerr << "Where options are:" << endl;
    cerr << "  -a  Show also hidden files and directories" << endl;
    cerr << "  -d  Print matching directories" << endl;
    cerr << "  -f  Print matching files" << endl;
    cerr << "  -h  Print this info and exit" << endl;
    cerr << "Omitting both 'd' and 'f' flags is the same as specifying -df" << endl;
    exit(1);
}

// Assembly:
pushq %rbx
movq 0x4c1c(%rip), %rbx      # 0x6ff0
leaq 0x2c29(%rip), %rsi      # 0x5004
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c28(%rip), %rsi      # 0x501a
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c39(%rip), %rsi      # 0x5042
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c32(%rip), %rsi      # 0x5052
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c2e(%rip), %rsi      # 0x5065
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c44(%rip), %rsi      # 0x5092
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c4e(%rip), %rsi      # 0x50b3
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c52(%rip), %rsi      # 0x50ce
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c5a(%rip), %rsi      # 0x50ed
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
movl $0x1, %edi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O3/akojo[P]quickfind/dir.cpp
// Function: walk(char*, int, std::function<void (char const*)>)
static void walk(char *name, int opts, function<void(const char*)> func) noexcept
{
    auto dir = opendir(name);
    auto namelen = strlen(name);
    auto endp = name + namelen;
    struct dirent *d;

    if (!dir) return;

    *endp++ = '/';

    while ((d = readdir(dir)) != NULL) {
        if (skip(d->d_name, opts)) continue;
        if (strlen(d->d_name) + namelen >= FILENAME_MAX) continue;

        strcpy(endp, d->d_name);

        if (is_dir(d, name)) {
           if (opts & DW_DIRECTORIES) func(name);
           walk(name, opts, func);
        }
        else if (opts & DW_FILES) {
            func(name);
        }
    }
    closedir(dir);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x21a0
movq %rax, %r15
movq %r14, %rdi
callq 0x2080
testq %r15, %r15
je 0x331a
movq %rax, %r12
addq %r14, %rax
incq %rax
movq %rax, 0x10(%rsp)
movq %r14, 0x8(%rsp)
movb $0x2f, (%r14,%r12)
movq %r15, %rdi
callq 0x21b0
movq %rax, %r13
testq %rax, %rax
je 0x3312
movq %r13, %r14
cmpb $0x2e, 0x13(%r13)
jne 0x3221
testb $0x1, %bpl
je 0x31e8
movzbl 0x14(%r14), %eax
testl %eax, %eax
je 0x31e8
cmpl $0x2e, %eax
jne 0x3221
cmpb $0x0, 0x15(%r14)
je 0x31e8
addq $0x13, %r13
movq %r13, %rdi
callq 0x2080
addq %r12, %rax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x31e8
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x2110
movzbl 0x12(%r14), %eax
testl %eax, %eax
je 0x32bb
cmpl $0x4, %eax
movq 0x8(%rsp), %r14
jne 0x32e7
testb $0x2, %bpl
je 0x327d
movq %r14, 0x38(%rsp)
cmpq $0x0, 0x10(%rbx)
je 0x332c
movq %rbx, %rdi
leaq 0x38(%rsp), %rsi
callq *0x18(%rbx)
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x333e
movq %r14, %rdi
movl %ebp, %esi
leaq 0x18(%rsp), %rdx
callq 0x319e
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x31e8
leaq 0x18(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x31e8
movq 0x8(%rsp), %r14
movq %r14, %rdi
leaq 0x38(%rsp), %rsi
callq 0x2100
testl %eax, %eax
jne 0x32e7
movl 0x50(%rsp), %eax
movl $0xf000, %ecx           # imm = 0xF000
andl %ecx, %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x325c
testb $0x4, %bpl
je 0x31e8
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x10(%rbx)
je 0x332c
movq %rbx, %rdi
leaq 0x38(%rsp), %rsi
callq *0x18(%rbx)
jmp 0x31e8
movq %r15, %rdi
callq 0x21e0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2060
jmp 0x3335
jmp 0x3335
movq %rax, %rdi
callq 0x2a00
nop
// File: /workspace/github_cpp_makefile_star2_O3/Crawler995[P]Cpp-Ray-Tracing/libs/sphere.cpp
// Function: Sphere::Sphere()
Sphere::Sphere() {
    center = Vector3(0, 0, 0);
    radius = 0;

    PhongMaterial m = PhongMaterial(0, 0, 0, 0, Color(0, 0, 0), Color(0, 0, 0), Color(0, 0, 0));
    set_material(&m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x6060(%rip), %rax      # 0x8ca0
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0x284c
leaq -0xa8(%rbp), %r14
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r14, %rdi
callq 0x2838
movq 0x10(%r14), %rax
movq %rax, 0x20(%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x28(%rbx)
leaq -0x58(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x35c8
leaq -0x48(%rbp), %r12
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x35c8
leaq -0x38(%rbp), %r13
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x35c8
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq (%r12), %rcx
movl 0x8(%r12), %r8d
movl 0x8(%r13), %eax
movq (%r13), %r9
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
xorps %xmm3, %xmm3
movq %r14, %rdi
pushq %rax
pushq %r9
callq 0x3804
addq $0x10, %rsp
movq %r14, 0x8(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Crawler995[P]Cpp-Ray-Tracing/libs/perspective_camera.cpp
// Function: PerspectiveCamera::generate_ray(double, double)
Ray3 PerspectiveCamera::generate_ray(double u, double v) {
    return Ray3(
        camera_pos,
        left_bottom_pos.add(horizontal.scale(u))
                       .add(vertical.scale(v))
                       .subtract(camera_pos)
                       .normalize()
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movsd %xmm1, -0x28(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movq 0x60(%rsi), %rax
movq %rax, -0x30(%rbp)
movups 0x50(%rsi), %xmm1
movaps %xmm1, -0x40(%rbp)
leaq 0x8(%rsi), %r15
addq $0x20, %rsi
leaq -0x70(%rbp), %r12
movq %r12, %rdi
callq 0x29da
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
leaq -0x88(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2950
leaq 0x38(%r14), %rsi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x29da
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2950
movq 0x60(%r14), %rax
movq %rax, 0x10(%rsp)
movups 0x50(%r14), %xmm0
movups %xmm0, (%rsp)
leaq -0xb8(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x29a6
leaq -0xd0(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28d2
movq 0x10(%r15), %rax
movq %rax, 0x28(%rsp)
movups (%r15), %xmm0
movups %xmm0, 0x18(%rsp)
movq -0x30(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x2ae8
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Crawler995[P]Cpp-Ray-Tracing/libs/geometry_union.cpp
// Function: GeometryUnion::intersect(Ray3)
IntersectResult GeometryUnion::intersect(Ray3 ray) {
    int size = geometries.size();
    double min_dis = MAX_DISTANCE;
    IntersectResult res(0, 0, Vector3(0, 0, 0), Vector3(0, 0, 0));
    for(int i = 0; i < size; i++) {
        IntersectResult tmp = geometries[i] -> intersect(ray);
        if(tmp.geometry && tmp.distance < min_dis) {
            min_dis = tmp.distance;
            res = tmp;
        }
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r13
subq (%rsi), %r13
shrq $0x3, %r13
leaq -0xc0(%rbp), %r15
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0x2838
leaq -0xa8(%rbp), %r12
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r12, %rdi
callq 0x2838
movq 0x10(%r12), %rax
movq %rax, -0x60(%rbp)
movups (%r12), %xmm0
movaps %xmm0, -0x70(%rbp)
movups (%r15), %xmm0
movaps %xmm0, -0x90(%rbp)
movq 0x10(%r15), %rax
movq %rax, -0x80(%rbp)
leaq 0x10(%rbx), %rdi
callq 0x284c
leaq 0x28(%rbx), %rdi
callq 0x284c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movaps -0x90(%rbp), %xmm0
movups %xmm0, 0x10(%rbx)
movq -0x80(%rbp), %rax
movq %rax, 0x20(%rbx)
movapd -0x70(%rbp), %xmm0
movupd %xmm0, 0x28(%rbx)
movq -0x60(%rbp), %rax
movq %rax, 0x38(%rbx)
testl %r13d, %r13d
jle 0x3471
leaq 0x10(%rbp), %r12
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
movsd 0x2d1f(%rip), %xmm0     # 0x6110
movsd %xmm0, -0x30(%rbp)
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15,8), %rsi
movq (%rsi), %rax
movupd (%r12), %xmm0
movupd 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
leaq -0x70(%rbp), %rdi
callq *(%rax)
cmpq $0x0, -0x70(%rbp)
je 0x3469
movsd -0x68(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3469
movupd -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movups -0x50(%rbp), %xmm3
movups -0x40(%rbp), %xmm4
movups %xmm4, 0x30(%rbx)
movups %xmm3, 0x20(%rbx)
movups %xmm2, 0x10(%rbx)
movupd %xmm1, (%rbx)
movsd %xmm0, -0x30(%rbp)
incq %r15
cmpq %r15, %r13
jne 0x33f9
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Crawler995[P]Cpp-Ray-Tracing/libs/phong_material.cpp
// Function: PhongMaterial::PhongMaterial(double, double, double, double, Color, Color, Color)
PhongMaterial::PhongMaterial(double a, double d, double s, double h, Color a_c, Color d_c, Color s_c) {
    envir_factor = a;
    diffuse_factor = d;
    specular_factor = s;
    highlight_factor = h;

    envir_color = a_c;
    diffuse_color = d_c;
    specular_color = s_c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %r13
movsd %xmm3, -0x48(%rbp)
movsd %xmm2, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rdi, %r15
leaq 0x5491(%rip), %rax      # 0x8cd0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x35d6
leaq 0x2c(%r15), %rdi
callq 0x35d6
leaq 0x38(%r15), %rdi
callq 0x35d6
leaq 0x54a0(%rip), %rax      # 0x8d08
movq %rax, (%r15)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x8(%r15)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x10(%r15)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0x18(%r15)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0x48(%r15)
movq %r13, 0x20(%r15)
movl %r12d, 0x28(%r15)
movq %r14, 0x2c(%r15)
movl %ebx, 0x34(%r15)
movq 0x10(%rbp), %rax
movq %rax, 0x38(%r15)
movl 0x18(%rbp), %eax
movl %eax, 0x40(%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Crawler995[P]Cpp-Ray-Tracing/libs/phong_material.cpp
// Function: PhongMaterial::PhongMaterial()
PhongMaterial::PhongMaterial() {
    envir_factor = 0;
    diffuse_factor = specular_factor = 0.5;
    highlight_factor = 5;

    envir_color = Color(0, 0, 0);
    diffuse_color = specular_color = Color(255, 255, 255);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x53f5(%rip), %rax      # 0x8cd0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x35d6
leaq 0x2c(%rbx), %rdi
callq 0x35d6
leaq 0x38(%rbx), %rdi
callq 0x35d6
leaq 0x5404(%rip), %rax      # 0x8d08
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x18(%rbx)
movq %rax, 0x10(%rbx)
movabsq $0x4014000000000000, %rax # imm = 0x4014000000000000
movq %rax, 0x48(%rbx)
leaq -0x1c(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x35c8
movl 0x8(%r14), %eax
movl %eax, 0x28(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
movq %r14, %rdi
movl $0xff, %esi
movl $0xff, %edx
movl $0xff, %ecx
callq 0x35c8
movl 0x8(%r14), %eax
movl %eax, 0x40(%rbx)
movq (%r14), %rax
movq %rax, 0x38(%rbx)
movq (%r14), %rax
movq %rax, 0x2c(%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x34(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Crawler995[P]Cpp-Ray-Tracing/libs/phong_material.cpp
// Function: PhongMaterial::sample(Ray3, Vector3, Vector3)
Color PhongMaterial::sample(Ray3 ray, Vector3 position, Vector3 normal) {
    Vector3 light(1, 1, 1);
    double ed = normal.dot(light.normalize());
    Vector3 h = light.normalize().subtract(ray.get_dir()).normalize();
    double es = normal.dot(h);

    ed = (ed >= 0.0) ? ed : 0;
    es = (es >= 0.0) ? es : 0;
    
    Color diffuse = diffuse_color.multiply(diffuse_factor * ed);
    Color specular = specular_color.multiply(specular_factor * pow(es, highlight_factor));
    Color envir = envir_color.multiply(envir_factor);

    Color res = envir.add(specular.add(diffuse));

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq -0xd8(%rbp), %r15
movsd 0x26e6(%rip), %xmm0     # 0x6098
movq %r15, %rdi
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
callq 0x2838
leaq -0xc0(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x28d2
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x58(%rbp), %r12
movq %r12, %rdi
callq 0x2a3a
movaps %xmm0, -0x40(%rbp)
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x28d2
leaq -0x90(%rbp), %r15
leaq 0x10(%rbp), %rsi
movq %r15, %rdi
callq 0x2b8c
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x29a6
leaq -0xa8(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x28d2
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movupd (%r13), %xmm0
movupd %xmm0, (%rsp)
movq %r12, %rdi
callq 0x2a3a
movapd %xmm0, %xmm3
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
movapd -0x40(%rbp), %xmm2
cmplesd %xmm2, %xmm0
andpd %xmm2, %xmm0
cmplesd %xmm3, %xmm1
andpd %xmm1, %xmm3
movapd %xmm3, -0x40(%rbp)
leaq 0x2c(%rbx), %rdi
mulsd 0x10(%rbx), %xmm0
callq 0x3612
movq %rax, %r12
movl %edx, %r13d
leaq 0x38(%rbx), %r14
movsd 0x18(%rbx), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x48(%rbx), %xmm1
movapd -0x40(%rbp), %xmm0
callq 0x2180
mulsd -0x48(%rbp), %xmm0
movq %r14, %rdi
callq 0x3612
movq %rax, (%r15)
movl %edx, 0x8(%r15)
movsd 0x8(%rbx), %xmm0
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x3612
leaq -0x60(%rbp), %rcx
movq %rax, (%rcx)
movl %edx, 0x8(%rcx)
leaq -0x78(%rbp), %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x35f6
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x35f6
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Crawler995[P]Cpp-Ray-Tracing/libs/cook_torrance_material.cpp
// Function: CookTorranceMaterial::CookTorranceMaterial(double, double, double, double, double, Color, Color, Color)
CookTorranceMaterial::CookTorranceMaterial(
    double envir_factor,
    double diffuse_factor,
    double specular_factor,
    double fresnel_factor,
    double roughness,
    Color envir_color,
    Color diffuse_color,
    Color specular_color
) {
    this -> envir_factor = envir_factor;
    this -> diffuse_factor = diffuse_factor;
    this -> specular_factor = specular_factor;
    this -> fresnel_factor = fresnel_factor;
    this -> roughness = roughness;
    this -> envir_color = envir_color;
    this -> diffuse_color = diffuse_color;
    this -> specular_color = specular_color;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r13
movsd %xmm4, -0x50(%rbp)
movsd %xmm3, -0x48(%rbp)
movsd %xmm2, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rdi, %r12
leaq 0x515c(%rip), %rax      # 0x8cd0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x35d6
leaq 0x2c(%r12), %rdi
callq 0x35d6
leaq 0x38(%r12), %rdi
callq 0x35d6
leaq 0x5199(%rip), %rax      # 0x8d38
movq %rax, (%r12)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x8(%r12)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x10(%r12)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0x18(%r12)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0x48(%r12)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, 0x50(%r12)
movq %r13, 0x20(%r12)
movl %r15d, 0x28(%r12)
movq %r14, 0x2c(%r12)
movl %ebx, 0x34(%r12)
movq 0x10(%rbp), %rax
movq %rax, 0x38(%r12)
movl 0x18(%rbp), %eax
movl %eax, 0x40(%r12)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Crawler995[P]Cpp-Ray-Tracing/libs/cook_torrance_material.cpp
// Function: CookTorranceMaterial::sample(Ray3, Vector3, Vector3)
Color CookTorranceMaterial::sample(Ray3 ray, Vector3 position, Vector3 normal) {
    Vector3 light(1, 1, 1);
    double ed = normal.dot(light.normalize());
    Vector3 h = light.normalize().subtract(ray.get_dir()).normalize();

    ed = (ed >= 0.0) ? ed : 0;
    
    Color diffuse = diffuse_color.multiply(diffuse_factor * ed);
    Color specular = specular_color.multiply(specular_factor * BRDF(ray, normal));
    Color envir = envir_color.multiply(envir_factor);

    Color res = envir.add(specular.add(diffuse));

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq -0xd8(%rbp), %r14
movsd 0x245e(%rip), %xmm0     # 0x6098
movq %r14, %rdi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x2838
leaq -0xc0(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28d2
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x58(%rbp), %rdi
callq 0x2a3a
movaps %xmm0, -0x40(%rbp)
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28d2
leaq -0x90(%rbp), %r14
leaq 0x10(%rbp), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x2b8c
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movupd (%r14), %xmm0
movupd %xmm0, (%rsp)
leaq -0x78(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x29a6
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x28d2
xorpd %xmm0, %xmm0
movapd -0x40(%rbp), %xmm1
cmplesd %xmm1, %xmm0
andpd %xmm1, %xmm0
leaq 0x2c(%rbx), %rdi
mulsd 0x10(%rbx), %xmm0
callq 0x3612
movq %rax, -0x40(%rbp)
movl %edx, %r15d
leaq 0x38(%rbx), %r14
movsd 0x18(%rbx), %xmm0
movsd %xmm0, -0x48(%rbp)
leaq 0x58(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x40(%rsp)
movups (%rcx), %xmm0
movups %xmm0, 0x30(%rsp)
movapd (%r13), %xmm0
movaps 0x10(%r13), %xmm1
movaps 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x3d9e
mulsd -0x48(%rbp), %xmm0
movq %r14, %rdi
callq 0x3612
movq %rax, (%r12)
movl %edx, 0x8(%r12)
movsd 0x8(%rbx), %xmm0
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x3612
leaq -0x60(%rbp), %rcx
movq %rax, (%rcx)
movl %edx, 0x8(%rcx)
leaq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %r15d, %edx
callq 0x35f6
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x35f6
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Crawler995[P]Cpp-Ray-Tracing/libs/cook_torrance_material.cpp
// Function: CookTorranceMaterial::BRDF(Ray3, Vector3)
double CookTorranceMaterial::BRDF(Ray3 ray, Vector3 normal) {
    Vector3 light(1, 1, 1);
    double F = fresnel_reflect(ray);
    double D = shadow_mask(ray, normal);
    double G = normal_distribution(ray, normal);

    double n_dot_v = normal.dot(ray.get_dir().negate());
    double n_dot_l = normal.dot(light.normalize());

    return (F * D * G) / (n_dot_v * n_dot_l * 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r12
leaq -0xa0(%rbp), %rbx
movsd 0x22d6(%rip), %xmm0     # 0x6098
movq %rbx, %rdi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x2838
leaq 0x10(%rbp), %r15
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movaps 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x3f12
movsd %xmm0, -0x40(%rbp)
leaq 0x40(%rbp), %r14
movq 0x10(%r14), %rax
movq %rax, 0x40(%rsp)
movaps (%r14), %xmm0
movups %xmm0, 0x30(%rsp)
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movaps 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x4026
movsd %xmm0, -0x38(%rbp)
movq 0x10(%r14), %rax
movq %rax, 0x40(%rsp)
movaps (%r14), %xmm0
movups %xmm0, 0x30(%rsp)
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movaps 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x4146
movsd %xmm0, -0x30(%rbp)
leaq -0x70(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2b8c
leaq -0x88(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x292a
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x2a3a
movsd %xmm0, -0x28(%rbp)
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x28d2
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movupd (%r15), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x2a3a
movsd -0x38(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm0
mulsd 0x2267(%rip), %xmm0     # 0x6160
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Crawler995[P]Cpp-Ray-Tracing/libs/cook_torrance_material.cpp
// Function: CookTorranceMaterial::shadow_mask(Ray3, Vector3)
double CookTorranceMaterial::shadow_mask(Ray3 ray, Vector3 normal) {
    Vector3 light(1, 1, 1);
    Vector3 h = light.normalize().subtract(ray.get_dir()).normalize();
    double n_dot_h = normal.dot(h);
    double a = 1.0 / (roughness * roughness * pow(n_dot_h, 4) * 4);
    double b = (n_dot_h * n_dot_h - 1) / (roughness * roughness * n_dot_h * n_dot_h);
    return a * exp(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq -0xa8(%rbp), %r14
movsd 0x2050(%rip), %xmm0     # 0x6098
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x2838
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28d2
leaq -0x48(%rbp), %r14
leaq 0x10(%rbp), %rsi
movq %r14, %rdi
callq 0x2b8c
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x29a6
leaq -0x90(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28d2
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movupd (%r15), %xmm0
movupd %xmm0, (%rsp)
leaq 0x40(%rbp), %rdi
callq 0x2a3a
movsd %xmm0, -0x30(%rbp)
movsd 0x50(%rbx), %xmm1
mulsd %xmm1, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd 0x207d(%rip), %xmm1     # 0x6160
callq 0x2180
mulsd -0x28(%rbp), %xmm0
mulsd 0x206b(%rip), %xmm0     # 0x6160
movsd -0x20(%rbp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
movsd -0x30(%rbp), %xmm2
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd 0x2058(%rip), %xmm0     # 0x6170
movsd 0x50(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x21a0
mulsd -0x20(%rbp), %xmm0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Crawler995[P]Cpp-Ray-Tracing/libs/cook_torrance_material.cpp
// Function: CookTorranceMaterial::normal_distribution(Ray3, Vector3)
double CookTorranceMaterial::normal_distribution(Ray3 ray, Vector3 normal) {
    Vector3 light(1, 1, 1);
    Vector3 h = light.normalize().subtract(ray.get_dir()).normalize();

    double n_dot_h = normal.dot(h);
    double v_dot_h = ray.get_dir().negate().dot(h);

    double g1 = 2 * n_dot_h * normal.dot(light.normalize()) / v_dot_h;
    double g2 = 2 * n_dot_h * normal.dot(ray.get_dir().negate()) / v_dot_h;

    return std::min(std::min(1.0, g1), g2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
leaq -0xe8(%rbp), %r14
movsd 0x1f2f(%rip), %xmm0     # 0x6098
movq %r14, %rdi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x2838
leaq -0x70(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28d2
leaq -0xb8(%rbp), %r12
leaq 0x10(%rbp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2b8c
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
leaq -0x58(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x29a6
leaq -0xd0(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x28d2
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
leaq 0x40(%rbp), %r15
movq %r15, %rdi
callq 0x2a3a
movsd %xmm0, -0x30(%rbp)
leaq -0x70(%rbp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2b8c
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x292a
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x2a3a
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0xa0(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28d2
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movupd (%rbx), %xmm0
movupd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x2a3a
mulsd -0x30(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
leaq 0x10(%rbp), %rsi
callq 0x2b8c
leaq -0x88(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x292a
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movupd (%r14), %xmm0
movupd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x2a3a
mulsd -0x30(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
minsd 0x1dc9(%rip), %xmm1     # 0x6098
minsd %xmm1, %xmm0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Crawler995[P]Cpp-Ray-Tracing/libs/plane.cpp
// Function: Plane::intersect(Ray3)
IntersectResult Plane::intersect(Ray3 ray) {
    IntersectResult res(0, 0, Vector3(0, 0, 0), Vector3(0, 0, 0));
    double a = ray.get_dir().dot(normal);

    if(a >= 0) {
        return res;
    }

    double b = normal.dot(ray.get_origin().add(normal.scale(distance)));
    double dis = -b / a;

    res.geometry = this;
    res.distance = dis;
    res.position = ray.get_point(res.distance);
    res.normal = normal;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq -0xd0(%rbp), %r12
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r12, %rdi
callq 0x2838
leaq -0xb8(%rbp), %r13
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r13, %rdi
callq 0x2838
movq 0x10(%r13), %rax
leaq -0x70(%rbp), %r14
movq %rax, 0x10(%r14)
movups (%r13), %xmm0
movaps %xmm0, (%r14)
movups (%r12), %xmm0
movaps %xmm0, -0x50(%rbp)
movq 0x10(%r12), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbx), %rdi
movq %rdi, -0x38(%rbp)
callq 0x284c
leaq 0x28(%rbx), %r13
movq %r13, %rdi
callq 0x284c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movaps -0x50(%rbp), %xmm0
movups %xmm0, 0x10(%rbx)
movq -0x40(%rbp), %rax
movq %rax, 0x20(%rbx)
movaps (%r14), %xmm0
movups %xmm0, 0x28(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x38(%rbx)
movq %r14, %rdi
leaq 0x10(%rbp), %rsi
movq %rsi, %r12
callq 0x2b8c
movq 0x20(%r15), %rax
movq %rax, 0x10(%rsp)
movupd 0x10(%r15), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x2a3a
ucomisd 0x1a15(%rip), %xmm0     # 0x61a0
jae 0x484c
leaq 0x10(%r15), %r14
leaq -0x70(%rbp), %rdi
movq %r12, %rsi
movsd %xmm0, -0x30(%rbp)
callq 0x2b74
movsd 0x28(%r15), %xmm0
leaq -0x88(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x29da
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
leaq -0x70(%rbp), %rsi
callq 0x2950
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movupd (%r12), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x2a3a
xorpd 0x18d7(%rip), %xmm0     # 0x60e0
divsd -0x30(%rbp), %xmm0
movq %r15, (%rbx)
movsd %xmm0, 0x8(%rbx)
leaq -0x70(%rbp), %r15
movq %r15, %rdi
leaq 0x10(%rbp), %rsi
callq 0x2b26
movq 0x10(%r15), %rax
movq -0x38(%rbp), %rcx
movq %rax, 0x10(%rcx)
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%r13)
movupd (%r14), %xmm0
movupd %xmm0, (%r13)
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/fastahack/Fasta.cpp
// Function: FastaReference::getSequence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string FastaReference::getSequence(string seqname) {
    FastaIndexEntry entry = index->entry(seqname);
    int newlines_in_sequence = entry.length / entry.line_blen;
    int seqlen = newlines_in_sequence  + entry.length;
    char* seq = (char*) calloc (seqlen + 1, sizeof(char));
    fseek64(file, entry.offset, SEEK_SET);
    string s;
    if (fread(seq, sizeof(char), seqlen, file)) {
        seq[seqlen] = '\0';
        char* pbegin = seq;
        char* pend = seq + (seqlen/sizeof(char));
        pend = remove(pbegin, pend, '\n');
        pend = remove(pbegin, pend, '\0');
        s = seq;
        free(seq);
        s.resize((pend - pbegin)/sizeof(char));
    }
    return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x40(%rsi), %r14
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x54f0
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4742
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4bd7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32b0
movl 0x50(%rsp), %ecx
movl %ecx, %eax
cltd
idivl 0x60(%rsp)
leal (%rax,%rcx), %ebp
addl %ecx, %eax
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x31c0
movq %rax, %r14
movq 0x28(%r15), %rdi
movq 0x58(%rsp), %rsi
xorl %edx, %edx
callq 0x31a0
leaq 0x10(%rbx), %r13
movq %r13, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movslq %ebp, %r12
movq 0x28(%r15), %rcx
movl $0x1, %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3390
testq %rax, %rax
je 0x4c9e
leaq (%r14,%r12), %rsi
movb $0x0, (%r14,%r12)
leaq 0xf(%rsp), %rdx
movb $0xa, (%rdx)
movq %r14, %rdi
callq 0x712c
leaq 0xf(%rsp), %rdx
movb $0x0, (%rdx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x712c
movq %rax, %r15
movq 0x8(%rbx), %r12
movq %r14, %rdi
callq 0x3140
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x33c0
movq %r14, %rdi
callq 0x3320
subq %r14, %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x30e0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4cb9
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4cd9
jmp 0x4cd9
movq %rax, %r14
movq 0x10(%rsp), %rdi
jmp 0x4cf9
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x4cf0
movq (%r13), %rsi
incq %rsi
callq 0x32b0
leaq 0x40(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x4d0a
movq (%r13), %rsi
incq %rsi
callq 0x32b0
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/soccin[P]BIC-RNAseq/tools/MergeFusion/main.cpp
// Function: main
int main(int argc, char* argv[])
{
    parseOption(argc, argv);
    Merger my_merger;
    if(normalize_gene)
        my_merger.loadHugoFile(hugo_data_file.c_str());
    //my_merger.printHugoMap();
    for(size_t i = 0; i < input_files.size(); i++)
    {
        my_merger.loadFusionFile(input_files[i].first.c_str(), input_files[i].second, normalize_chrom, normalize_gene);
    }
    if(!sorting_criteria.empty())
        my_merger.sortBy(sorting_criteria);
    my_merger.outputStandardFusion(output_file.c_str());
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
callq 0x3a7f
leaq -0x88(%rbp), %rdi
callq 0x45f0
cmpb $0x1, 0xd40f(%rip)      # 0x11408
jne 0x400e
movq 0xd40e(%rip), %rsi      # 0x11410
leaq -0x88(%rbp), %rdi
callq 0x51ac
movq 0xd39b(%rip), %rax      # 0x113b0
cmpq %rax, 0xd39c(%rip)      # 0x113b8
je 0x407d
movl $0x20, %r14d
xorl %r15d, %r15d
leaq -0x88(%rbp), %rbx
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
movq -0x20(%rax,%r14), %rsi
movl (%rax,%r14), %edx
movzbl 0xd1a8(%rip), %ecx      # 0x111f0
movzbl 0xd3b8(%rip), %r8d      # 0x11408
movq %rbx, %rdi
callq 0x463e
incq %r15
movq 0xd356(%rip), %rcx      # 0x113b8
movq 0xd347(%rip), %rax      # 0x113b0
subq %rax, %rcx
sarq $0x3, %rcx
imulq %r12, %rcx
addq $0x28, %r14
cmpq %rcx, %r15
jb 0x4038
movq 0xd36c(%rip), %rdx      # 0x113f0
testq %rdx, %rdx
je 0x40c9
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0xd350(%rip), %rsi      # 0x113e8
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x41d6
leaq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4af4
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x40c9
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3200
movq 0xd2f8(%rip), %rsi      # 0x113c8
leaq -0x88(%rbp), %rdi
callq 0x498c
leaq -0x88(%rbp), %rdi
callq 0x461e
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x4116
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3200
jmp 0x4116
jmp 0x4113
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x461e
movq %rbx, %rdi
callq 0x3340
// File: /workspace/github_cpp_makefile_star2_O3/soccin[P]BIC-RNAseq/tools/MergeFusion/Merger.cpp
// Function: Merger::outputStandardFusion(char const*)
void Merger::outputStandardFusion(const char* filename)
{
#ifdef _DEBUG
    cout << "[DEBUG]: Printing result to: " << filename << endl;
#endif
    ofstream output_fs(filename);
    if(!output_fs)
    {
        cerr << "Error: fail to open output file: " << filename << endl;
        exit(1);
    }
    output_fusion_header(output_fs);
    for(size_t i = 0; i < fusion_vec.size(); i++)
        output_fs << fusion_vec[i] << endl;
    output_fs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x228(%rbp), %r15
movq %r15, %rdi
movl $0x10, %edx
callq 0x3240
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x208(%rbp,%rax)
jne 0x4aa2
leaq -0x228(%rbp), %rdi
callq 0xab2a
movq (%rbx), %rsi
cmpq %rsi, 0x8(%rbx)
je 0x4a4e
xorl %r12d, %r12d
movabsq $-0x30c30c30c30c30c3, %r13 # imm = 0xCF3CF3CF3CF3CF3D
xorl %r14d, %r14d
addq %r12, %rsi
leaq -0x228(%rbp), %rdi
callq 0xadff
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3150
incq %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x4, %rax
imulq %r13, %rax
addq $0x150, %r12            # imm = 0x150
cmpq %rax, %r14
jb 0x49f4
leaq -0x228(%rbp), %rdi
callq 0x3280
movq 0xc55f(%rip), %rax      # 0x10fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x220(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x228(%rbp,%rcx)
callq 0x31b0
leaq -0x130(%rbp), %rdi
callq 0x30d0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc547(%rip), %rdi      # 0x10ff0
leaq 0x7af1(%rip), %rsi      # 0xc5a1
movl $0x21, %edx
callq 0x3250
movq 0xc52f(%rip), %rdi      # 0x10ff0
movq %r14, %rsi
callq 0x31e0
movq %rax, %rdi
callq 0x3110
movl $0x1, %edi
callq 0x3260
jmp 0x4add
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x32a0
movq %rbx, %rdi
callq 0x3340