LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/quancs[P]EAVC/./eavc.h
// Function: update_best_sol()
inline void update_best_sol() {
    memcpy(vInBest, vInC, sizeof(VerticeStatus)*vNum);

    bestSize = total_IN_ABS + cvSize;
#ifdef WIN32
    finish = clock();
    bestTime = (static_cast<double>(finish - gstart));
#else
    times(&finish);
    bestTime = double(finish.tms_utime + finish.tms_stime - startTime);
#endif
    bestStep = step;
    //cout << "c Best vertex cover size = " << best_c_size <<  ", SearchSteps = " << best_step <<  ", SearchTime = " << best_comp_time << endl;
}

// Assembly:
pushq %rax
movq 0x2679(%rip), %rdi      # 0x71a8
movq 0x265a(%rip), %rsi      # 0x7190
movl 0x2600(%rip), %edx      # 0x713c
callq 0x2120
movl 0x26a9(%rip), %eax      # 0x71f0
addl 0x26a7(%rip), %eax      # 0x71f4
movl %eax, 0x26a5(%rip)      # 0x71f8
leaq 0x26a6(%rip), %rdi      # 0x7200
callq 0x21b0
movq 0x26a2(%rip), %rax      # 0x7208
addq 0x2693(%rip), %rax      # 0x7200
movslq 0x26c4(%rip), %rcx      # 0x7238
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x26ec(%rip)     # 0x7270
movl 0x26aa(%rip), %eax      # 0x7234
movl %eax, 0x26e8(%rip)      # 0x7278
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/quancs[P]EAVC/./eavc.h
// Function: cover(unsigned int)
inline
void cover(unsigned int e) {
    unsigned int index, last_uncov_edge;

    //since the edge is satisfied, its position can be reused to store the last_uncov_edge
    last_uncov_edge = uncovEdges[--ueSize];
    index = uncovEdgeIndexes[e];
    uncovEdges[index] = last_uncov_edge;
    uncovEdgeIndexes[last_uncov_edge] = index;
}

