LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ke6jjj[P]r-dat/DifferentialClockDetector.cc
// Function: DifferentialClockDetector::EvaluateClock()
void
DifferentialClockDetector::EvaluateClock()
{
  int i, maxI, minI;
  float max, min, ratio;

  for (max = min = mWindow[0], i = 1, maxI = 0; i < mWindowSize; i++)
  {
    //
    // Find the highest peak.
    //
    if (mWindow[i] > max) {
      max = mWindow[i];
      maxI = i;
    }
    //
    // And the lowest valley.
    //
    if (mWindow[i] < min)
      min = mWindow[i];
  }
  
  if (maxI != mMaximumDiffPos) {
    //
    // We've found a new maximum differential position.
    // In the future we might calculate clock error here.
    //
    mMaximumDiffPos = maxI;

    //
    // Queue up the next firing position.
    //
    mNextSyncPos = FirePosition(mMaximumDiffPos, mWindowSize);
  }
  
  //
  // If there is a significant difference between the highest
  // peak and the lowest valley then we have a good clock signal.
  //
  if (max > 0.0)
    ratio = min / max;
  else
    ratio = 0.0;

  bool newDetectionState = ratio <= mDetectionThresholdRatio;

  if (newDetectionState != mDetected && mListener != NULL) {
    mListener->ClockDetected(newDetectionState);
  }

  mDetected = newDetectionState;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x10(%rdi), %rax
movss (%rax), %xmm0
xorl %edx, %edx
pushq $0x1
popq %rsi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
jbe 0x7891
movss (%rax,%rsi,4), %xmm2
ucomiss %xmm0, %xmm2
cmoval %esi, %edx
movaps %xmm2, %xmm3
maxss %xmm0, %xmm3
minss %xmm1, %xmm2
incq %rsi
movaps %xmm3, %xmm0
movaps %xmm2, %xmm1
jmp 0x786b
movslq %edx, %rdx
cmpq %rdx, 0x20(%rbx)
je 0x78b1
movq %rdx, 0x20(%rbx)
leaq -0x1(%rcx), %rax
shrq %rax
addq %rdx, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x30(%rbx)
divss %xmm0, %xmm1
xorps %xmm2, %xmm2
cmpltss %xmm0, %xmm2
andps %xmm1, %xmm2
movss 0xc(%rbx), %xmm0
ucomiss %xmm2, %xmm0
setae %bpl
cmpb %bpl, 0x1c(%rbx)
je 0x78e9
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x78e9
xorl %esi, %esi
ucomiss %xmm2, %xmm0
setae %sil
movq (%rdi), %rax
callq *(%rax)
movb %bpl, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ke6jjj[P]r-dat/RDATSlopeDecoder.cc
// Function: RDATSlopeDecoder::Reset()
void
RDATSlopeDecoder::Reset()
{
  mClockDetector.Reset();
  mSymbolWindow.Reset();
  mOverallSignalLevel = 0.0;
  mTrackInProgress = false;
  mTrackSampleCount = 0;
#if 1
  mSampleNumber = 0;
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x7770
leaq 0x58(%rbx), %rdi
callq 0x7cec
andl $0x0, 0x88(%rbx)
movb $0x0, 0x80(%rbx)
andq $0x0, 0x78(%rbx)
andq $0x0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/johnbeard[P]visitor-double-dispatch/visitor-double-dispatch.cpp
// Function: main
int main(int argc, char** argv)
{
    const auto objects = getObjects();

    // The renderer
    DataRenderer renderer;

    // Render each object in the container
    for (const auto& obj: objects)
    {
        obj->accept(renderer);
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
leaq 0xdce(%rip), %rsi       # 0x203e
leaq 0xdcd(%rip), %rdx       # 0x2044
leaq 0x10(%rsp), %rdi
callq 0x14a5
movq 0x10(%rsp), %rax
andq $0x0, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x1634
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x12ae
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x12c4
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x1c(%rsp), %rsi
movl $0x10, (%rsi)
leaq 0x3c(%rsp), %rdx
movl $0x20, (%rdx)
leaq 0x10(%rsp), %rdi
callq 0x156c
movq 0x10(%rsp), %rax
andq $0x0, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x1634
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1311
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1327
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x1c(%rsp), %rsi
movl $0x4048f5c3, (%rsi)     # imm = 0x4048F5C3
leaq 0xd11(%rip), %rdx       # 0x204a
leaq 0x10(%rsp), %rdi
callq 0x15a3
movq 0x10(%rsp), %rax
andq $0x0, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x1634
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1370
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1386
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x29fb(%rip), %rax      # 0x3d88
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %r15
cmpq %r15, %r14
je 0x13b6
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
addq $0x8, %r14
jmp 0x139f
leaq 0x20(%rsp), %rdi
callq 0x1416
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x13d4
jmp 0x1401
jmp 0x13d4
jmp 0x1401
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13e7
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1404
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1404
jmp 0x1401
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1416
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/ruippeixotog[P]algo-lib/bipartite-matching.cpp
// Function: bpmDfs(int)
bool bpmDfs(int u) {
  for(int v = 0; v < n; v++) {
    if(graph[u][v]) {
      if(seen[v]) continue;
      seen[v] = true;

      if(matchR[v] < 0 || bpmDfs(matchR[v])) {
        matchL[u] = v; matchR[v] = u;
        return true;
      }
    }
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %r12
movl 0x2ef4(%rip), %eax      # 0x4044
movq %r12, (%rsp)
shlq $0x7, %r12
leaq 0x7171(%rip), %r15      # 0x82d0
xorl %r14d, %r14d
leaq 0x2ee7(%rip), %r13      # 0x4050
leaq 0x6ee0(%rip), %rbp      # 0x8050
movslq %eax, %rbx
cmpq %rbx, %r14
jge 0x11c1
leaq (%r12,%r14), %rcx
cmpb $0x1, (%r13,%rcx)
jne 0x11a6
cmpb $0x0, (%r14,%rbp)
jne 0x11a6
movb $0x1, (%r14,%rbp)
movl (%r15), %edi
testl %edi, %edi
js 0x11af
callq 0x113c
testb %al, %al
jne 0x11af
movl 0x2e9e(%rip), %eax      # 0x4044
incq %r14
addq $0x4, %r15
jmp 0x1170
leaq 0x6f1a(%rip), %rax      # 0x80d0
movq (%rsp), %rcx
movl %r14d, (%rax,%rcx,4)
movl %ecx, (%r15)
cmpq %rbx, %r14
setl %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ruippeixotog[P]algo-lib/bipartite-matching.cpp
// Function: bpm()
int bpm() {
  memset(matchL, -1, sizeof(matchL));
  memset(matchR, -1, sizeof(matchR));
  int cnt = 0;
  for(int i = 0; i < m; i++) {
    memset(seen, false, sizeof(seen));
    if(bpmDfs(i)) cnt++;
  }
  return cnt;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x6ef0(%rip), %rdi      # 0x80d0
movl $0x200, %edx            # imm = 0x200
movl $0xff, %esi
callq 0x1030
leaq 0x70da(%rip), %rdi      # 0x82d0
movl $0x200, %edx            # imm = 0x200
movl $0xff, %esi
callq 0x1030
xorl %ebx, %ebx
xorl %ebp, %ebp
cmpl 0x2e31(%rip), %ebp      # 0x4040
jge 0x125c
xorps %xmm0, %xmm0
movaps %xmm0, 0x6ea5(%rip)     # 0x80c0
movaps %xmm0, 0x6e8e(%rip)     # 0x80b0
movaps %xmm0, 0x6e77(%rip)     # 0x80a0
movaps %xmm0, 0x6e60(%rip)     # 0x8090
movaps %xmm0, 0x6e49(%rip)     # 0x8080
movaps %xmm0, 0x6e32(%rip)     # 0x8070
movaps %xmm0, 0x6e1b(%rip)     # 0x8060
movaps %xmm0, 0x6e04(%rip)     # 0x8050
movl %ebp, %edi
callq 0x113c
movzbl %al, %eax
addl %eax, %ebx
incl %ebp
jmp 0x1209
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/prophyle[P]prophasm/src/prophasm.cpp
// Function: print_help()
void print_help(){
	std::cerr <<
		"\n" <<
		"Program:  prophasm (a greedy assembler for k-mer set compression)\n" <<
		"Version:  " VERSION "\n" <<
		"Contact:  Karel Brinda <kbrinda@hsph.harvard.edu>\n" <<
		"\n" <<
		"Usage:    prophasm [options]\n" <<
		"\n" <<
		"Examples: prophasm -k 15 -i f1.fa -i f2.fa -x fx.fa\n" <<
		"             - compute intersection of f1 and f2\n" <<
		"          prophasm -k 15 -i f1.fa -i f2.fa -x fx.fa -o g1.fa -o g2.fa\n" <<
		"             - compute intersection of f1 and f2, and subtract it from them\n" <<
		"          prophasm -k 15 -i f1.fa -o g1.fa\n" <<
		"             - re-assemble f1 to g1\n" <<
		"\n" <<
		"Command-line parameters:\n" <<
		" -k INT   K-mer size.\n" <<
		" -i FILE  Input FASTA file (can be used multiple times).\n" <<
		" -o FILE  Output FASTA file (if used, must be used as many times as -i).\n" <<
		" -x FILE  Compute intersection, subtract it, save it.\n" <<
		" -s FILE  Output file with k-mer statistics.\n" <<
		//" -k INT   K-mer size. [" << default_k << "]\n" <<
		" -S       Silent mode.\n" <<
		"\n" <<
		"Note that '-' can be used for standard input/output. \n" <<
		std::endl;
}

// Assembly:
pushq %rbx
movq 0x5b1c(%rip), %rdi      # 0x7ff0
leaq 0x2fbd(%rip), %rbx      # 0x5498
movq %rbx, %rsi
callq 0x21c0
leaq 0x2c56(%rip), %rsi      # 0x5140
movq %rax, %rdi
callq 0x21c0
leaq 0x2c8a(%rip), %rsi      # 0x5183
movq %rax, %rdi
callq 0x21c0
leaq 0x2c8c(%rip), %rsi      # 0x5194
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21c0
leaq 0x2ca5(%rip), %rsi      # 0x51c7
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21c0
leaq 0x2ca9(%rip), %rsi      # 0x51e5
movq %rax, %rdi
callq 0x21c0
leaq 0x2ccf(%rip), %rsi      # 0x521a
movq %rax, %rdi
callq 0x21c0
leaq 0x2cf2(%rip), %rsi      # 0x524c
movq %rax, %rdi
callq 0x21c0
leaq 0x2d2a(%rip), %rsi      # 0x5293
movq %rax, %rdi
callq 0x21c0
leaq 0x2d68(%rip), %rsi      # 0x52e0
movq %rax, %rdi
callq 0x21c0
leaq 0x2d85(%rip), %rsi      # 0x530c
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21c0
leaq 0x2d90(%rip), %rsi      # 0x5331
movq %rax, %rdi
callq 0x21c0
leaq 0x2d9b(%rip), %rsi      # 0x534b
movq %rax, %rdi
callq 0x21c0
leaq 0x2da3(%rip), %rsi      # 0x5362
movq %rax, %rdi
callq 0x21c0
leaq 0x2dce(%rip), %rsi      # 0x539c
movq %rax, %rdi
callq 0x21c0
leaq 0x2e09(%rip), %rsi      # 0x53e6
movq %rax, %rdi
callq 0x21c0
leaq 0x2e31(%rip), %rsi      # 0x541d
movq %rax, %rdi
callq 0x21c0
leaq 0x2e50(%rip), %rsi      # 0x544b
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21c0
leaq 0x2e4e(%rip), %rsi      # 0x5463
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
popq %rbx
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/prophyle[P]prophasm/src/prophasm.cpp
// Function: reverse_complement_in_place(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void reverse_complement_in_place(std::string &kmer){
	//std::cerr << "before reverse complementing " << kmer << std::endl;
    std::reverse(kmer.begin(), kmer.end());
	for (int32_t i=0;i<static_cast<int32_t>(kmer.size());i++){
		char nt4=nt256_nt4[static_cast<int32_t>(kmer[i])];
		if (nt4<4){
			nt4=3-nt4;
		}
		kmer[i]=nt4_nt256[static_cast<int32_t>(nt4)];
	}
	//std::cerr << "after reverse complementing " << kmer << std::endl;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
callq 0x3dbb
xorl %eax, %eax
leaq 0x296b(%rip), %rcx      # 0x5040
leaq 0x2dee(%rip), %rdx      # 0x54ca
movslq 0x8(%rbx), %rsi
cmpq %rsi, %rax
jge 0x2714
movq (%rbx), %rsi
movsbq (%rsi,%rax), %rdi
movzbl (%rdi,%rcx), %edi
movb $0x3, %r8b
subb %dil, %r8b
cmpb $0x4, %dil
movzbl %r8b, %r8d
cmovgel %edi, %r8d
movsbq %r8b, %rdi
movb (%rdi,%rdx), %dil
movb %dil, (%rsi,%rax)
incq %rax
jmp 0x26dc
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/prophyle[P]prophasm/src/prophasm.cpp
// Function: int remove_subset<std::unordered_set<unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<unsigned long>>, std::unordered_set<unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<unsigned long>>>(std::vector<std::unordered_set<unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<unsigned long>>, std::allocator<std::unordered_set<unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<unsigned long>>>>&, std::unordered_set<unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<unsigned long>> const&)
int32_t remove_subset(std::vector<_set_T> &sets, const _subset_T &subset){

	for(int32_t i=0;i<static_cast<int32_t>(sets.size());i++){

		_set_T &current_set = sets[i];

		for(const auto &nkmer : subset){
			current_set.erase(nkmer);
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rbx
xorl %r12d, %r12d
pushq $0x38
popq %r13
movq (%r14), %r15
movq 0x8(%r14), %rax
subq %r15, %rax
cqto
idivq %r13
cltq
cmpq %rax, %r12
jge 0x38d9
imulq $0x38, %r12, %rax
addq %rax, %r15
movq %rbx, %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x38d4
leaq 0x8(%rbp), %rsi
movq %r15, %rdi
callq 0x49e6
jmp 0x38bd
incq %r12
jmp 0x389d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/prophyle[P]prophasm/src/prophasm.cpp
// Function: int encode_canonical<unsigned long>(char const*, int, unsigned long&)
int32_t encode_canonical(const char *kmers, const int32_t k, _nkmer_T &nkmer){
	_nkmer_T nkmer_f;
	_nkmer_T nkmer_r;

	int32_t error_code;

	error_code=encode_forward(kmers, k, nkmer_f);
	if(error_code!=0){
		return error_code;
	}

	error_code=encode_reverse(kmers, k, nkmer_r);
	if(error_code!=0){
		return error_code;
	}

	nkmer=std::min(nkmer_f,nkmer_r);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
callq 0x424a
testl %eax, %eax
jne 0x4241
movq %rsp, %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x4296
testl %eax, %eax
jne 0x4241
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
cmovbq %rax, %rcx
movq %rcx, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/prophyle[P]prophasm/src/prophasm.cpp
// Function: int encode_forward<unsigned long>(char const*, int, unsigned long&)
int32_t encode_forward(const char *kmers, const int32_t k, _nkmer_T &nkmer){
	nkmer=0;
	for (int32_t i=0;i<k;i++){
		uint8_t nt4 = nt256_nt4[static_cast<int32_t>(kmers[i])];
		if (nt4==4){
			return -1;
		}

		nkmer <<= 2;
		nkmer |= nt4;
	}
	return 0;
}

// Assembly:
andq $0x0, (%rdx)
xorl %ecx, %ecx
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
leaq 0xddf(%rip), %r8        # 0x5040
xorl %r9d, %r9d
cmpq %rcx, %rax
je 0x4288
movsbq (%rdi,%rcx), %r10
movzbl (%r10,%r8), %r10d
cmpq $0x4, %r10
je 0x4288
shlq $0x2, %r9
orq %r10, %r9
movq %r9, (%rdx)
incq %rcx
jmp 0x4264
movslq %esi, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
setl %al
negl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/prophyle[P]prophasm/src/prophasm.cpp
// Function: int encode_reverse<unsigned long>(char const*, int, unsigned long&)
int32_t encode_reverse(const char *kmers, const int32_t k, _nkmer_T &nkmer){
	nkmer=0;
	for (int32_t i=0;i<k;i++){
		uint8_t nt4 = nt256_nt4[static_cast<int32_t>(kmers[k-i-1])];
		if (nt4==4){
			return -1;
		}

		//complement
		nt4 = 3-nt4;

		nkmer <<= 2;
		nkmer |= nt4;
	}
	return 0;
}

// Assembly:
pushq %rbx
andq $0x0, (%rdx)
xorl %ecx, %ecx
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
leal -0x1(%rsi), %r8d
negq %rax
leaq 0xd8b(%rip), %r9        # 0x5040
xorl %r10d, %r10d
cmpq %rcx, %rax
je 0x42eb
leal (%r8,%rcx), %r11d
movslq %r11d, %r11
movsbq (%rdi,%r11), %r11
movb (%r11,%r9), %r11b
cmpb $0x4, %r11b
je 0x42eb
movb $0x3, %bl
subb %r11b, %bl
shlq $0x2, %r10
movzbl %bl, %r11d
orq %r11, %r10
movq %r10, (%rdx)
decq %rcx
jmp 0x42b8
movslq %esi, %rdx
negq %rcx
xorl %eax, %eax
cmpq %rdx, %rcx
setl %al
negl %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/prophyle[P]prophasm/src/prophasm.cpp
// Function: contig_t::contig_t(unsigned int)
contig_t(uint32_t _k){
		this->k=_k;
		seq_buffer=new char[k+2*max_contig_length+1]();
		l_ext_border=seq_buffer;
		r_ext_border=seq_buffer+2*max_contig_length;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, (%rdi)
addl $0x1312d01, %esi        # imm = 0x1312D01
movslq %esi, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2110
movq %r15, 0x8(%rbx)
movq %r15, 0x20(%rbx)
addq $0x1312d00, %r15        # imm = 0x1312D00
movq %r15, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/prophyle[P]prophasm/src/prophasm.cpp
// Function: int decode_kmer<unsigned long>(unsigned long, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int32_t decode_kmer(_nkmer_T nkmer, int32_t k, std::string &kmer){
	kmer.resize(k);
	for(int32_t i=0;i<k;i++){
		uint8_t nt4 = nkmer & 0x3;
		nkmer >>=2;
		kmer[k-i-1]=nt4_nt256[nt4];
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movslq %esi, %r15
movq %rdx, %rdi
movq %r15, %rsi
callq 0x22b0
xorl %eax, %eax
testl %r15d, %r15d
cmovgl %r15d, %eax
decl %r15d
leaq 0x9f1(%rip), %rcx       # 0x54ca
subq $0x1, %rax
jb 0x4afb
movl %r14d, %edx
andl $0x3, %edx
shrq $0x2, %r14
movb (%rdx,%rcx), %dl
movslq %r15d, %r15
movq (%rbx), %rsi
movb %dl, (%rsi,%r15)
decl %r15d
jmp 0x4ad9
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/prophyle[P]prophasm/src/prophasm.cpp
// Function: contig_t::new_contig(char const*)
int32_t new_contig(const char *base_kmer){
		assert(static_cast<int32_t>(strlen(base_kmer))==k);

		l_ext = r_ext = &seq_buffer[max_contig_length];
		*r_ext='\0';

		for(int32_t i=0;i<k;i++){
			r_extend(base_kmer[i]);
		}
		return 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20c0
cmpl %eax, (%r14)
jne 0x4b5b
movq 0x8(%r14), %rax
leaq 0x989680(%rax), %rcx
movq %rcx, 0x18(%r14)
movq %rcx, 0x10(%r14)
movb $0x0, 0x989680(%rax)
xorl %r15d, %r15d
movslq (%r14), %rax
cmpq %rax, %r15
jge 0x4b53
movsbl (%rbx,%r15), %esi
movq %r14, %rdi
callq 0x4b7a
incq %r15
jmp 0x4b39
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc7a(%rip), %rdi       # 0x57dc
leaq 0xad7(%rip), %rsi       # 0x5640
leaq 0xc97(%rip), %rcx       # 0x5807
movl $0xf9, %edx
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/prophyle[P]prophasm/src/prophasm.cpp
// Function: contig_t::r_extend(char)
int32_t r_extend(char c){
		uint8_t nt4 = nt256_nt4[static_cast<int32_t>(c)];

		if (nt4==4){
			return -1;
		}

		*r_ext=nt4_nt256[nt4];
		++r_ext;
		*r_ext='\0';
		return 0;
	}

// Assembly:
movslq %esi, %rax
leaq 0x4bc(%rip), %rcx       # 0x5040
movzbl (%rax,%rcx), %eax
cmpq $0x4, %rax
jne 0x4b92
pushq $-0x1
popq %rax
retq
leaq 0x931(%rip), %rcx       # 0x54ca
movb (%rax,%rcx), %al
movq 0x18(%rdi), %rcx
movb %al, (%rcx)
movq 0x18(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rdi)
movb $0x0, 0x1(%rax)
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/prophyle[P]prophasm/src/prophasm.cpp
// Function: contig_t::print_to_fasta(_IO_FILE*, char const*, char const*) const
int32_t print_to_fasta(FILE* fasta_file, const char* contig_name, const char *comment=nullptr) const {
		if (comment==nullptr){
			fprintf(fasta_file,">%s\n",contig_name);
		} else {
			fprintf(fasta_file,">%s %s\n",contig_name,comment);
		}

		char print_buffer[fasta_line_length+1]={0};

		for (char *p=l_ext;p<r_ext;p+=fasta_line_length){
			strncpy(print_buffer,p,fasta_line_length);
			fprintf(fasta_file, "%s\n", print_buffer);
		}

		return 0;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rcx, %rcx
je 0x4be2
leaq 0xc61(%rip), %rsi       # 0x5837
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22c0
jmp 0x4bf3
leaq 0xc49(%rip), %rsi       # 0x5832
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22c0
movq %rsp, %r15
andq $0x0, 0x35(%r15)
andq $0x0, 0x30(%r15)
movq 0x10(%r14), %r12
pushq $0x3c
popq %r13
leaq 0xc2c(%rip), %rbp       # 0x583b
cmpq 0x18(%r14), %r12
jae 0x4c39
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x20f0
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x22c0
addq $0x3c, %r12
jmp 0x4c0f
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/src/cli/helper.h
// Function: kr_print_help()
void kr_print_help() {
	std::cout << "Kram " << KR_VERSION << "\n"
	          << "Run a script with `kram path/to/file.kr`\n"
	          << "Available commands:\n"
	          << "\t--help: This text\n"
	          << "\t--version: Print version related information";
}

// Assembly:
pushq %rax
movq 0x1791c(%rip), %rdi     # 0x1afd0
leaq 0xd949(%rip), %rsi      # 0x11004
callq 0x3220
leaq 0xd943(%rip), %rsi      # 0x1100a
movq %rax, %rdi
callq 0x3220
leaq 0xe173(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
leaq 0xd92b(%rip), %rsi      # 0x11010
movq %rax, %rdi
callq 0x3220
leaq 0xd946(%rip), %rsi      # 0x1103a
movq %rax, %rdi
callq 0x3220
leaq 0xd94c(%rip), %rsi      # 0x1104f
movq %rax, %rdi
callq 0x3220
leaq 0xd951(%rip), %rsi      # 0x11063
movq %rax, %rdi
popq %rax
jmp 0x3220
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::Lexer()
Lexer::Lexer() {
	// Initialize all  keywords
	keywords["class"] = true;
	keywords["fn"] = true;
	keywords["if"] = true;
	keywords["else"] = true;
	keywords["new"] = true;
	keywords["while"] = true;
	keywords["return"] = true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
leaq 0x48(%rdi), %rax
movq %rax, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movb $0x0, 0x48(%rdi)
leaq 0xcdf1(%rip), %rsi      # 0x11208
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f4a
movb $0x1, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0xcdc7(%rip), %rsi      # 0x1120e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f4a
movb $0x1, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0xcd9a(%rip), %rsi      # 0x11211
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f4a
movb $0x1, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0xcd6d(%rip), %rsi      # 0x11214
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f4a
movb $0x1, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0xcd42(%rip), %rsi      # 0x11219
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f4a
movb $0x1, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0xcd16(%rip), %rsi      # 0x1121d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f4a
movb $0x1, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0xccec(%rip), %rsi      # 0x11223
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f4a
movb $0x1, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x3130
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x4580
jmp 0x458f
jmp 0x4580
jmp 0x458f
jmp 0x4580
jmp 0x458f
jmp 0x4580
jmp 0x458f
jmp 0x4580
jmp 0x458f
jmp 0x4580
jmp 0x458f
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3130
jmp 0x4592
movq %rax, %r14
leaq 0x38(%rbx), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x424a
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::parse_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<Token*> Lexer::parse_file(std::string filename) {
	std::vector<Token*> result;

	std::ifstream file(filename);

	if (file.fail()) {
		std::cout << "Could not open " << filename << "\n";
		exit(0);
	}

    while (std::getline(file, this->row))
    {
    	this->index = 0;

    	while (true) {
        	Token* tok = this->next();

        	this->index++;

        	if (tok->type == Type::IGNORE) {
        		continue;
        	}

        	result.push_back(tok);

        	if (tok->type == Type::T_EOF || tok->type == Type::T_EOL) {
        		break;
        	}
        }
    }

    // Indicate end of file
    result.push_back(new Token(Type::T_EOF));

    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r15, %rsi
callq 0x3330
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x468a
leaq 0x38(%r14), %r15
leaq 0x8(%rsp), %r12
movq %rsp, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x3050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4649
andq $0x0, 0x58(%r14)
movq %r14, %rdi
callq 0x46f4
movq %rax, (%rsp)
incq 0x58(%r14)
cmpl $0x2, (%rax)
je 0x461e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4ef6
movq (%rsp), %rax
cmpl $0x2, (%rax)
jae 0x461e
jmp 0x4600
pushq $0x28
popq %rdi
callq 0x3230
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0x55f8
movq %rsp, %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x54c8
leaq 0x8(%rsp), %rdi
callq 0x30a0
movq %rbx, %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x1693f(%rip), %rdi     # 0x1afd0
leaq 0xcb92(%rip), %rsi      # 0x1122a
callq 0x3220
movq %rax, %rdi
movq %r15, %rsi
callq 0x3200
leaq 0xd19a(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
xorl %edi, %edi
callq 0x3280
jmp 0x46d6
movq %rax, %r14
movq %r15, %rdi
callq 0x3210
jmp 0x46d9
movq %rax, %r14
jmp 0x46e3
jmp 0x46d6
jmp 0x46d6
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x4300
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::comment()
Token* Lexer::comment() {
	while(true) {
		this->index += 1;
		char current = this->char_at_pos(this->index + 1);

		if (current == '\n' || current == '\r' || current == '\0') {
			break;
		}
	}

	return new Token(Type::T_EOL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
movq 0x58(%rdi), %rdx
addq $0x2, %rdx
movl $0x2401, %esi           # imm = 0x2401
leaq -0x1(%rdx), %r8
movq %r8, 0x58(%rdi)
cmpq %rdx, %rcx
jbe 0x491e
movzbl (%rax,%rdx), %r8d
incq %rdx
cmpl $0xd, %r8d
ja 0x48fd
btl %r8d, %esi
jae 0x48fd
pushq $0x28
popq %rdi
callq 0x3230
movq %rax, %rbx
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x55f8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::name()
Token* Lexer::name() {
	std::string s(1, this->current);

	while (true) {
		char c = this->char_at_pos(this->index + 1);

		// After the beginning, a name can be a-Z0-9_
		if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_') {
			s += c;
			this->index += 1;
		} else {
			break;
		}
	}

	if (s == "true" || s == "false") {
		return new Token(Type::BOOL, s);
	}

	if (this->keywords.find(s) != this->keywords.end()) {
		return new Token(Type::KEYWORD, s);
	}

	return new Token(Type::NAME, s);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movsbl 0x60(%rdi), %edx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3260
movq 0x58(%rbx), %rax
incq %rax
cmpq %rax, 0x40(%rbx)
jbe 0x499f
movq 0x38(%rbx), %rcx
movb (%rcx,%rax), %al
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jae 0x49a1
jmp 0x49b3
xorl %eax, %eax
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
setae %cl
cmpb $0x5f, %al
setne %dl
testb %cl, %dl
jne 0x49cb
movsbl %al, %esi
movq %r14, %rdi
callq 0x31e0
movq 0x58(%rbx), %rax
incq %rax
movq %rax, 0x58(%rbx)
jmp 0x4980
leaq 0xc875(%rip), %rsi      # 0x11247
leaq 0x8(%rsp), %rdi
callq 0x3b79
testb %al, %al
jne 0x49f5
leaq 0xc865(%rip), %rsi      # 0x1124c
leaq 0x8(%rsp), %rdi
callq 0x3b79
testb %al, %al
je 0x4a40
pushq $0x28
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x68(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x32b0
pushq $0x6
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5614
movq %r14, %rdi
callq 0x3130
leaq 0x8(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x55a8
testq %rax, %rax
je 0x4a7f
pushq $0x28
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x48(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x32b0
pushq $0x9
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5614
jmp 0x4a20
pushq $0x28
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x32b0
pushq $0x5
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5614
jmp 0x4a20
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x4ad1
jmp 0x4ad8
movq %rax, %r14
leaq 0x48(%rsp), %rdi
jmp 0x4ad1
jmp 0x4ad8
jmp 0x4ae7
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x3130
jmp 0x4adb
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
jmp 0x4aea
jmp 0x4ae7
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::number()
Token* Lexer::number() {
	std::string s(1, this->current);

	// Look for more digits.
	while(true) {
		char c = this->char_at_pos(this->index + 1);

		if ((c < '0' || c > '9') && c != '.') {
			break;
		}

		// A dot needs to be followed by another digit to be valid
		if (c == '.') {
			char cc = this->char_at_pos(this->index + 2);

			if (cc < '0' || cc > '9') {
				break;
			}
		}

		this->index += 1;
		s += c;
	}

	// TODO Decimal
	// TODO Verify that it ends with a space?

	return new Token(Type::NUMBER, s);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movsbl 0x60(%rdi), %edx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3260
movq 0x40(%rbx), %rsi
movq 0x58(%rbx), %rdx
leaq 0x1(%rdx), %rax
cmpq %rax, %rsi
jbe 0x4b3d
movq 0x38(%rbx), %rcx
movb (%rcx,%rax), %cl
jmp 0x4b3f
xorl %ecx, %ecx
leal -0x3a(%rcx), %edi
cmpb $-0xa, %dil
setb %dil
cmpb $0x2e, %cl
setne %r8b
testb %dil, %r8b
jne 0x4b84
cmpb $0x2e, %cl
jne 0x4b73
addq $0x2, %rdx
cmpq %rdx, %rsi
jbe 0x4b84
movq 0x38(%rbx), %rsi
movb (%rsi,%rdx), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x4b84
movq %rax, 0x58(%rbx)
movsbl %cl, %esi
movq %r14, %rdi
callq 0x31e0
jmp 0x4b23
pushq $0x28
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x32b0
pushq $0x4
popq %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x5614
leaq 0x28(%rsp), %rdi
callq 0x3130
leaq 0x8(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3130
jmp 0x4bdf
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
jmp 0x4bee
jmp 0x4beb
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::string()
Token* Lexer::string() {
	std::string s = "";

	this->index += 1;

	while(true) {

		// End of string
		if (this->char_at_pos(this->index) == '"') {
			break;
		}

		// Escaping
		if (this->char_at_pos(this->index) == '\\') {

			// In case of eg. \n or \t

			switch (this->char_at_pos(this->index + 1)) {
				case 't': s += '\t'; break;
				case 'n': s += '\n'; break;
				case 'r': s += '\r'; break;
				default: 
					s += this->char_at_pos(this->index + 1);
					break;
			}

			this->index += 2;
			continue;
		}

		s += this->char_at_pos(this->index);
		this->index += 1;
	}

	return new Token(Type::STRING, s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0xcc35(%rip), %rsi      # 0x1184a
leaq 0x28(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x30f0
movq 0x58(%rbx), %rax
incq %rax
movq %rax, 0x58(%rbx)
pushq $0x2
popq %r15
pushq $0x1
popq %r12
movq 0x40(%rbx), %rdx
cmpq %rax, %rdx
jbe 0x4c57
movq 0x38(%rbx), %rsi
movzbl (%rsi,%rax), %ecx
cmpl $0x5c, %ecx
je 0x4c69
cmpl $0x22, %ecx
jne 0x4c59
jmp 0x4cac
xorl %ecx, %ecx
movsbl %cl, %esi
movq %r14, %rdi
callq 0x31e0
movq %r12, %rax
jmp 0x4c9a
incq %rax
cmpq %rax, %rdx
jbe 0x4c8a
movzbl (%rsi,%rax), %ecx
cmpl $0x6e, %ecx
je 0x4ca8
cmpl $0x72, %ecx
je 0x4ca4
movb $0x9, %al
cmpl $0x74, %ecx
je 0x4c8c
movl %ecx, %eax
jmp 0x4c8c
xorl %eax, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x31e0
movq %r15, %rax
addq 0x58(%rbx), %rax
movq %rax, 0x58(%rbx)
jmp 0x4c3a
movb $0xd, %al
jmp 0x4c8c
movb $0xa, %al
jmp 0x4c8c
pushq $0x28
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x32b0
pushq $0x3
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5614
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0x28(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3130
jmp 0x4d0b
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
jmp 0x4d1a
jmp 0x4d17
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::oper()
Token* Lexer::oper() {
	std::string s(1, this->current);

	while(true) {

		char next = this->char_at_pos(this->index + 1);

		// EOF
		if (next == '\0') {
			break;
		}

		std::string combined = s + next;

		if (Token::Trans(combined) != Type::IGNORE) {
			s += next;
			this->index += 1;
		} else {
			break;
		}
	}

	return new Token(Type::OPERATOR, s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movsbl 0x60(%rdi), %edx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3260
leaq 0x48(%rsp), %r15
leaq 0x68(%rsp), %r12
movq 0x58(%rbx), %rax
incq %rax
cmpq %rax, 0x40(%rbx)
jbe 0x4dd5
movq 0x38(%rbx), %rcx
movb (%rcx,%rax), %al
testb %al, %al
je 0x4dd5
movsbl %al, %ebp
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x4f13
movq %r12, %rdi
movq %r15, %rsi
callq 0x32b0
movq %r12, %rdi
callq 0x568e
movl %eax, %r13d
movq %r12, %rdi
callq 0x3130
cmpl $0x2, %r13d
je 0x4dcb
movq %r14, %rdi
movl %ebp, %esi
callq 0x31e0
incq 0x58(%rbx)
movq %r15, %rdi
callq 0x3130
jmp 0x4d67
leaq 0x48(%rsp), %rdi
callq 0x3130
pushq $0x28
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x32b0
pushq $0x11
popq %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x5614
leaq 0x28(%rsp), %rdi
callq 0x3130
leaq 0x8(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3130
jmp 0x4e3a
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
jmp 0x4e67
jmp 0x4e55
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x3130
jmp 0x4e5d
movq %rax, %r14
jmp 0x4e67
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x3130
leaq 0x8(%rsp), %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/token.cpp
// Function: lexer::Token::STRING(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Token Token::STRING(std::string val) {
	Token tok;
	tok.type = Type::STRING;
	tok.value = val;
	return tok;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %r14
movb $0x0, 0x18(%rdi)
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rax, (%rdi)
movq %r14, %rdi
callq 0x3160
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/token.cpp
// Function: lexer::Token::NUMBER(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Token Token::NUMBER(std::string val) {
	Token tok;
	tok.type = Type::NUMBER;
	tok.value = val;
	return tok;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %r14
movb $0x0, 0x18(%rdi)
movabsq $0x200000004, %rax      # imm = 0x200000004
movq %rax, (%rdi)
movq %r14, %rdi
callq 0x3160
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/token.cpp
// Function: lexer::Token::KEYWORD(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Token Token::KEYWORD(std::string val) {
	Token tok;
	tok.type = Type::KEYWORD;
	tok.value = val;
	tok.sub = Token::Trans(val);

	return tok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rbx
movb $0x0, 0x18(%rdi)
movabsq $0x200000009, %rax      # imm = 0x200000009
movq %rax, (%rdi)
movq %rbx, %rdi
callq 0x3160
movq %rsp, %rdi
movq %r15, %rsi
callq 0x32b0
movq %rsp, %rdi
callq 0x568e
movl %eax, 0x4(%r14)
movq %rsp, %rdi
callq 0x3130
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x3130
jmp 0x63e1
movq %rax, %r14
movq %rbx, %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/token.cpp
// Function: lexer::Token::OPERATOR(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Token Token::OPERATOR(std::string val) {
	Token tok;
	tok.type = Type::OPERATOR;
	tok.value = val;
	tok.sub = Token::Trans(val);

	return tok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rbx
movb $0x0, 0x18(%rdi)
movabsq $0x200000011, %rax      # imm = 0x200000011
movq %rax, (%rdi)
movq %rbx, %rdi
callq 0x3160
movq %rsp, %rdi
movq %r15, %rsi
callq 0x32b0
movq %rsp, %rdi
callq 0x568e
movl %eax, 0x4(%r14)
movq %rsp, %rdi
callq 0x3130
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x3130
jmp 0x6467
movq %rax, %r14
movq %rbx, %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/token.cpp
// Function: lexer::Token::print[abi:cxx11]()
std::string Token::print() {
	// make sure that opTrans is built
	Token::Trans("");

	std::string res = "";

	res += "T: " + Token::print(this->type) + ", ";
	res += "S: " + Token::print(this->sub) + ", ";
	res += "V: " + this->value;

	return res;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb31b(%rip), %rsi      # 0x1184a
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x30f0
leaq 0x68(%rsp), %rdi
callq 0x568e
leaq 0x68(%rsp), %rdi
callq 0x3130
leaq 0xb2f1(%rip), %rsi      # 0x1184a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x30f0
movl (%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0x66d0
leaq 0xacf3(%rip), %rsi      # 0x1126d
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x673e
leaq 0xad5d(%rip), %rdx      # 0x112ed
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x671f
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0x48(%rsp), %rdi
callq 0x3130
leaq 0x28(%rsp), %rdi
callq 0x3130
movl 0x4(%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0x66d0
leaq 0xac92(%rip), %rsi      # 0x11271
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x673e
leaq 0xacf8(%rip), %rdx      # 0x112ed
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x671f
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0x48(%rsp), %rdi
callq 0x3130
leaq 0x28(%rsp), %rdi
callq 0x3130
addq $0x8, %r14
leaq 0xac3b(%rip), %rsi      # 0x11275
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x6762
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq 0x8(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x66a6
jmp 0x66ad
jmp 0x6680
jmp 0x668f
jmp 0x669e
jmp 0x66ad
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3130
jmp 0x6692
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x3130
jmp 0x66a1
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3130
jmp 0x66b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3390
movq %rax, %r14
leaq 0x68(%rsp), %rdi
jmp 0x66b3
movq %rax, %r14
jmp 0x66b8
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/lexer/token.cpp
// Function: lexer::Token::print[abi:cxx11](lexer::Type)
std::string Token::print(Type in) {
	for (const auto& kv : opTrans) {
		if (kv.second == in) {
			return kv.first;
		}
	}

	return "UNKNOWN";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %eax
movq %rdi, %rbx
leaq 0x14b5f(%rip), %rsi     # 0x1b240
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x66fc
cmpl %eax, 0x28(%rsi)
jne 0x66e1
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x32b0
jmp 0x6710
leaq 0xa9e2(%rip), %rsi      # 0x110e5
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x30f0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm_environment.cpp
// Function: VM::name_update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Value*)
void VM::name_update(const std::string& name, Value* val) {

	// Verify that the variable exists first
	if (!this->environment->exists(name)) {
		std::cout << "No such variable, " << name << ", did you mean to use := ?\n";
		exit(0);
	}

	Value* previous = this->environment->get(name);

	if (previous->type != val->type) {
		std::cout << "Can not update (with =) a variable of type " << previous->print(true) << " to " << val->print(true) << "\n";
		exit(0);
	}

	this->environment->update(name, val);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %rdi
callq 0xba5c
testb %al, %al
je 0x6e8a
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0xb958
movq %rax, %r12
movl 0x8(%rax), %eax
cmpl 0x8(%rbx), %eax
jne 0x6ebe
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb8d4
movq 0x1413f(%rip), %rdi     # 0x1afd0
leaq 0xa445(%rip), %rsi      # 0x112dd
callq 0x3220
movq %rax, %rdi
movq %r14, %rsi
callq 0x3200
leaq 0xa441(%rip), %rsi      # 0x112f0
movq %rax, %rdi
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq 0x1410b(%rip), %rdi     # 0x1afd0
leaq 0xa440(%rip), %rsi      # 0x1130c
callq 0x3220
movq %rax, %r14
leaq 0x28(%rsp), %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0xbe30
movq %r14, %rdi
movq %r15, %rsi
callq 0x3200
leaq 0xa43f(%rip), %rsi      # 0x11338
movq %rax, %rdi
callq 0x3220
movq %rax, %r14
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0xbe30
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3200
leaq 0xa921(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0x28(%rsp), %rdi
callq 0x3130
jmp 0x6eb7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3130
jmp 0x6f5d
jmp 0x6f5a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/std/String.h
// Function: utf8chr[abi:cxx11](int)
std::string utf8chr(int cp)
{
    char c[5]={ 0x00,0x00,0x00,0x00,0x00 };
    if     (cp<=0x7F) { c[0] = cp;  }
    else if(cp<=0x7FF) { c[0] = (cp>>6)+192; c[1] = (cp&63)+128; }
    else if(0xd800<=cp && cp<=0xdfff) {} //invalid block of utf8
    else if(cp<=0xFFFF) { c[0] = (cp>>12)+224; c[1]= ((cp>>6)&63)+128; c[2]=(cp&63)+128; }
    else if(cp<=0x10FFFF) { c[0] = (cp>>18)+240; c[1] = ((cp>>12)&63)+128; c[2] = ((cp>>6)&63)+128; c[3]=(cp&63)+128; }
    return std::string(c);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb $0x0, 0xc(%rsp)
andl $0x0, 0x8(%rsp)
cmpl $0x7f, %esi
jg 0x6fcd
movb %sil, 0x8(%rsp)
jmp 0x7064
movl %esi, %eax
cmpl $0x7ff, %esi            # imm = 0x7FF
ja 0x6fef
shrl $0x6, %eax
orb $-0x40, %al
movb %al, 0x8(%rsp)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x9(%rsp)
jmp 0x7064
andl $0x7ffff800, %eax       # imm = 0x7FFFF800
cmpl $0xd800, %eax           # imm = 0xD800
je 0x7064
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x702a
movl %esi, %eax
shrl $0xc, %eax
orb $-0x20, %al
movb %al, 0x8(%rsp)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x9(%rsp)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0xa(%rsp)
jmp 0x7064
cmpl $0x10ffff, %esi         # imm = 0x10FFFF
ja 0x7064
movl %esi, %eax
shrl $0x12, %eax
orb $-0x10, %al
movb %al, 0x8(%rsp)
movl %esi, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x9(%rsp)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0xa(%rsp)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0xb(%rsp)
leaq 0x8(%rsp), %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x30f0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::assign(Instruction*, vm::ON)
Value* VM::assign(Instruction* ins, vm::ON on) {

	if (on == vm::ON::PUSHED_CLASS) {
		Value* top = this->lib_stack.back();

		if (top->type != Type::CLASS) {
			std::cout << "The assign operation (:=) is not allowed on this object (userland classes only)\n";
			exit(0);
		}

		// Convert top to a Class*
		Class* cl = static_cast<Class*>(top);
		cl->set_value(ins->name, this->run(ins->right[0]));
	} else {
		this->name_create(ins->name, this->run(ins->right[0]));
	}

	return this->get_value_null();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, %edx
jne 0x70d6
movq 0x8(%rbx), %rax
movq -0x8(%rax), %r15
cmpl $0x6, 0x8(%r15)
jne 0x7109
leaq 0x8(%r14), %rsi
movq %rsp, %rdi
callq 0x32b0
movq 0x50(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x7136
movq %rsp, %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x8970
movq %rsp, %rdi
callq 0x3130
jmp 0x70f7
movq 0x50(%r14), %rax
addq $0x8, %r14
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x7136
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6de0
movq %rbx, %rdi
callq 0xb7ec
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x13ec0(%rip), %rdi     # 0x1afd0
leaq 0xa32d(%rip), %rsi      # 0x11444
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::set(Instruction*, vm::ON)
Value* VM::set(Instruction* ins, vm::ON on) {
	if (on == vm::ON::PUSHED_CLASS) {
		Value* top = this->lib_stack.back();

		if (top->type != Type::CLASS) {
			std::cout << "The set operation (=) is not allowed on this object (userland classes only)\n";
			exit(0);
		}

		// Convert top to a Class*
		Class* cl = static_cast<Class*>(top);
		cl->update_value(ins->name, this->run(ins->right[0]));
	} else {
		this->name_update(ins->name, this->run(ins->right[0]));
	}

	return this->get_value_null();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, %edx
jne 0x7194
movq 0x8(%rbx), %rax
movq -0x8(%rax), %r15
cmpl $0x6, 0x8(%r15)
jne 0x71c7
leaq 0x8(%r14), %rsi
movq %rsp, %rdi
callq 0x32b0
movq 0x50(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x7136
movq %rsp, %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x8a14
movq %rsp, %rdi
callq 0x3130
jmp 0x71b5
movq 0x50(%r14), %rax
addq $0x8, %r14
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x7136
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6e38
movq %rbx, %rdi
callq 0xb7ec
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x13e02(%rip), %rdi     # 0x1afd0
leaq 0xa2c0(%rip), %rsi      # 0x11495
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390