LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wichtounet[P]articles/src/threads/part1/Hello1.cpp
// Function: main
int main(){
    std::vector<std::thread> threads;

    for(int i = 0; i < 5; ++i){
        threads.push_back(std::thread(hello));
    }

    for(auto& thread : threads){
        thread.join();
    }

    return 0;
}

// Assembly:
subq $0x68, %rsp
movl $0x0, 0x64(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x14a0
movl $0x0, 0x44(%rsp)
cmpl $0x5, 0x44(%rsp)
jge 0x1360
leaq -0x7c(%rip), %rsi       # 0x1280
leaq 0x38(%rsp), %rdi
callq 0x14e0
jmp 0x1308
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x14b0
jmp 0x1319
leaq 0x38(%rsp), %rdi
callq 0x15a0
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x12ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x13e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x15a0
jmp 0x13e1
leaq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x15c0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x15f0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1620
testb $0x1, %al
jne 0x139d
jmp 0x13c6
leaq 0x18(%rsp), %rdi
callq 0x1660
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1120
jmp 0x13b8
jmp 0x13ba
leaq 0x18(%rsp), %rdi
callq 0x1670
jmp 0x1388
movl $0x0, 0x64(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1690
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
leaq 0x48(%rsp), %rdi
callq 0x1690
movq 0x30(%rsp), %rdi
callq 0x1130
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, 0x10(%rax)
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movq 0xb6be(%rip), %rdi      # 0xdff0
leaq 0x6725(%rip), %rsi      # 0x905e
callq 0x2200
movq %rax, %rdi
leaq 0x6737(%rip), %rsi      # 0x907f
callq 0x2200
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x54(%rax), %esi
callq 0x22e0
movq %rax, %rdi
movq 0xb652(%rip), %rsi      # 0xdfb8
callq 0x2240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0xb415(%rip), %rdi      # 0xdff0
leaq 0x651e(%rip), %rsi      # 0x9100
callq 0x2200
movq %rax, %rdi
movq 0xb3c7(%rip), %rsi      # 0xdfb8
callq 0x2240
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x39a0
cmpq $0x0, %rax
je 0x2c0b
jmp 0x2c2a
leaq 0x6518(%rip), %rdi      # 0x912a
leaq 0x6524(%rip), %rsi      # 0x913d
movl $0xa6, %edx
leaq 0x653a(%rip), %rcx      # 0x915f
callq 0x2140
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x3a90
movq -0x30(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x18, %rdi
callq 0x39a0
subq $0x2, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x2d20
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x39c0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x2ccc
movb $0x1, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x2cca
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
movl 0x8(%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movl -0x28(%rbp), %edx
cmpl 0x8(%rcx,%rdx,4), %eax
je 0x2cbd
movb $0x0, -0x21(%rbp)
jmp 0x2cca
jmp 0x2cbf
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2c93
jmp 0x2ccc
testb $0x1, -0x21(%rbp)
je 0x2d08
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %edx
movl 0x50(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x50(%rax)
movq -0x20(%rbp), %rdi
callq 0x84d0
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x39c0
movq $0x0, (%rax)
jmp 0x2d10
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2d12
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2c52
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::DeleteSubsumedCandidates(unsigned int)
void AllMaximalSetsLexicographic::DeleteSubsumedCandidates(unsigned int current_set_index) {
  current_set_ = candidates_[current_set_index];
  assert(current_set_);
  if (current_set_->size <= 1)
    return;

  const uint32_t* current_set_it = current_set_->begin();
  // The first candidate_set we consider is the first set following
  // current_set in the ordering, if one exists.
  CandidateList::iterator begin_range_it =
      candidates_.begin() + current_set_index + 1;
  DeleteSubsumedFromRange(begin_range_it, candidates_.end(), current_set_it, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x18, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x39c0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x48(%rax)
cmpq $0x0, 0x48(%rax)
je 0x2f8c
jmp 0x2fab
leaq 0x623c(%rip), %rdi      # 0x91cf
leaq 0x61a3(%rip), %rsi      # 0x913d
movl $0xe5, %edx
leaq 0x6236(%rip), %rcx      # 0x91dc
callq 0x2140
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x1, 0x4(%rax)
ja 0x2fbb
jmp 0x3032
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x3c10
movq -0x48(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x18, %rdi
callq 0x3c30
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x3c60
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x3c60
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x18, %rdi
callq 0x3ca0
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
xorl %r8d, %r8d
callq 0x3190
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::DeleteSubsumedCandidates(std::vector<unsigned int, std::allocator<unsigned int>> const&)
void AllMaximalSetsLexicographic::DeleteSubsumedCandidates(const ItemSet& itemset) {
  if (itemset.size() <= 1)
    return;
  current_set_ = SetProperties::Create(0, itemset);

  const uint32_t* current_set_it = current_set_->begin();
  DeleteSubsumedFromRange(
      candidates_.begin(), candidates_.end(), current_set_it, 0);
  SetProperties::Delete(current_set_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3a70
cmpq $0x1, %rax
ja 0x3069
jmp 0x30d3
movq -0x10(%rbp), %rsi
xorl %edi, %edi
callq 0x8480
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
movq 0x48(%rax), %rdi
callq 0x3c10
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x18, %rdi
callq 0x3c30
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x3ca0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
xorl %r8d, %r8d
callq 0x3190
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x84d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
callq 0x39a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x315e
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x39c0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3151
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34a0
movq -0x18(%rbp), %rdi
callq 0x84d0
jmp 0x3153
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x30fb
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x4240
movq 0xae56(%rip), %rdi      # 0xdfc8
movq 0xae57(%rip), %rsi      # 0xdfd0
callq 0x2240
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
incq %rcx
movq %rcx, (%rax)
movl 0x58(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x34dd
jmp 0x34c9
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x34df
jmp 0x34d3
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x3500
jmp 0x351f
jmp 0x3551
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq 0xaadc(%rip), %rdi      # 0xdfc8
callq 0x22e0
movq %rax, %rdi
movl $0xa, %esi
callq 0x2290
jmp 0x3551
movq -0x10(%rbp), %rsi
movq 0xaabd(%rip), %rdi      # 0xdfc8
callq 0x84f0
movq %rax, %rdi
movl $0xa, %esi
callq 0x2290
jmp 0x3551
movq 0xaaa2(%rip), %rdi      # 0xdfc8
leaq 0x5e3a(%rip), %rsi      # 0x9367
callq 0x2200
leaq 0x5e34(%rip), %rdi      # 0x936d
leaq 0x5bfd(%rip), %rsi      # 0x913d
movl $0x19b, %edx            # imm = 0x19B
leaq 0x5e23(%rip), %rcx      # 0x936f
callq 0x2140
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::DeleteSubsumedSets(__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)
inline void AllMaximalSetsLexicographic::DeleteSubsumedSets(
    CandidateList::iterator* begin_range_it,
    CandidateList::iterator end_range_it,
    unsigned int depth) {
  // If current_set_->size() == depth, then the current set
  // cannot *properly* subsume any candidates.
  if (current_set_->size > depth) {
    while (*begin_range_it != end_range_it &&
           (!**begin_range_it || (**begin_range_it)->size == depth)) {
      if (**begin_range_it) {
        // Subsumed!
        items_in_ram_ -= (**begin_range_it)->size;
        SetProperties::Delete(**begin_range_it);
        **begin_range_it = 0;
      }
      ++(*begin_range_it);
      }
  } else {
    // Otherwise just skip over already-deleted itemsets.
    while (*begin_range_it != end_range_it && !**begin_range_it) {
      ++(*begin_range_it);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x48(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x3df8
jmp 0x3d41
movq -0x18(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x3cd0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x3d5c
jmp 0x3d91
movq -0x18(%rbp), %rdi
callq 0x3eb0
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, (%rcx)
movb %al, -0x2a(%rbp)
je 0x3d8b
movq -0x18(%rbp), %rdi
callq 0x3eb0
movq (%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x1c(%rbp), %eax
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x3d9a
jmp 0x3df6
movq -0x18(%rbp), %rdi
callq 0x3eb0
cmpq $0x0, (%rax)
je 0x3de8
movq -0x18(%rbp), %rdi
callq 0x3eb0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq (%rcx), %rcx
movl 0x4(%rcx), %edx
movl 0x50(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x50(%rax)
movq -0x18(%rbp), %rdi
callq 0x3eb0
movq (%rax), %rdi
callq 0x84d0
movq -0x18(%rbp), %rdi
callq 0x3eb0
movq $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x40a0
jmp 0x3d41
jmp 0x3e40
jmp 0x3dfa
movq -0x18(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x3cd0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x2b(%rbp)
jne 0x3e15
jmp 0x3e2a
movq -0x18(%rbp), %rdi
callq 0x3eb0
cmpq $0x0, (%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
testb $0x1, %al
jne 0x3e33
jmp 0x3e3e
movq -0x18(%rbp), %rdi
callq 0x40a0
jmp 0x3dfa
jmp 0x3e40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
leaq -0x8(%rbp), %rdi
callq 0x4310
cmpl $0x0, -0x28(%rbp)
jne 0x4027
movq -0x60(%rbp), %rdi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movq %rax, -0x68(%rbp)
addq $0x30, %rdi
callq 0x4330
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x401d
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
callq 0x3c30
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x30, %rdi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3b60
movq (%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3c60
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4350
testb $0x1, %al
jne 0x3ffa
jmp 0x3ffc
jmp 0x401b
leaq 0x53cb(%rip), %rdi      # 0x93ce
leaq 0x5133(%rip), %rsi      # 0x913d
movl $0x13f, %edx            # imm = 0x13F
leaq 0x53d9(%rip), %rcx      # 0x93ef
callq 0x2140
jmp 0x4025
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4056
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3560
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: roberto-bayardo[P]google-extremal-sets/data-source-iterator.cc
// Function: google_extremal_sets::DataSourceIterator::Get(char const*)
DataSourceIterator* DataSourceIterator::Get(const char* filename) {
  FILE* data = fopen(filename, "rb");
  if (!data) {
    std::cerr << "ERROR: Failed to open input file ("
              << filename << "): " << strerror(errno) << "\n";
    return 0;
  }
  return new DataSourceIterator(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2f20(%rip), %rsi      # 0x97e7
callq 0x22a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x693a
movq 0x7712(%rip), %rdi      # 0xdff0
leaq 0x2f05(%rip), %rsi      # 0x97ea
callq 0x2200
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2200
movq %rax, %rdi
leaq 0x2f0d(%rip), %rsi      # 0x980d
callq 0x2200
movq %rax, -0x30(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x20a0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x2200
movq %rax, %rdi
leaq 0x2752(%rip), %rsi      # 0x907d
callq 0x2200
movq $0x0, -0x8(%rbp)
jmp 0x697f
movl $0x30, %edi
callq 0x2220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x69a0
jmp 0x6959
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x697f
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x2230
jmp 0x6989
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: roberto-bayardo[P]google-extremal-sets/data-source-iterator.cc
// Function: google_extremal_sets::DataSourceIterator::Seek(long)
bool DataSourceIterator::Seek(off_t resume_offset) {
  if (fseeko(data_, resume_offset, 0)) {
    error_ = "fseek failed: " +  std::string(strerror(errno));
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x2120
cmpl $0x0, %eax
je 0x6afe
callq 0x2040
movl (%rax), %edi
callq 0x20a0
movq %rax, -0x88(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2380
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x7300
jmp 0x6a88
leaq 0x2d82(%rip), %rsi      # 0x9811
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x72b0
jmp 0x6a9e
movq -0x78(%rbp), %rdi
addq $0x10, %rdi
leaq -0x38(%rbp), %rsi
callq 0x22b0
leaq -0x38(%rbp), %rdi
callq 0x2130
leaq -0x58(%rbp), %rdi
callq 0x2130
leaq -0x59(%rbp), %rdi
callq 0x2260
movb $0x0, -0x1(%rbp)
jmp 0x6b02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x6af3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2130
leaq -0x59(%rbp), %rdi
callq 0x2260
jmp 0x6b10
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x2370
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x22e0
movq %rax, %rdi
leaq 0x12f5(%rip), %rsi      # 0x980e
callq 0x2200
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x8564
cmpl $0x0, -0x14(%rbp)
je 0x8545
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x2290
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl 0x8(%rax,%rcx,4), %esi
callq 0x22e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8525
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
movq 0x9b75(%rip), %rdi      # 0xbff0
leaq 0x5c46(%rip), %rsi      # 0x80c8
callq 0x21b0
movq %rax, %rdi
movq 0x9b2f(%rip), %rsi      # 0xbfc0
callq 0x21e0
movq 0x9b53(%rip), %rdi      # 0xbff0
leaq 0x5c3a(%rip), %rsi      # 0x80de
callq 0x21b0
movq %rax, %rdi
movq 0x9b0d(%rip), %rsi      # 0xbfc0
callq 0x21e0
movq 0x9b31(%rip), %rdi      # 0xbff0
leaq 0x5c40(%rip), %rsi      # 0x8106
callq 0x21b0
movq %rax, %rdi
movq 0x9aeb(%rip), %rsi      # 0xbfc0
callq 0x21e0
movq 0x9b0f(%rip), %rdi      # 0xbff0
leaq 0x5c2e(%rip), %rsi      # 0x8116
callq 0x21b0
movq %rax, %rdi
movq 0x9ac9(%rip), %rsi      # 0xbfc0
callq 0x21e0
movq 0x9aed(%rip), %rdi      # 0xbff0
leaq 0x5c1f(%rip), %rsi      # 0x8129
callq 0x21b0
movq %rax, %rdi
movq 0x9aa7(%rip), %rsi      # 0xbfc0
callq 0x21e0
movq 0x9acb(%rip), %rdi      # 0xbff0
leaq 0x5c2a(%rip), %rsi      # 0x8156
callq 0x21b0
movq %rax, %rdi
movq 0x9a85(%rip), %rsi      # 0xbfc0
callq 0x21e0
movq 0x9aa9(%rip), %rdi      # 0xbff0
leaq 0x5c29(%rip), %rsi      # 0x8177
callq 0x21b0
movq %rax, %rdi
movq 0x9a63(%rip), %rsi      # 0xbfc0
callq 0x21e0
movq 0x9a87(%rip), %rdi      # 0xbff0
leaq 0x5c22(%rip), %rsi      # 0x8192
callq 0x21b0
movq %rax, %rdi
movq 0x9a41(%rip), %rsi      # 0xbfc0
callq 0x21e0
movq 0x9a65(%rip), %rdi      # 0xbff0
leaq 0x5c1f(%rip), %rsi      # 0x81b1
callq 0x21b0
movq %rax, %rdi
movq 0x9a1f(%rip), %rsi      # 0xbfc0
callq 0x21e0
movl $0x1, %edi
callq 0x2240
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2290
movq %rax, -0x60(%rbp)
jmp 0x55c9
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x55f6
jmp 0x5701
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x2f, (%rax)
movq -0x20(%rbp), %rdi
callq 0x22a0
movq %rax, -0x70(%rbp)
jmp 0x5617
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x56f6
movq -0x38(%rbp), %rdi
addq $0x13, %rdi
movl -0xc(%rbp), %esi
callq 0x5720
testb $0x1, %al
jne 0x563f
jmp 0x5641
jmp 0x5608
movq -0x38(%rbp), %rdi
addq $0x13, %rdi
callq 0x20d0
addq -0x28(%rbp), %rax
cmpq $0x1000, %rax           # imm = 0x1000
jb 0x565c
jmp 0x5608
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x13, %rsi
callq 0x21a0
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x57a0
cmpl $0x0, %eax
je 0x56d3
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x569b
movq -0x68(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x58f0
jmp 0x5699
jmp 0x569b
movq -0x68(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5840
jmp 0x56b8
movl -0x74(%rbp), %esi
movq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x55a0
leaq -0x58(%rbp), %rdi
callq 0x3310
jmp 0x56f1
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x56ef
movq -0x68(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x58f0
jmp 0x56ed
jmp 0x56ef
jmp 0x56f1
jmp 0x5608
movq -0x20(%rbp), %rdi
callq 0x22d0
jmp 0x5701
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: akojo[P]quickfind/dir.cpp
// Function: skip(char const*, int)
static bool skip(const char *dirname, int opts) noexcept
{
    if (dirname[0] == '.') {
        return (!(opts & DW_HIDDEN)) ||
            (dirname[1] == '\0') ||
            (dirname[1] == '.' && dirname[2] == '\0');
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x578c
movl -0x14(%rbp), %ecx
andl $0x1, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x5782
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x5782
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x16(%rbp)
jne 0x577c
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5790
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: Crawler995[P]Cpp-Ray-Tracing/libs/vector3.cpp
// Function: Vector3::cross(Vector3)
Vector3 Vector3::cross(Vector3 v) {
    return Vector3(
        -z * v.get_y() + y * v.get_z(),
        z * v.get_x() - x * v.get_z(),
        -y * v.get_x() + x * v.get_y()
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd 0x10(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x70(%rbp)
callq 0x2f40
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x78(%rbp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
callq 0x2f60
movsd -0x80(%rbp), %xmm1
movsd -0x78(%rbp), %xmm2
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movaps %xmm0, %xmm3
movsd -0x70(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
callq 0x2f20
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x60(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
callq 0x2f60
movsd -0x68(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movaps %xmm0, %xmm3
movsd -0x58(%rbp), %xmm0
mulsd %xmm3, %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x2f20
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x30(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x2f40
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
movsd -0x30(%rbp), %xmm4
movq -0x28(%rbp), %rdi
movsd -0x20(%rbp), %xmm1
movaps %xmm0, %xmm5
movsd -0x18(%rbp), %xmm0
mulsd %xmm5, %xmm3
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
callq 0x2c50
movq -0x10(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3b60
movq -0xc0(%rbp), %rdi
leaq 0x96c3(%rip), %rax      # 0xcc70
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0x2c90
leaq -0x20(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x2c50
movq -0xc0(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
leaq -0x7c(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x4c50
leaq -0x88(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x4c50
leaq -0x98(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x4c50
movq -0x7c(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0x74(%rbp), %eax
movl %eax, -0xa0(%rbp)
movq -0xa8(%rbp), %rsi
movl -0xa0(%rbp), %edx
movq -0x88(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0xb0(%rbp)
movq -0xb8(%rbp), %rcx
movl -0xb0(%rbp), %r8d
leaq -0x70(%rbp), %rdi
xorps %xmm3, %xmm3
leaq -0x98(%rbp), %rax
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
movq (%rax), %r9
movq %r9, (%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rsp)
callq 0x5240
movq -0xc0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3b80
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Crawler995[P]Cpp-Ray-Tracing/libs/intersect_result.h
// Function: IntersectResult::IntersectResult(Geometry*, double, Vector3, Vector3)
IntersectResult(Geometry* s, double d, Vector3 pos, Vector3 nor) {
        geometry = s;
        distance = d;
        position = pos;
        normal = nor;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
callq 0x2c90
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x2c90
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rsi
movq %rsi, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movq (%rdx), %rsi
movq %rsi, 0x10(%rax)
movq 0x8(%rdx), %rsi
movq %rsi, 0x18(%rax)
movq 0x10(%rdx), %rdx
movq %rdx, 0x20(%rax)
movq (%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x38(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Crawler995[P]Cpp-Ray-Tracing/libs/perspective_camera.cpp
// Function: PerspectiveCamera::PerspectiveCamera(double, Vector3, Vector3, Vector3, Vector3)
PerspectiveCamera::PerspectiveCamera(double d, Vector3 lb, Vector3 h, Vector3 v, Vector3 p) {
    distance = d;
    left_bottom_pos = lb;
    horizontal = h;
    vertical = v;
    camera_pos = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x2c90
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x2c90
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x2c90
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x2c90
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rax)
movq (%rdi), %r8
movq %r8, 0x8(%rax)
movq 0x8(%rdi), %r8
movq %r8, 0x10(%rax)
movq 0x10(%rdi), %rdi
movq %rdi, 0x18(%rax)
movq (%rsi), %rdi
movq %rdi, 0x20(%rax)
movq 0x8(%rsi), %rdi
movq %rdi, 0x28(%rax)
movq 0x10(%rsi), %rsi
movq %rsi, 0x30(%rax)
movq (%rdx), %rsi
movq %rsi, 0x38(%rax)
movq 0x8(%rdx), %rsi
movq %rsi, 0x40(%rax)
movq 0x10(%rdx), %rdx
movq %rdx, 0x48(%rax)
movq (%rcx), %rdx
movq %rdx, 0x50(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x58(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x60(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0xe8(%rbp)
movq %rdi, -0xe0(%rbp)
movq %rsi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xf0(%rbp)
movq 0x50(%rsi), %rax
movq %rax, -0x30(%rbp)
movq 0x58(%rsi), %rax
movq %rax, -0x28(%rbp)
movq 0x60(%rsi), %rax
movq %rax, -0x20(%rbp)
movq %rsi, %rax
addq $0x8, %rax
movq %rax, -0xf8(%rbp)
addq $0x20, %rsi
movsd -0x10(%rbp), %xmm0
leaq -0xa8(%rbp), %rdi
callq 0x3030
movq -0xf8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
leaq -0xa8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2e70
movq -0xf0(%rbp), %rsi
addq $0x38, %rsi
movsd -0x18(%rbp), %xmm0
leaq -0xc0(%rbp), %rdi
callq 0x3030
leaq -0x78(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0xc0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2e70
movq -0xf0(%rbp), %rax
movq 0x50(%rax), %rcx
movq %rcx, -0xd8(%rbp)
movq 0x58(%rax), %rcx
movq %rcx, -0xd0(%rbp)
movq 0x60(%rax), %rax
movq %rax, -0xc8(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0xd8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2f80
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2d90
movq -0xe8(%rbp), %rdi
leaq -0x30(%rbp), %rcx
leaq -0x48(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x3350
movq -0xe0(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0xc8(%rbp)
movq %rdi, -0xe0(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x4440
movl %eax, -0xc(%rbp)
movsd 0x4ead(%rip), %xmm0     # 0x9100
movsd %xmm0, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x2c50
leaq -0x48(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x2c50
movq -0xc8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rcx
leaq -0x48(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x3bc0
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x439a
movq -0xd0(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x4460
movq -0xd8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0xe8(%rbp)
leaq -0xc0(%rbp), %rdi
movl $0x30, %edx
callq 0x20e0
movq -0xe8(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
movups -0xc0(%rbp), %xmm0
movups -0xb0(%rbp), %xmm1
movups -0xa0(%rbp), %xmm2
movq %rsp, %rcx
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
leaq -0x90(%rbp), %rdi
callq *%rax
cmpq $0x0, -0x90(%rbp)
je 0x438a
movsd -0x88(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x438a
movq -0xc8(%rbp), %rdi
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x90(%rbp), %rsi
movl $0x40, %edx
callq 0x20e0
jmp 0x438c
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x42d1
movq -0xe0(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rsi, -0x1c(%rbp)
movl %edx, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rcx, -0x38(%rbp)
movl %r8d, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq %rdi, -0x40(%rbp)
movsd %xmm0, -0x48(%rbp)
movsd %xmm1, -0x50(%rbp)
movsd %xmm2, -0x58(%rbp)
movsd %xmm3, -0x60(%rbp)
movq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x57c0
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %rax
leaq 0x7a41(%rip), %rdx      # 0xccf0
addq $0x10, %rdx
movq %rdx, (%rax)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x60(%rbp), %xmm0
movsd %xmm0, 0x48(%rax)
movq -0xc(%rbp), %rdx
movq %rdx, 0x20(%rax)
movl -0x4(%rbp), %edx
movl %edx, 0x28(%rax)
movq -0x28(%rbp), %rdx
movq %rdx, 0x2c(%rax)
movl -0x20(%rbp), %edx
movl %edx, 0x34(%rax)
movq (%rcx), %rdx
movq %rdx, 0x38(%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x40(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x57c0
movq -0x28(%rbp), %rax
leaq 0x79bc(%rip), %rcx      # 0xccf0
addq $0x10, %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x3dfd(%rip), %xmm0     # 0x9148
movsd %xmm0, 0x18(%rax)
movsd 0x3df0(%rip), %xmm0     # 0x9148
movsd %xmm0, 0x10(%rax)
movsd 0x3ddb(%rip), %xmm0     # 0x9140
movsd %xmm0, 0x48(%rax)
leaq -0x14(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x4c50
movq -0x28(%rbp), %rax
movq -0x14(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x28(%rax)
leaq -0x20(%rbp), %rdi
movl $0xff, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x4c50
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x40(%rax)
movq 0x38(%rax), %rcx
movq %rcx, 0x2c(%rax)
movl 0x40(%rax), %ecx
movl %ecx, 0x34(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq %rsi, -0x1c(%rbp)
movl %edx, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rcx, -0x38(%rbp)
movl %r8d, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq %rdi, -0x40(%rbp)
movsd %xmm0, -0x48(%rbp)
movsd %xmm1, -0x50(%rbp)
movsd %xmm2, -0x58(%rbp)
movsd %xmm3, -0x60(%rbp)
movsd %xmm4, -0x68(%rbp)
movq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x57c0
movq -0x78(%rbp), %rcx
movq -0x70(%rbp), %rax
leaq 0x7499(%rip), %rdx      # 0xcd20
addq $0x10, %rdx
movq %rdx, (%rax)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x60(%rbp), %xmm0
movsd %xmm0, 0x48(%rax)
movsd -0x68(%rbp), %xmm0
movsd %xmm0, 0x50(%rax)
movq -0xc(%rbp), %rdx
movq %rdx, 0x20(%rax)
movl -0x4(%rbp), %edx
movl %edx, 0x28(%rax)
movq -0x28(%rbp), %rdx
movq %rdx, 0x2c(%rax)
movl -0x20(%rbp), %edx
movl %edx, 0x34(%rax)
movq (%rcx), %rdx
movq %rdx, 0x38(%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x40(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1b0, %rsp            # imm = 0x1B0
leaq 0x40(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x160(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x168(%rbp)
leaq -0x20(%rbp), %rdi
movsd 0x33cc(%rip), %xmm2     # 0x9098
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x2c50
movq -0x160(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movl $0x30, %edx
callq 0x20e0
movq -0x168(%rbp), %rdi
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x5f00
movq -0x160(%rbp), %rsi
movsd %xmm0, -0x28(%rbp)
leaq -0x90(%rbp), %rdi
movl $0x30, %edx
callq 0x20e0
movq -0x168(%rbp), %rdi
movq -0x158(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x40(%rax)
movups -0xa8(%rbp), %xmm0
movups %xmm0, 0x30(%rax)
movups -0x90(%rbp), %xmm0
movups -0x80(%rbp), %xmm1
movups -0x70(%rbp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x6050
movq -0x160(%rbp), %rsi
movsd %xmm0, -0x60(%rbp)
leaq -0xe0(%rbp), %rdi
movl $0x30, %edx
callq 0x20e0
movq -0x168(%rbp), %rdi
movq -0x158(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0xf8(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0xf0(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x40(%rax)
movups -0xf8(%rbp), %xmm0
movups %xmm0, 0x30(%rax)
movups -0xe0(%rbp), %xmm0
movups -0xd0(%rbp), %xmm1
movups -0xc0(%rbp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x6220
movq -0x160(%rbp), %rsi
movsd %xmm0, -0xb0(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x3470
leaq -0x118(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x2df0
movq -0x158(%rbp), %rdi
leaq -0x118(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x30d0
movsd %xmm0, -0x100(%rbp)
leaq -0x150(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2d90
movq -0x158(%rbp), %rdi
leaq -0x150(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x30d0
movsd %xmm0, -0x138(%rbp)
movsd -0x28(%rbp), %xmm0
mulsd -0x60(%rbp), %xmm0
mulsd -0xb0(%rbp), %xmm0
movsd -0x100(%rbp), %xmm1
mulsd -0x138(%rbp), %xmm1
movsd 0x31ea(%rip), %xmm2     # 0x90d8
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nop