// Assembly:
movq 0x25a3(%rip), %rax      # 0x7158
movl 0x2631(%rip), %ecx      # 0x71ec
decl %ecx
movl %ecx, 0x2629(%rip)      # 0x71ec
movl (%rax,%rcx,4), %ecx
movq 0x2593(%rip), %rdx      # 0x7160
movl %edi, %esi
movl (%rdx,%rsi,4), %esi
movl %ecx, (%rax,%rsi,4)
movl %esi, (%rdx,%rcx,4)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkom-cloud[P]mmseg/src/Mmseg.cpp
// Function: mmsegSpace::MMSeg::get_chunks(__gnu_cxx::__normal_iterator<char16_t const*, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>, __gnu_cxx::__normal_iterator<char16_t const*, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>, int)
std::vector<MMSeg::Chunk> MMSeg::get_chunks(StringIt _start, StringIt _end, int depth) {
    std::vector<Chunk> ret;

    // "递归"实现
    std::function<void(StringIt, StringIt, int, std::vector<StringP>, std::vector<int>)> get_chunks_it = [&] (StringIt start, StringIt end, int n, std::vector<StringP> segs, std::vector<int> inDict) {
      if (n == 0 || start == end) {
        ret.emplace_back(std::move(segs), std::move(inDict), char_freqs_);
      }
      else {
        auto m = dict_.match_all(start, end);
        //std::cout<<"Match_all Length : "<<m.size()<<std::endl;
        for (auto& w: m) {
          auto nsegs = segs;
          auto ninDict = inDict;
          auto len = length(w);
          //std::cout<<TransCode::to_utf8(String(start, start+len))<<std::endl;
          nsegs.emplace_back(std::move(w));
          ninDict.emplace_back(1);
          get_chunks_it(start + len, end, n - 1, std::move(nsegs), std::move(ninDict));
        }

        //std::cout<<TransCode::to_utf8(String(start, start+1))<<std::endl;
        segs.emplace_back(start, start +1 );
        inDict.emplace_back(0);
        get_chunks_it(start + 1, end, n - 1, std::move(segs), std::move(inDict));
      }
    };

    get_chunks_it(_start, _end, depth, std::vector<StringP>{}, std::vector<int>{});
    return ret;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
andq $0x0, 0x10(%rdi)
vxorps %xmm0, %xmm0, %xmm0
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
vmovups %xmm0, (%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rsp)
pushq $0x18
popq %rdi
vzeroupper
callq 0x2250
leaq 0x40(%rsp), %r8
leaq 0x20(%rsp), %r9
movq %rbx, (%rax)
movq %rsp, %rdi
movq %r12, 0x8(%rax)
movq %rdi, 0x10(%rax)
movq %rax, (%rdi)
leaq 0x7ba(%rip), %rax       # 0x2d64
vxorps %xmm0, %xmm0, %xmm0
andq $0x0, 0x10(%r8)
andq $0x0, 0x10(%r9)
movq %rax, 0x18(%rdi)
leaq 0xb03(%rip), %rax       # 0x30c6
vmovaps %xmm0, (%r8)
vmovaps %xmm0, (%r9)
movq %rax, 0x10(%rdi)
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x3126
leaq 0x20(%rsp), %rdi
callq 0x3f00
leaq 0x40(%rsp), %rdi
callq 0x3ef2
movq %rsp, %rdi
callq 0x315c
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %rdi
movq %rax, %r14
callq 0x3f00
leaq 0x40(%rsp), %rdi
callq 0x3ef2
jmp 0x2626
movq %rax, %r14
movq %rsp, %rdi
callq 0x315c
movq %rbx, %rdi
callq 0x3178
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/jkom-cloud[P]mmseg/src/Mmseg.cpp
// Function: mmsegSpace::MMSeg::unload()
void mmsegSpace::MMSeg::unload() {
    mtx.lock();
    dict_.clear();
    is_inited = false;
    mtx.unlock();
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x8(%rdi), %r14
movq %rdi, %rbx
movq %r14, %rdi
callq 0x319a
leaq 0x68(%rbx), %rdi
callq 0x3376
movb $0x0, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/jkom-cloud[P]mmseg/src/Mmseg.cpp
// Function: mmsegSpace::MMSeg::getInitStatus()
bool mmsegSpace::MMSeg::getInitStatus() {
    bool status = false;
    mtx.lock();
    status = is_inited;
    mtx.unlock();
    return status;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x8(%rdi), %r14
movq %rdi, %rbx
movq %r14, %rdi
callq 0x319a
movb (%rbx), %bl
movq %r14, %rdi
callq 0x21a0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkom-cloud[P]mmseg/src/TransCode.hpp
// Function: TransCode::from_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline static std::u16string from_utf8(const std::string& in) {
	std::u16string out;
#ifdef MMSEG_GBK
	gbkTrans(in, out);
#else
	utf8ToUnicode(in, out);
#endif
	return out;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x10(%rdi), %rax
movq %rdi, %rbx
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
andw $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x33b1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %rax, %r14
callq 0x321c
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkom-cloud[P]mmseg/src/TransCode.hpp
// Function: TransCode::to_utf8(std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>> const&)
inline static std::string to_utf8(const std::u16string& in) {
    std::string out;
#ifdef MMSEG_GBK
	gbkTrans(in.begin(), in.end(), out);
#else
	unicodeToUtf8(in.begin(), in.end(), out);
#endif
	return out;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x10(%rdi), %rax
movq %rdi, %rbx
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq (%rsi), %rdi
leaq (%rdi,%rax,2), %rsi
movq %rbx, %rdx
callq 0x36a5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %rax, %r14
callq 0x2100
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/jkom-cloud[P]mmseg/src/Trie.hpp
// Function: mmsegSpace::Trie::add(std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>> const&)
void add(const String& word) {
			Node *current = &root_;
			for (auto ch: word) {
				auto it = current->trans_.find(ch);
				if (it == current->trans_.end()) {
					auto ret = current->trans_.emplace(ch, new Node{});
                                        //std::cout << "Current: " << current << " Alloc:" << ret.first->second << std::endl;
					current = ret.first->second;
				}
				else {
					current = it->second;
				}
			}
			current->val_ = true;// 词条存在
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rsi), %rbp
movq (%rsi), %r13
leaq 0xe(%rsp), %rbx
leaq 0x10(%rsp), %r12
movq %rdi, %r15
xorl %r14d, %r14d
addq %rbp, %rbp
cmpq %r14, %rbp
je 0x3345
movzwl (%r13,%r14), %eax
movq %r15, %rdi
movq %rbx, %rsi
movw %ax, 0xe(%rsp)
callq 0x39d4
testq %rax, %rax
jne 0x333b
pushq $0x40
popq %rdi
callq 0x2250
vxorps %xmm0, %xmm0, %xmm0
leaq 0x30(%rax), %rcx
movq %rax, 0x10(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
vmovups %ymm0, 0x20(%rax)
vxorps %xmm0, %xmm0, %xmm0
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
vmovups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
vmovups %xmm0, 0x28(%rax)
movb $0x0, 0x38(%rax)
vzeroupper
callq 0x3a54
movq 0x10(%rax), %r15
addq $0x2, %r14
jmp 0x32cc
movb $0x1, 0x38(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkom-cloud[P]mmseg/src/Trie.hpp
// Function: mmsegSpace::Trie::clear()
void clear() {
                         Node *r = &root_;
                         for (auto a = r->trans_.begin(); a != r->trans_.end();a++)
                           clear_(a->second);
                         r->trans_.clear();
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x10(%rdi), %r14
movq %rdi, %rbx
movq (%r14), %r14
testq %r14, %r14
je 0x3397
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3e44
jmp 0x3381
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3e9a
// File: /workspace/github_cpp_makefile_star2_O2/jkom-cloud[P]mmseg/src/util/StringUtil.hpp
// Function: bool utilSpace::utf8ToUnicode<std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>(char const*, unsigned long, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>&)
bool utf8ToUnicode(const char * const str, size_t len, Uint16Container& vec) {
  if(!str) {
    return false;
  }
  char ch1, ch2;
  uint16_t tmp;
  vec.clear();
  for(size_t i = 0; i < len;) {
    if(!(str[i] & 0x80)) { // 0xxxxxxx
      vec.push_back(str[i]);
      i++;
    } else if ((uint8_t)str[i] <= 0xdf && i + 1 < len) { // 110xxxxxx
      ch1 = (str[i] >> 2) & 0x07;
      ch2 = (str[i+1] & 0x3f) | ((str[i] & 0x03) << 6 );
      tmp = (((uint16_t(ch1) & 0x00ff ) << 8) | (uint16_t(ch2) & 0x00ff));
      vec.push_back(tmp);
      i += 2;
    } else if((uint8_t)str[i] <= 0xef && i + 2 < len) {
      ch1 = ((uint8_t)str[i] << 4) | ((str[i+1] >> 2) & 0x0f );
      ch2 = (((uint8_t)str[i+1]<<6) & 0xc0) | (str[i+2] & 0x3f);
      tmp = (((uint16_t(ch1) & 0x00ff ) << 8) | (uint16_t(ch2) & 0x00ff));
      vec.push_back(tmp);
      i += 3;
    } else {
      return false;
    }
  }
  return true;
}

// Assembly:
testq %rdi, %rdi
je 0x349c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
andq $0x0, 0x8(%rdx)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq (%rdx), %rax
andw $0x0, (%rax)
pushq $0x1
popq %rbp
cmpq %r14, %r12
setae %al
jae 0x348d
movzbl (%r15,%r12), %ecx
testb %cl, %cl
js 0x340c
movq %rbp, %r13
jmp 0x347a
cmpb $-0x21, %cl
ja 0x343c
leaq 0x1(%r12), %rdx
cmpq %r14, %rdx
jae 0x3441
movzbl (%r15,%rdx), %edx
movzwl %cx, %eax
shlb $0x6, %cl
andl $0x1c, %eax
movzbl %cl, %ecx
shll $0x6, %eax
andl $0x3f, %edx
orl %edx, %ecx
orl %ecx, %eax
movl %eax, %ecx
pushq $0x2
jmp 0x3478
cmpb $-0x11, %cl
ja 0x348d
leaq 0x2(%r12), %rdx
cmpq %r14, %rdx
jae 0x348d
movb 0x1(%r15,%r12), %al
shlb $0x4, %cl
movl %eax, %edx
shlb $0x6, %al
shrb $0x2, %dl
movzbl %al, %eax
andb $0xf, %dl
orb %cl, %dl
movzbl 0x2(%r15,%r12), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movzbl %dl, %ecx
shll $0x8, %ecx
orl %eax, %ecx
pushq $0x3
popq %r13
movzwl %cx, %esi
movq %rbx, %rdi
callq 0x34a0
addq %r13, %r12
jmp 0x33f2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkom-cloud[P]mmseg/src/util/StringUtil.hpp
// Function: void utilSpace::unicodeToUtf8<__gnu_cxx::__normal_iterator<char16_t const*, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>>(__gnu_cxx::__normal_iterator<char16_t const*, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>, __gnu_cxx::__normal_iterator<char16_t const*, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void unicodeToUtf8(Uint16ContainerConIter begin, Uint16ContainerConIter end, string& res) {
  res.clear();
  uint16_t ui;
  while(begin != end) {
    ui = *begin;
    if(ui <= 0x7f) {
      res += char(ui);
    } else if(ui <= 0x7ff) {
      res += char(((ui>>6) & 0x1f) | 0xc0);
      res += char((ui & 0x3f) | 0x80);
    } else {
      res += char(((ui >> 12) & 0x0f )| 0xe0);
      res += char(((ui>>6) & 0x3f )| 0x80 );
      res += char((ui & 0x3f) | 0x80);
    }
    begin ++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
andq $0x0, 0x8(%rdx)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rax
movb $0x0, (%rax)
cmpq %r14, %r15
je 0x372c
movzwl (%r15), %ebp
cmpw $0x7f, %bp
jbe 0x371a
cmpw $0x7ff, %bp             # imm = 0x7FF
ja 0x36e3
movl %ebp, %eax
shrl $0x6, %eax
orb $-0x40, %al
movsbl %al, %esi
jmp 0x370a
movzwl %bp, %r12d
movq %rbx, %rdi
movl %r12d, %eax
shrl $0xc, %eax
orb $-0x20, %al
movsbl %al, %esi
callq 0x21d0
shrl $0x6, %r12d
andb $0x3f, %r12b
orb $-0x80, %r12b
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0x21d0
andb $0x3f, %bpl
orb $-0x80, %bpl
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x21d0
addq $0x2, %r15
jmp 0x36c1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkom-cloud[P]mmseg/src/Trie.hpp
// Function: mmsegSpace::Trie::clear_(mmsegSpace::Trie::Node*)
void clear_(Node * pNode) {
                         for (auto a = pNode->trans_.begin(); a != pNode->trans_.end();a++) {
                           clear_(a->second);
                         }
                         //std::cout<<"Free : "<<pNode<<std::endl;
                         delete pNode;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x10(%rsi), %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%r15), %r15
testq %r15, %r15
je 0x3e69
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x3e44
jmp 0x3e53
movq %rbx, %rdi
callq 0x3e7e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/jkom-cloud[P]mmseg/src/Trie.hpp
// Function: mmsegSpace::Trie::match_all(__gnu_cxx::__normal_iterator<char16_t const*, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>, __gnu_cxx::__normal_iterator<char16_t const*, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>)
std::vector<StringP> match_all(StringIt start, StringIt end) {
			std::vector<StringP> ret;
			Node *current = &root_;
			StringIt _start = start;
			for (; start != end; ++start) {
				auto ch = *start;
				auto it = current->trans_.find(ch);
				if (it == current->trans_.end())
					break;
				current = it->second;
				if (current->val_) {
                                  ret.emplace_back(_start, start + 1);
                                }
			}
			return ret;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
andq $0x0, 0x10(%rdi)
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %r12
leaq 0x6(%rsp), %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %rbx
vmovups %xmm0, (%rdi)
movq %rdx, (%r12)
cmpq %r14, %r15
je 0x408e
movzwl (%r15), %eax
movw %ax, 0x6(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x39d4
testq %rax, %rax
je 0x408e
movq 0x10(%rax), %rbp
cmpb $0x1, 0x38(%rbp)
jne 0x4088
leaq 0x2(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4198
addq $0x2, %r15
jmp 0x4047
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x40a2
movq %rbx, %rdi
movq %rax, %r14
callq 0x3ef2
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkom-cloud[P]mmseg/src/MmsegWrapper.cpp
// Function: copySegs
char * copySegs(struct tagMMSeg * pInstance, const char * pOrigStr) {
  std::string istr(pOrigStr); 
  std::string ostr;

  ostr = pInstance->ptr_mmseg->segment(istr);
  char * out = new char[ostr.length() + 1];

  strcpy(out, ostr.c_str());

  return out;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %rdx
movq %rdi, %rbx
movq %r14, %rdi
callq 0x20e0
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rbx), %rsi
leaq 0x48(%rsp), %rdi
pushq $0x3
popq %rcx
movq %r14, %rdx
callq 0x263e
leaq 0x8(%rsp), %rbx
leaq 0x48(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2270
movq %r14, %rdi
callq 0x2100
movq 0x8(%rbx), %rdi
incq %rdi
callq 0x2030
leaq 0x8(%rsp), %r14
movq %rax, %rbx
movq %rax, %rdi
movq (%r14), %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2100
leaq 0x28(%rsp), %rdi
callq 0x2100
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x50e0
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x2100
leaq 0x28(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: BitmapSA<C4PXS, 10000ul>::New()
T* New()
	{
		for (size_t i = 0; i < maskN; i++)
		{
			uint64_t m = ~mask[i];
			if (m)
			{
				size_t j = __builtin_ffsll(m) - 1;
				size_t idx = i*64 + j;
				if (idx >= N) return nullptr;
				mask[i] |= (uint64_t) 1 << j;
				return &data[idx];
			}
		}
		return nullptr;
	}

// Assembly:
leaq 0x30d40(%rdi), %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq $-0x2740, %rdx          # imm = 0xD8C0
je 0x2175
movq (%rcx), %rsi
cmpq $-0x1, %rsi
jne 0x2149
addq $0x8, %rcx
addq $-0x40, %rdx
jmp 0x212d
movq %rsi, %rax
notq %rax
bsfq %rax, %r8
movq %r8, %rax
subq %rdx, %rax
cmpq $0x270f, %rax           # imm = 0x270F
jbe 0x2164
xorl %eax, %eax
retq
btsq %r8, %rsi
movq %rsi, (%rcx)
imulq $0x14, %rax, %rax
addq %rax, %rdi
movq %rdi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: BitmapSA<C4PXS, 10000ul>::Delete(C4PXS*)
void Delete(T *el)
	{
		size_t idx = el - data;
		assert(idx < N);
		size_t i = idx / 64, j = idx % 64;
		mask[i] &= ~((uint64_t) 1 << j);
	}

// Assembly:
movq %rsi, %rax
subq %rdi, %rax
pushq $0x14
popq %rcx
cqto
idivq %rcx
cmpq $0x2710, %rax           # imm = 0x2710
jae 0x21d3
pushq $-0x2
popq %rdx
movl %eax, %ecx
rolq %cl, %rdx
shrq $0x6, %rax
andq %rdx, 0x30d40(%rdi,%rax,8)
retq
pushq %rax
leaq 0x1fa8(%rip), %rdi      # 0x4183
leaq 0x1f12(%rip), %rsi      # 0x40f4
leaq 0x1fa2(%rip), %rcx      # 0x418b
pushq $0x21
popq %rdx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: BitmapSA<C4PXS, 10000ul>::Iterator<C4PXS, BitmapSA<C4PXS, 10000ul>>::operator++()
Iterator& operator++()
		{
			assert(array);
			while (!cur)
			{
				el += 64 - pos;
				if (el >= N) break;
				pos = 0;
				cur = array->mask[(el + 1) / 64];
			}
			size_t inc = __builtin_ffsll(cur);
			el += inc - start;
			pos += inc;
			cur >>= inc;
			if (el >= N)
			{
				array = nullptr;
				el = 0;
			}
			return *this;
		}

// Assembly:
pushq %rax
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x228b
movq 0x20(%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
testq %rax, %rax
jne 0x2247
subq %rdx, %rsi
leaq 0x40(%rsi), %r8
movq %r8, 0x8(%rdi)
cmpq $0x270f, %r8            # imm = 0x270F
ja 0x2244
andq $0x0, 0x10(%rdi)
addq $0x41, %rsi
shrq $0x6, %rsi
movq 0x30d40(%rcx,%rsi,8), %rax
movq %rax, 0x20(%rdi)
movq %r8, %rsi
xorl %edx, %edx
jmp 0x220b
movq %r8, %rsi
bsfq %rax, %rcx
pushq $-0x1
popq %r8
cmovneq %rcx, %r8
leaq 0x1(%r8), %rcx
movq %rcx, %r9
subq 0x18(%rdi), %r9
addq %rsi, %r9
movq %r9, 0x8(%rdi)
shrq %cl, %rax
leaq (%rdx,%r8), %rcx
incq %rcx
movq %rcx, 0x10(%rdi)
movq %rax, 0x20(%rdi)
cmpq $0x2710, %r9            # imm = 0x2710
jb 0x2286
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, %rax
popq %rcx
retq
leaq 0x1f39(%rip), %rdi      # 0x41cb
leaq 0x1e5b(%rip), %rsi      # 0x40f4
leaq 0x1f31(%rip), %rcx      # 0x41d1
pushq $0x37
popq %rdx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: BitmapSA<C4PXS, 10000ul>::Iterator<C4PXS, BitmapSA<C4PXS, 10000ul>>::Iterator(BitmapSA<C4PXS, 10000ul>*)
Iterator(SA *array) : array(array), el(0), pos(64), cur(0)
		{
			start = 1;
			if (array)
				operator++();
			start = 0;
		}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
andq $0x0, 0x8(%rdi)
movq $0x40, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
movq $0x1, 0x18(%rdi)
testq %rsi, %rsi
je 0x22d6
movq %rbx, %rdi
callq 0x21f2
andq $0x0, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: ChunkSA<C4PXS, 10000ul, 500ul>::New()
T* New()
	{
		for (size_t i = 0; i < MaxChunk; i++)
		{
			// Create new chunk if necessary.
			if (!Chunk[i])
			{
				Chunk[i] = new T[ChunkSize];
				ChunkFill[i] = 0;
			}
			// Check this chunk for space.
			if (ChunkFill[i] < ChunkSize)
				for (size_t j = 0; j < ChunkSize; j++)
					if (!UsedElements[i*ChunkSize + j])
					{
						UsedElements.set(i*ChunkSize + j);
						ChunkFill[i]++;
						return &Chunk[i][j];
					}
		}
		return nullptr;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x140(%rdi), %r15
xorl %r14d, %r14d
xorl %ebp, %ebp
xorl %r13d, %r13d
cmpq $0x14, %r13
je 0x25a2
cmpq $0x0, (%rbx,%r13,8)
je 0x2536
cmpq $0x1f3, 0xa0(%rbx,%r13,8) # imm = 0x1F3
jbe 0x255f
incq %r13
addq $0x1f4, %rbp            # imm = 0x1F4
jmp 0x250b
movl $0x2710, %edi           # imm = 0x2710
callq 0x1030
movq %rax, %r12
movl $0x2710, %edx           # imm = 0x2710
movq %rax, %rdi
xorl %esi, %esi
callq 0x1080
movq %r12, (%rbx,%r13,8)
andq $0x0, 0xa0(%rbx,%r13,8)
movq %rbp, %rsi
xorl %r12d, %r12d
cmpq $-0x2710, %r12          # imm = 0xD8F0
je 0x252a
movq %rsi, %rax
shrq $0x6, %rax
movq (%r15,%rax,8), %rax
btq %rsi, %rax
jae 0x2588
addq $-0x14, %r12
incq %rsi
jmp 0x2565
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x26d8
incq 0xa0(%rbx,%r13,8)
movq (%rbx,%r13,8), %r14
subq %r12, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: ChunkSA<C4PXS, 10000ul, 500ul>::Delete(C4PXS*)
void Delete(T *el)
	{
		size_t i, j;
		for (i = 0; i < MaxChunk; i++)
			if (ChunkFill[i])
				if (el >= &Chunk[i][0] && el < &Chunk[i][ChunkSize])
					break;
		assert(i < MaxChunk);

		j = el - &Chunk[i][0];
		assert(UsedElements[i*ChunkSize + j]);
		UsedElements.reset(i*ChunkSize + j);

		if (--ChunkFill[i] == 0)
		{
			delete[] Chunk[i];
			Chunk[i] = nullptr;
		}
	}

// Assembly:
pushq %rbx
xorl %ecx, %ecx
movq %rdi, %rbx
cmpq $-0x2710, %rcx          # imm = 0xD8F0
je 0x264c
cmpq $0x0, 0xa0(%rbx)
je 0x25ed
movq (%rbx), %rax
cmpq %rsi, %rax
setbe %dl
leaq 0x2710(%rax), %r8
cmpq %rsi, %r8
seta %r8b
testb %r8b, %dl
jne 0x25fa
addq $0x8, %rbx
addq $-0x1f4, %rcx           # imm = 0xFE0C
jmp 0x25ba
subq %rax, %rsi
pushq $0x14
popq %r8
movq %rsi, %rax
cqto
idivq %r8
subq %rcx, %rax
movq %rax, %rcx
shrq $0x6, %rcx
movq 0x140(%rdi,%rcx,8), %rcx
btq %rax, %rcx
jae 0x266b
addq $0x140, %rdi            # imm = 0x140
movq %rax, %rsi
callq 0x27ec
decq 0xa0(%rbx)
jne 0x264a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2646
callq 0x1110
andq $0x0, (%rbx)
popq %rbx
retq
leaq 0x1c46(%rip), %rdi      # 0x4299
leaq 0x1a9a(%rip), %rsi      # 0x40f4
leaq 0x1c45(%rip), %rcx      # 0x42a6
movl $0x92, %edx
callq 0x1090
leaq 0x1c84(%rip), %rdi      # 0x42f6
leaq 0x1a7b(%rip), %rsi      # 0x40f4
leaq 0x1c26(%rip), %rcx      # 0x42a6
movl $0x95, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: ChunkSA<C4PXS, 10000ul, 500ul>::~ChunkSA()
~ChunkSA()
	{
		for (size_t i = 0; i < MaxChunk; i++)
		{
			if (Chunk[i]) delete[] Chunk[i];
			Chunk[i] = nullptr;
			ChunkFill[i] = 0;
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $-0xa0, %r14
testq %r14, %r14
je 0x26cf
movq 0xa0(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x26b7
callq 0x1110
andq $0x0, 0xa0(%rbx,%r14)
andq $0x0, 0x140(%rbx,%r14)
addq $0x8, %r14
jmp 0x26a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: ChunkSA<C4PXS, 10000ul, 500ul>::Iterator<C4PXS, ChunkSA<C4PXS, 10000ul, 500ul>>::next(bool)
Iterator& next(bool return_next)
		{
			for (; i < MaxChunk; i++, j = 0)
			{
				if (array->ChunkFill[i])
				{
					for (; j < ChunkSize; j++)
					{
						if (array->UsedElements[i*ChunkSize + j] && return_next)
							return *this;
						return_next = true;
					}
				}
				return_next = true;
			}
			// We're at the end.
			array = nullptr;
			i = j = 0;
			return *this;
		}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %r8
imulq $0x1f4, %rdx, %rdi      # imm = 0x1F4
cmpq $0x13, %rdx
ja 0x27e0
cmpq $0x0, 0xa0(%rcx,%rdx,8)
je 0x27c5
cmpq $0x1f3, %r8             # imm = 0x1F3
ja 0x27c5
leaq (%rdi,%r8), %r9
movq %r9, %r10
shrq $0x6, %r10
movq 0x140(%rcx,%r10,8), %r10
btq %r9, %r10
setb %r9b
testb %r9b, %sil
jne 0x27eb
incq %r8
movq %r8, 0x10(%rax)
movb $0x1, %sil
jmp 0x2790
incq %rdx
movq %rdx, 0x8(%rax)
andq $0x0, 0x10(%rax)
addq $0x1f4, %rdi            # imm = 0x1F4
movb $0x1, %sil
xorl %r8d, %r8d
jmp 0x277f
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: StaticChunkSA<C4PXS, 10000ul, 500ul>::New()
T* New()
	{
		for (size_t i = 0; i < MaxChunk; i++)
		{
			// Check this chunk for space.
			if (ChunkFill[i] < ChunkSize)
				for (size_t j = 0; j < ChunkSize; j++)
					if (!UsedElements[i*ChunkSize + j])
					{
						UsedElements.set(i*ChunkSize + j);
						ChunkFill[i]++;
						return &Chunk[i][j];
					}
		}
		return nullptr;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x30de0, %rdi          # imm = 0x30DE0
xorl %eax, %eax
xorl %ecx, %ecx
movq %rbx, %r14
xorl %r15d, %r15d
cmpq $0x14, %r15
je 0x2aa0
cmpq $0x1f3, 0x30d40(%rbx,%r15,8) # imm = 0x1F3
ja 0x2a77
movq %rcx, %rsi
xorl %r12d, %r12d
cmpq $-0x2710, %r12          # imm = 0xD8F0
je 0x2a77
movq %rsi, %rdx
shrq $0x6, %rdx
movq (%rdi,%rdx,8), %rdx
btq %rsi, %rdx
jae 0x2a8a
addq $-0x14, %r12
incq %rsi
jmp 0x2a54
incq %r15
addq $0x2710, %r14           # imm = 0x2710
addq $0x1f4, %rcx            # imm = 0x1F4
jmp 0x2a3a
pushq $0x1
popq %rdx
callq 0x26d8
incq 0x30d40(%rbx,%r15,8)
subq %r12, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: StaticChunkSA<C4PXS, 10000ul, 500ul>::Delete(C4PXS*)
void Delete(T *el)
	{
		size_t i, j;
		for (i = 0; i < MaxChunk; i++)
			if (ChunkFill[i])
				if (el >= &Chunk[i][0] && el < &Chunk[i][ChunkSize])
					break;
		assert(i < MaxChunk);

		j = el - &Chunk[i][0];
		assert(UsedElements[i*ChunkSize + j]);
		UsedElements.reset(i*ChunkSize + j);

		--ChunkFill[i];
	}

// Assembly:
pushq %rbx
leaq 0x30d40(%rdi), %rbx
movq %rsi, %rax
subq %rdi, %rax
xorl %ecx, %ecx
movq %rdi, %rdx
cmpq $-0x2710, %rcx          # imm = 0xD8F0
je 0x2b36
cmpq $0x0, (%rbx)
je 0x2ae8
cmpq %rsi, %rdx
setbe %r8b
leaq 0x2710(%rdx), %r9
cmpq %rsi, %r9
seta %r9b
testb %r9b, %r8b
jne 0x2b02
addq $0x8, %rbx
addq $-0x1f4, %rcx           # imm = 0xFE0C
addq $-0x2710, %rax          # imm = 0xD8F0
addq $0x2710, %rdx           # imm = 0x2710
jmp 0x2abf
pushq $0x14
popq %rsi
cqto
idivq %rsi
subq %rcx, %rax
movq %rax, %rcx
shrq $0x6, %rcx
movq 0x30de0(%rdi,%rcx,8), %rcx
btq %rax, %rcx
jae 0x2b55
addq $0x30de0, %rdi          # imm = 0x30DE0
movq %rax, %rsi
callq 0x27ec
decq (%rbx)
popq %rbx
retq
leaq 0x175c(%rip), %rdi      # 0x4299
leaq 0x15b0(%rip), %rsi      # 0x40f4
leaq 0x17d7(%rip), %rcx      # 0x4322
movl $0xfb, %edx
callq 0x1090
leaq 0x179a(%rip), %rdi      # 0x42f6
leaq 0x1591(%rip), %rsi      # 0x40f4
leaq 0x17b8(%rip), %rcx      # 0x4322
movl $0xfe, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: LinkedListSA<C4PXS, 10000ul>::LinkedListSA()
LinkedListSA() : firstUsed(nullptr), firstFree(array)
	{
		// Everything starts in the free list.
		for (size_t i = 1; i < N; i++)
			array[i-1].next = &array[i];
		array[N-1].next = nullptr;
	}

// Assembly:
pushq $0x20
popq %rax
xorps %xmm0, %xmm0
andl $0x0, -0x10(%rdi,%rax)
movups %xmm0, -0x20(%rdi,%rax)
movb $0x0, (%rdi,%rax)
addq $0x28, %rax
cmpq $0x61aa0, %rax          # imm = 0x61AA0
jne 0x2da4
andq $0x0, 0x61a80(%rdi)
movq %rdi, 0x61a88(%rdi)
leaq 0x28(%rdi), %rax
movl $0x270f, %ecx           # imm = 0x270F
subq $0x1, %rcx
jb 0x2de6
movq %rax, -0x10(%rax)
addq $0x28, %rax
jmp 0x2dd6
andq $0x0, 0x61a70(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: LinkedListSA<C4PXS, 10000ul>::Delete(C4PXS*)
void Delete(T *dataEl)
	{
		ListElement *el = reinterpret_cast<ListElement*>(dataEl);
		assert(el >= &array[0] && el < &array[N]);
		assert(el->used);
		el->used = false;

		ListElement *next = el->next;
		bool lookingForUsed = false, lookingForFree = !!firstFree;
		if (el == firstUsed)
			firstUsed = next;
		else
			lookingForUsed = true;

		ListElement *prevEl = el;
		while (--prevEl >= array && (lookingForUsed || lookingForFree))
		{
			if (lookingForUsed && prevEl->used)
			{
				prevEl->next = next;
				lookingForUsed = false;
			}
			if (lookingForFree && !prevEl->used)
			{
				el->next = prevEl->next;
				prevEl->next = el;
				lookingForFree = false;
			}
		}

		if (!!firstFree == lookingForFree)
		{
			if (firstFree)
				el->next = firstFree;
			else
				el->next = nullptr;
			firstFree = el;
		}
	}

// Assembly:
pushq %rax
cmpq %rdi, %rsi
jb 0x2ef8
leaq 0x61a80(%rdi), %r9
cmpq %rsi, %r9
jbe 0x2ef8
cmpb $0x0, 0x20(%rsi)
je 0x2f17
movb $0x0, 0x20(%rsi)
movq 0x18(%rsi), %rcx
movq 0x61a88(%rdi), %rax
testq %rax, %rax
setne %dl
cmpq %rsi, 0x61a80(%rdi)
setne %r8b
jne 0x2e93
movq %rcx, (%r9)
movq %rsi, %r9
addq $-0x28, %r9
cmpq %rdi, %r9
jb 0x2ede
movl %r8d, %r10d
orb %dl, %r10b
testb $0x1, %r10b
je 0x2ede
testb $0x1, %r8b
je 0x2ebf
movb $0x1, %r8b
cmpb $0x1, 0x20(%r9)
jne 0x2ec2
movq %rcx, 0x18(%r9)
xorl %r8d, %r8d
testb $0x1, %dl
je 0x2e96
cmpb $0x1, 0x20(%r9)
je 0x2e96
movq 0x18(%r9), %rdx
movq %rdx, 0x18(%rsi)
movq %rsi, 0x18(%r9)
xorl %edx, %edx
jmp 0x2e96
testq %rax, %rax
setne %cl
xorb %dl, %cl
testb $0x1, %cl
jne 0x2ef6
movq %rax, 0x18(%rsi)
movq %rsi, 0x61a88(%rdi)
popq %rax
retq
leaq 0x1479(%rip), %rdi      # 0x4378
leaq 0x11ee(%rip), %rsi      # 0x40f4
leaq 0x148d(%rip), %rcx      # 0x439a
movl $0x175, %edx            # imm = 0x175
callq 0x1090
leaq 0x14c0(%rip), %rdi      # 0x43de
leaq 0x11cf(%rip), %rsi      # 0x40f4
leaq 0x146e(%rip), %rcx      # 0x439a
movl $0x176, %edx            # imm = 0x176
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: LinkedListBitmapSA<C4PXS, 10000ul>::New()
T* New()
	{
		if (!firstFree) return nullptr;
		ListElement *el = firstFree;
		firstFree = el->next;
		UsedElements.set(el - array);

		// The hard part is now to insert the element in the right place in the list. We could just
		// put it in the front, but this would destroy cache locality during iteration.
		if (firstUsed)
		{
			ListElement *prevEl = el;
			while (--prevEl >= array)
				if (UsedElements[prevEl - array])
				{
					el->next = prevEl->next;
					prevEl->next = el;
					goto done;
				}
			// We're at the front.
			el->next = firstUsed;
		}
		else
			el->next = nullptr;
		firstUsed = el;
done:
		return &el->data;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x4e208(%rdi), %rbx
testq %rbx, %rbx
je 0x31b8
movq %rdi, %r14
movq 0x18(%rbx), %rax
movq %rax, 0x4e208(%rdi)
leaq 0x4e210(%rdi), %r15
movq %rbx, %r12
subq %rdi, %r12
movq %r12, %rsi
sarq $0x5, %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x26d8
leaq 0x4e200(%r14), %rdx
movq 0x4e200(%r14), %rax
testq %rax, %rax
je 0x31ae
leaq 0x18(%rbx), %rcx
addq $-0x20, %r12
leaq -0x38(%rcx), %rsi
cmpq %r14, %rsi
jb 0x31ae
movq %r12, %rsi
sarq $0x5, %rsi
movq %rsi, %rdi
shrq $0x6, %rdi
movq (%r15,%rdi,8), %rdi
addq $-0x20, %rcx
addq $-0x20, %r12
btq %rsi, %rdi
jae 0x3180
movq (%rcx), %rax
jmp 0x31b1
movq %rdx, %rcx
movq %rax, 0x18(%rbx)
movq %rbx, (%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: LinkedListBitmapSA<C4PXS, 10000ul>::Delete(C4PXS*)
void Delete(T *dataEl)
	{
		ListElement *el = reinterpret_cast<ListElement*>(dataEl);
		assert(el >= &array[0] && el < &array[N]);
		assert(UsedElements[el - array]);
		UsedElements.reset(el - array);

		ListElement *next = el->next;
		bool lookingForUsed = false, lookingForFree = !!firstFree;
		if (el == firstUsed)
			firstUsed = next;
		else
			lookingForUsed = true;

		ListElement *prevEl = el;
		while (--prevEl >= array && (lookingForUsed || lookingForFree))
		{
			if (lookingForUsed && UsedElements[prevEl - array])
			{
				prevEl->next = next;
				lookingForUsed = false;
			}
			if (lookingForFree && !UsedElements[prevEl - array])
			{
				el->next = prevEl->next;
				prevEl->next = el;
				lookingForFree = false;
			}
		}

		if (!!firstFree == lookingForFree)
		{
			if (firstFree)
				el->next = firstFree;
			else
				el->next = nullptr;
			firstFree = el;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
subq %rdi, %rsi
jb 0x32e4
movq %rdi, %r14
leaq 0x4e200(%rdi), %r12
cmpq %rbx, %r12
jbe 0x32e4
sarq $0x5, %rsi
movq %rsi, %rax
shrq $0x6, %rax
movq 0x4e210(%r14,%rax,8), %rax
btq %rsi, %rax
jae 0x3303
leaq 0x4e210(%r14), %r15
movq %r15, %rdi
callq 0x27ec
movq 0x18(%rbx), %rcx
movq 0x4e208(%r14), %rax
testq %rax, %rax
setne %dl
cmpq %rbx, 0x4e200(%r14)
setne %r8b
jne 0x323d
movq %rcx, (%r12)
pushq $-0x20
popq %rsi
subq %r14, %rsi
movq %rbx, %rdi
leaq (%rsi,%rdi), %r9
addq $-0x20, %rdi
cmpq %r14, %rdi
jb 0x32c0
movl %r8d, %r10d
orb %dl, %r10b
testb $0x1, %r10b
je 0x32c0
testb $0x1, %r8b
je 0x3281
movq %r9, %r8
sarq $0x5, %r8
movq %r8, %r10
shrq $0x6, %r10
movq (%r15,%r10,8), %r10
btq %r8, %r10
jae 0x32ab
movq %rcx, 0x18(%rdi)
xorl %r8d, %r8d
testb $0x1, %dl
je 0x32a1
movq %r9, %r10
sarq $0x5, %r10
movq %r10, %r11
shrq $0x6, %r11
movq (%r15,%r11,8), %r11
btq %r10, %r11
jae 0x32b0
addq $-0x20, %rdi
addq $-0x20, %r9
jmp 0x324e
movb $0x1, %r8b
jmp 0x3284
movq 0x18(%rdi), %rdx
movq %rdx, 0x18(%rbx)
movq %rbx, 0x18(%rdi)
xorl %edx, %edx
jmp 0x3246
testq %rax, %rax
setne %cl
xorb %dl, %cl
testb $0x1, %cl
jne 0x32d8
movq %rax, 0x18(%rbx)
movq %rbx, 0x4e208(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x108d(%rip), %rdi      # 0x4378
leaq 0xe02(%rip), %rsi       # 0x40f4
leaq 0x10ee(%rip), %rcx      # 0x43e7
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x1090
leaq 0x1127(%rip), %rdi      # 0x4431
leaq 0xde3(%rip), %rsi       # 0x40f4
leaq 0x10cf(%rip), %rcx      # 0x43e7
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: DoubleLinkedListSA<C4PXS, 10000ul>::New()
T* New()
	{
		if (!firstFree) return nullptr;
		ListElement *el = firstFree;
		firstFree = el->next;
		el->used = true;

		// The hard part is now to insert the element in the right place in the list. We could just
		// put it in the front, but this would destroy cache locality during iteration.
		if (firstUsed)
		{
			ListElement *prevEl = el;
			while (--prevEl >= array)
				if (prevEl->used)
				{
					el->next = prevEl->next;
					el->prev = prevEl;
					prevEl->next = el;
					if (el->next)
						el->next->prev = el;
					goto done;
				}
			// We're at the front.
			el->next = firstUsed;
			el->next->prev = el;
		}
		else
			el->next = nullptr;
		firstUsed = el;
		el->prev = nullptr;
done:
		return &el->data;
	}

// Assembly:
movq 0x75308(%rdi), %rax
testq %rax, %rax
je 0x3552
movq 0x18(%rax), %rcx
movq %rcx, 0x75308(%rdi)
movb $0x1, 0x28(%rax)
movq 0x75300(%rdi), %rcx
testq %rcx, %rcx
je 0x3553
movq %rax, %rsi
leaq -0x30(%rsi), %rdx
cmpq %rdi, %rdx
jb 0x355a
cmpb $0x1, -0x8(%rsi)
movq %rdx, %rsi
jne 0x3524
movq 0x18(%rdx), %rcx
movq %rcx, 0x18(%rax)
movq %rdx, 0x20(%rax)
movq %rax, 0x18(%rdx)
movq 0x18(%rax), %rcx
movq %rax, %rdx
testq %rcx, %rcx
jne 0x356e
retq
andq $0x0, 0x18(%rax)
jmp 0x3562
movq %rcx, 0x18(%rax)
movq %rax, 0x20(%rcx)
movq %rax, 0x75300(%rdi)
xorl %edx, %edx
movq %rax, %rcx
movq %rdx, 0x20(%rcx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: DoubleLinkedListSA<C4PXS, 10000ul>::Delete(C4PXS*)
void Delete(T *dataEl)
	{
		ListElement *el = reinterpret_cast<ListElement*>(dataEl);
		assert(el >= &array[0] && el < &array[N]);
		assert(el->used);
		el->used = false;

		ListElement *next = el->next;
		if (el == firstUsed)
			firstUsed = next;
		if (next)
			next->prev = el->prev;
		if (el->prev)
			el->prev->next = next;

		if (firstFree)
		{
			ListElement *prevEl = el;
			while (--prevEl >= array)
			{
				if (!prevEl->used)
				{
					el->next = prevEl->next;
					prevEl->next = el;
					return;
				}
			}
			el->next = firstFree;
		}
		else
			el->next = nullptr;
		firstFree = el;
	}

// Assembly:
pushq %rax
cmpq %rdi, %rsi
jb 0x35f5
leaq 0x75300(%rdi), %rcx
cmpq %rsi, %rcx
jbe 0x35f5
cmpb $0x0, 0x28(%rsi)
je 0x3614
movb $0x0, 0x28(%rsi)
movq 0x18(%rsi), %rax
cmpq %rsi, (%rcx)
jne 0x35a0
movq %rax, (%rcx)
movq 0x20(%rsi), %rcx
testq %rax, %rax
je 0x35ad
movq %rcx, 0x20(%rax)
testq %rcx, %rcx
je 0x35b6
movq %rax, 0x18(%rcx)
leaq 0x75308(%rdi), %rcx
movq 0x75308(%rdi), %rax
testq %rax, %rax
je 0x35e9
leaq 0x18(%rsi), %r8
leaq -0x48(%r8), %rdx
cmpq %rdi, %rdx
jb 0x35e9
leaq -0x30(%r8), %rdx
cmpb $0x0, -0x20(%r8)
movq %rdx, %r8
jne 0x35cd
movq (%rdx), %rax
jmp 0x35ec
movq %rcx, %rdx
movq %rax, 0x18(%rsi)
movq %rsi, (%rdx)
popq %rax
retq
leaq 0xd7c(%rip), %rdi       # 0x4378
leaq 0xaf1(%rip), %rsi       # 0x40f4
leaq 0xe40(%rip), %rcx       # 0x444a
movl $0x2d6, %edx            # imm = 0x2D6
callq 0x1090
leaq 0xdc3(%rip), %rdi       # 0x43de
leaq 0xad2(%rip), %rsi       # 0x40f4
leaq 0xe21(%rip), %rcx       # 0x444a
movl $0x2d7, %edx            # imm = 0x2D7
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: UnorderedLinkedListSA<C4PXS, 10000ul>::Delete(C4PXS*)
void Delete(T *dataEl)
	{
		ListElement *el = reinterpret_cast<ListElement*>(dataEl);
		assert(el >= &array[0] && el < &array[N]);
		assert(el->used);
		el->used = false;

		ListElement *next = el->next;
		if (el == firstUsed)
			firstUsed = next;
		else
		{
			for (ListElement *prevEl = firstUsed; prevEl; prevEl = prevEl->next)
				if (prevEl->next == el)
				{
					prevEl->next = next;
					break;
				}
		}
		el->next = firstFree;
		firstFree = el;
	}

// Assembly:
pushq %rax
cmpq %rdi, %rsi
jb 0x3882
leaq 0x61a80(%rdi), %rax
cmpq %rsi, %rax
jbe 0x3882
cmpb $0x0, 0x20(%rsi)
je 0x38a1
movb $0x0, 0x20(%rsi)
movq 0x18(%rsi), %rcx
movq (%rax), %rdx
cmpq %rsi, %rdx
je 0x386b
testq %rdx, %rdx
je 0x386e
movq %rdx, %rax
movq 0x18(%rdx), %rdx
cmpq %rsi, %rdx
jne 0x3856
addq $0x18, %rax
movq %rcx, (%rax)
movq 0x61a88(%rdi), %rax
movq %rax, 0x18(%rsi)
movq %rsi, 0x61a88(%rdi)
popq %rax
retq
leaq 0xaef(%rip), %rdi       # 0x4378
leaq 0x864(%rip), %rsi       # 0x40f4
leaq 0xbfd(%rip), %rcx       # 0x4494
movl $0x262, %edx            # imm = 0x262
callq 0x1090
leaq 0xb36(%rip), %rdi       # 0x43de
leaq 0x845(%rip), %rsi       # 0x40f4
leaq 0xbde(%rip), %rcx       # 0x4494
movl $0x263, %edx            # imm = 0x263
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/lluchs[P]sparsearray/./sparsearray.h
// Function: ReorderingSA<C4PXS, 10000ul>::Delete(C4PXS*)
void Delete(T *el)
	{
		assert(el >= data && el < firstFree);
		auto lastUsed = firstFree - 1;
		if (el != lastUsed)
			*el = std::move(*lastUsed);
		firstFree--;
	}

// Assembly:
cmpq %rdi, %rsi
jb 0x3a93
movq 0x30d40(%rdi), %rax
cmpq %rsi, %rax
jbe 0x3a93
leaq -0x14(%rax), %rcx
cmpq %rsi, %rcx
je 0x3a87
movl 0x10(%rcx), %eax
movl %eax, 0x10(%rsi)
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x30d40(%rdi), %rax
addq $-0x14, %rax
movq %rax, 0x30d40(%rdi)
retq
pushq %rax
leaq 0xa46(%rip), %rdi       # 0x44e1
leaq 0x652(%rip), %rsi       # 0x40f4
leaq 0xa55(%rip), %rcx       # 0x44fe
movl $0x31f, %edx            # imm = 0x31F
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/dekanfrus[P]pThreads/osproj2b.cpp
// Function: fib(void*)
void *fib(void*)
{
	int total;

	// Iterates through and calculates the fibonnaci sequence
	for (int i = 0; i <= num; i++) {
		if (i <= 1) {
			total = i;
		}

		else if (num == 0)
		{
			// Quit the thread if the user's number was 0 as
			// there is nothing to calculate
			pthread_exit(0);
		}
		else
		{
			// Grab the values from the two previous indices
			// add them together and store them in total
			total = fibNum[i-1] + fibNum[i-2];
		}

		// Push the total to the end of the series vector
		fibNum.push_back(total);
	}

	// Exit the thread upon completion
	pthread_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r15d, %r15d
leaq 0x2e10(%rip), %rbx      # 0x40d0
leaq -0x1c(%rbp), %r14
movslq 0x2e01(%rip), %rax      # 0x40cc
cmpq %rax, %r15
jg 0x1303
cmpq $0x1, %r15
ja 0x12db
movl %r15d, %eax
jmp 0x12f0
testl %eax, %eax
je 0x1303
movq 0x2dea(%rip), %rcx      # 0x40d0
movl -0x8(%rcx,%r15,4), %eax
addl -0x4(%rcx,%r15,4), %eax
movl %eax, -0x1c(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1408
incq %r15
jmp 0x12c4
xorl %edi, %edi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/dekanfrus[P]pThreads/osproj2b.cpp
// Function: main
int main(int argc, char *argv[]) {

	// Local variable declaration
	pthread_t tid;
	double total = 0;

	// Store arguments into the number variable
	num = atoi(argv[1]);

	// Create a new thread and run the fib function
	pthread_create(&tid, NULL, &fib, NULL);

	// Join the thread to the main process and wait for it to complete
	// before continuing.
	pthread_join(tid, NULL);

	// Display the entire Fibonacci series 
	cout << "Series: " << endl;
	for (int i = 0; i < num; i++)
		cout << fibNum[i] << endl;

	int size = fibNum.size();

	// Display the actual Fibonacci value
	cout << "Total: ";
	total = fibNum[size] + fibNum[size - 1];
	cout << total << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rsi), %rdi
callq 0x10f0
movl %eax, 0x2da8(%rip)      # 0x40cc
leaq -0x7f(%rip), %rdx       # 0x12ac
xorl %r14d, %r14d
leaq -0x18(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1140
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x10a0
movq 0x2c89(%rip), %rbx      # 0x3fd8
leaq 0xcae(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x10b0
movq %rax, %rdi
callq 0x1060
movslq 0x2d5f(%rip), %rax      # 0x40cc
cmpq %rax, %r14
jge 0x1392
movq 0x2d57(%rip), %rax      # 0x40d0
movl (%rax,%r14,4), %esi
movq %rbx, %rdi
callq 0x1120
movq %rax, %rdi
callq 0x1060
incq %r14
jmp 0x1366
movq 0x2d3f(%rip), %r14      # 0x40d8
subq 0x2d30(%rip), %r14      # 0x40d0
movq 0x2c31(%rip), %rbx      # 0x3fd8
leaq 0xc5f(%rip), %rsi       # 0x200d
movq %rbx, %rdi
callq 0x10b0
shlq $0x1e, %r14
movq 0x2d0f(%rip), %rax      # 0x40d0
movq %r14, %rcx
sarq $0x1e, %rcx
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
addq %r14, %rdx
sarq $0x1e, %rdx
movl (%rax,%rdx), %edx
addl (%rax,%rcx), %edx
cvtsi2sd %edx, %xmm0
movq %rbx, %rdi
callq 0x1100
movq %rax, %rdi
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/utils.cpp
// Function: Utils::readFile[abi:cxx11](char const*)
std::string readFile(const char* fileName){
    std::stringstream ss;
    std::ifstream file(fileName,std::ios::binary);
	ss<<file.rdbuf(); // read stream buffer
            
	if(ss.str().empty()){
            throw std::invalid_argument("File Error: Job description file cannot be found or an empty file!");
        }
        
        return ss.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x3b8, %rsp            # imm = 0x3B8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1c0(%rbp), %rdi
callq 0x2180
leaq -0x3c8(%rbp), %rdi
pushq $0x4
popq %rdx
movq %r14, %rsi
callq 0x23c0
leaq -0x1b0(%rbp), %rdi
leaq -0x3b8(%rbp), %rsi
callq 0x2070
leaq -0x1a8(%rbp), %r14
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2340
leaq -0x38(%rbp), %rdi
movq 0x8(%rdi), %r15
callq 0x2100
testq %r15, %r15
je 0x2d5c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2340
leaq -0x3c8(%rbp), %rdi
callq 0x2080
leaq -0x1c0(%rbp), %rdi
callq 0x21b0
movq %rbx, %rax
addq $0x3b8, %rsp            # imm = 0x3B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %r14
leaq 0x9296(%rip), %rsi      # 0xc004
movq %rax, %rdi
callq 0x23e0
movq 0xf263(%rip), %rsi      # 0x11fe0
movq 0xf24c(%rip), %rdx      # 0x11fd0
movq %r14, %rdi
callq 0x2390
movq %rax, %rbx
movq %r14, %rdi
callq 0x21a0
jmp 0x2da3
jmp 0x2da0
movq %rax, %rbx
jmp 0x2daf
movq %rax, %rbx
leaq -0x3c8(%rbp), %rdi
callq 0x2080
leaq -0x1c0(%rbp), %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/utils.cpp
// Function: Utils::arg_check(char*)
bool arg_check(char* str){
        try{
            std::string tmp(str);
            int a = std::stoi(tmp);
        }
        catch (std::exception& e){
            throw std::invalid_argument("Arguement Error: Argument is NaN or an overbound number!");
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rsi
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20c0
leaq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x2f06
leaq -0x38(%rbp), %rdi
callq 0x2100
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2100
jmp 0x2e38
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x2e8b
movq %rbx, %rdi
callq 0x20d0
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %r14
leaq 0x91ef(%rip), %rsi      # 0xc047
movq %rax, %rdi
callq 0x23e0
movq 0xf179(%rip), %rsi      # 0x11fe0
movq 0xf162(%rip), %rdx      # 0x11fd0
movq %r14, %rdi
callq 0x2390
movq %rax, %rbx
jmp 0x2e86
movq %rax, %rbx
movq %r14, %rdi
callq 0x21a0
callq 0x2380
movq %rbx, %rdi
callq 0x23b0
movq %rax, %rdi
callq 0x2f27
nop