LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ke6jjj[P]r-dat/TimeCode.cc
// Function: TimeCode::TimeCode(unsigned char const*)
TimeCode::TimeCode(const uint8_t *item)
{
  uint8_t pno1 = item[0] & 0x7;
  uint8_t pno23 = item[1];
  
  //
  // Process the program number bits. Certain patterns are
  // special.
  //
  switch (pno23) {
  case 0xaa:
    mProgramId = PROGRAM_NOT_VALID;
    break;
  case 0xbb:
    mProgramId = PROGRAM_LEAD_IN;
    break;
  case 0xee:
    mProgramId = PROGRAM_LEAD_OUT;
    break;
  default:
    mProgramId = ((uint16_t) BCDDecode(pno23)) + 100 * pno1;
    break;
  }
  
  //
  // Process the index id bits.
  //
  uint8_t index_id = item[2];
  if (index_id == 0xaa)
    mIndexId = INDEX_NOT_VALID;
  else
    mIndexId = BCDDecode(item[2]);
  
  mHour = BCDDecode(item[3]);
  mMinute = BCDDecode(item[4]);
  mSecond = BCDDecode(item[5]);
  mFrame = BCDDecode(item[6]);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x1(%rsi), %eax
cmpl $0xaa, %eax
je 0x77c7
cmpl $0xee, %eax
je 0x77c1
cmpl $0xbb, %eax
jne 0x77cd
movw $0x80bb, %ax            # imm = 0x80BB
jmp 0x77e4
movw $0x80ee, %ax            # imm = 0x80EE
jmp 0x77e4
movw $0x80aa, %ax            # imm = 0x80AA
jmp 0x77e4
movzbl (%r14), %ebp
andl $0x7, %ebp
movzwl %ax, %edi
callq 0x7910
movzbl %al, %ecx
imull $0x64, %ebp, %eax
addl %ecx, %eax
movw %ax, (%rbx)
movzbl 0x2(%r14), %eax
movzwl %ax, %edi
movb $-0x56, %al
cmpl $0xaa, %edi
je 0x77fe
callq 0x7910
movb %al, 0x2(%rbx)
movzbl 0x3(%r14), %edi
callq 0x7910
movb %al, 0x3(%rbx)
movzbl 0x4(%r14), %edi
callq 0x7910
movb %al, 0x4(%rbx)
movzbl 0x5(%r14), %edi
callq 0x7910
movb %al, 0x5(%rbx)
movzbl 0x6(%r14), %edi
callq 0x7910
movb %al, 0x6(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ke6jjj[P]r-dat/TimeCode.cc
// Function: TimeCode::TimeCode(unsigned int)
TimeCode::TimeCode(uint32_t absoluteFrame)
  : mIndexId(INDEX_NOT_VALID), mProgramId(PROGRAM_NOT_VALID)
{
  //
  // There are 120000 frames an hour.
  //
  mHour = absoluteFrame / 120000;
  absoluteFrame %= 120000;
  
  //
  // There are 2000 frames every minute.
  //
  mMinute = absoluteFrame / 2000;
  absoluteFrame %= 2000;
  
  //
  // There are 100 frames every three seconds.
  //
  uint8_t second = (absoluteFrame / 100) * 3;
  absoluteFrame %= 100;
  second += absoluteFrame / 33;
  uint8_t frame = absoluteFrame % 33;
  second -= absoluteFrame / 99;
  frame += (absoluteFrame / 99) * 33;
  mSecond = second;
  mFrame = frame;
}

// Assembly:
movw $0x80aa, (%rdi)         # imm = 0x80AA
movb $-0x56, 0x2(%rdi)
movl %esi, %eax
imulq $0x45e7b273, %rax, %rax # imm = 0x45E7B273
shrq $0x2f, %rax
movb %al, 0x3(%rdi)
imull $0x1d4c0, %eax, %eax    # imm = 0x1D4C0
subl %eax, %esi
imulq $0x20c49c, %rsi, %rax   # imm = 0x20C49C
shrq $0x20, %rax
movb %al, 0x4(%rdi)
imull $0x7d0, %eax, %eax      # imm = 0x7D0
subl %eax, %esi
imulq $0x28f5c29, %rsi, %rcx  # imm = 0x28F5C29
shrq $0x20, %rcx
leal (%rcx,%rcx,2), %eax
imull $0x64, %ecx, %ecx
subl %ecx, %esi
imulq $0x7c1f07d, %rsi, %rcx  # imm = 0x7C1F07D
shrq $0x20, %rcx
addl %ecx, %eax
movl %ecx, %edx
shll $0x5, %edx
addl %ecx, %edx
imulq $0x295fad5, %rsi, %rcx  # imm = 0x295FAD5
subl %edx, %esi
shrq $0x20, %rcx
subl %ecx, %eax
movl %ecx, %edx
shll $0x5, %edx
addl %ecx, %edx
addl %esi, %edx
movb %al, 0x5(%rdi)
movb %dl, 0x6(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ke6jjj[P]r-dat/DifferentialClockDetector.cc
// Function: DifferentialClockDetector::Reset()
void
DifferentialClockDetector::Reset()
{
  mLastSample = 0.0;
  mMaximumDiffPos = 0;
  mNextSyncPos = FirePosition(mMaximumDiffPos, mWindowSize);
  mDetected = false;
  mCurrentPos = 0;
  for (size_t i = 0; i < mWindowSize; i++)
    mWindow[i] = 0.0;
}

// Assembly:
movl $0x0, 0x18(%rdi)
xorl %r8d, %r8d
movq %r8, 0x20(%rdi)
movq (%rdi), %rcx
movq 0x10(%rdi), %rsi
leaq -0x1(%rcx), %rax
shrq %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x30(%rdi)
movb $0x0, 0x1c(%rdi)
movq %r8, 0x38(%rdi)
cmpq $0x1, %rcx
adcq %r8, %rcx
shlq $0x2, %rcx
movq %rsi, %rdi
xorl %esi, %esi
movq %rcx, %rdx
jmp 0x20a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x2, %rcx
jb 0x7af8
movl $0x1, %esi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
movaps %xmm1, %xmm3
movss (%rax,%rsi,4), %xmm1
ucomiss %xmm0, %xmm1
cmoval %esi, %edx
movaps %xmm1, %xmm0
maxss %xmm2, %xmm0
minss %xmm3, %xmm1
incq %rsi
cmpq %rsi, %rcx
jne 0x7acf
movslq %edx, %rdx
jmp 0x7afb
movaps %xmm0, %xmm1
cmpq %rdx, 0x20(%rbx)
je 0x7b18
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 0x7b50
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x7b50
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x79bc
movq 0x58(%rbx), %rdx
testq %rdx, %rdx
je 0x7d07
movq 0x60(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x20a0
movl $0x0, 0x88(%rbx)
movb $0x0, 0x80(%rbx)
xorl %eax, %eax
movq %rax, 0x78(%rbx)
movq %rax, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x30, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0xdbb(%rip), %rsi       # 0x203e
leaq 0xdba(%rip), %rdx       # 0x2044
leaq 0x8(%rsp), %rdi
callq 0x157e
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1768
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x12c1
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x12d9
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x10, %edi
callq 0x10a0
leaq 0x2a0e(%rip), %rcx      # 0x3cf8
movq %rcx, (%rax)
movabsq $0x2000000010, %rcx     # imm = 0x2000000010
movq %rcx, 0x8(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1768
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x131a
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x2c(%rsp), %rsi
movl $0x4048f5c3, (%rsi)     # imm = 0x4048F5C3
leaq 0xd1e(%rip), %rdx       # 0x204a
leaq 0x8(%rsp), %rdi
callq 0x1684
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1768
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1363
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x137b
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x2a06(%rip), %rax      # 0x3d88
movq %rax, (%rsp)
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r15
cmpq %r15, %r14
je 0x13ad
movq %rsp, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x1398
leaq 0x10(%rsp), %rdi
callq 0x143c
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x13d5
movq (%rdi), %rax
callq *0x8(%rax)
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x110c
jmp 0x142a
jmp 0x1427
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x13f8
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0x142a
jmp 0x1427
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1416
movq (%rdi), %rax
callq *0x8(%rax)
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x10f0
jmp 0x142a
jmp 0x1427
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x143c
movq %rbx, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, 0x2ef6(%rip)      # 0x4044
setg %bl
jle 0x11c7
movslq %edi, %r13
movq %r13, (%rsp)
shlq $0x7, %r13
leaq 0x716b(%rip), %r15      # 0x82d0
xorl %r12d, %r12d
leaq 0x2ee1(%rip), %rbp      # 0x4050
leaq 0x6eda(%rip), %r14      # 0x8050
leaq (%r12,%r13), %rax
cmpb $0x1, (%rbp,%rax)
jne 0x119d
cmpb $0x0, (%r12,%r14)
jne 0x119d
movb $0x1, (%r12,%r14)
movl (%r15), %edi
testl %edi, %edi
js 0x11b5
callq 0x113c
testb %al, %al
jne 0x11b5
incq %r12
movslq 0x2e9d(%rip), %rax      # 0x4044
addq $0x4, %r15
cmpq %rax, %r12
setl %bl
jl 0x1176
jmp 0x11c7
leaq 0x6f14(%rip), %rax      # 0x80d0
movq (%rsp), %rcx
movl %r12d, (%rax,%rcx,4)
movl %ecx, (%r15)
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6eeb(%rip), %rdi      # 0x80d0
movl $0x200, %edx            # imm = 0x200
movl $0xff, %esi
callq 0x1030
leaq 0x70d5(%rip), %rdi      # 0x82d0
movl $0x200, %edx            # imm = 0x200
movl $0xff, %esi
callq 0x1030
cmpl $0x0, 0x2e2f(%rip)      # 0x4040
jle 0x126a
xorl %ebp, %ebp
xorl %ebx, %ebx
xorps %xmm0, %xmm0
movaps %xmm0, 0x6e9f(%rip)     # 0x80c0
movaps %xmm0, 0x6e88(%rip)     # 0x80b0
movaps %xmm0, 0x6e71(%rip)     # 0x80a0
movaps %xmm0, 0x6e5a(%rip)     # 0x8090
movaps %xmm0, 0x6e43(%rip)     # 0x8080
movaps %xmm0, 0x6e2c(%rip)     # 0x8070
movaps %xmm0, 0x6e15(%rip)     # 0x8060
movaps %xmm0, 0x6dfe(%rip)     # 0x8050
movl %ebp, %edi
callq 0x113c
movzbl %al, %eax
addl %eax, %ebx
incl %ebp
cmpl 0x2dda(%rip), %ebp      # 0x4040
jl 0x1217
jmp 0x126c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/prophyle[P]prophasm/src/prophasm.cpp
// Function: int encode_canonical<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:
pushq %rbx
testl %esi, %esi
setg %cl
jle 0x4b3d
movsbq (%rdi), %rax
leaq 0x1514(%rip), %r8       # 0x6040
movb (%rax,%r8), %r10b
cmpb $0x4, %r10b
jne 0x4b44
movb $0x1, %r8b
xorl %eax, %eax
jmp 0x4b7e
xorl %eax, %eax
movl %ecx, %r8d
jmp 0x4b7e
movl %esi, %r9d
movl $0x1, %ebx
xorl %eax, %eax
movq %rbx, %r11
movq %rax, %rbx
shlq $0x2, %rbx
movzbl %r10b, %eax
orq %rbx, %rax
cmpq %r11, %r9
je 0x4b77
movsbq (%rdi,%r11), %r10
movb (%r10,%r8), %r10b
leaq 0x1(%r11), %rbx
cmpb $0x4, %r10b
jne 0x4b4e
cmpq %r9, %r11
setb %r8b
testb %r8b, %r8b
je 0x4b89
movzbl %r8b, %eax
jmp 0x4c02
testl %esi, %esi
jle 0x4ba8
movl %esi, %ecx
movsbq -0x1(%rdi,%rcx), %rsi
leaq 0x14a4(%rip), %r8       # 0x6040
movb (%rsi,%r8), %r10b
cmpb $0x4, %r10b
jne 0x4bac
movb $0x1, %cl
xorl %esi, %esi
jmp 0x4bfb
addq %rcx, %rdi
addq $-0x2, %rdi
movl $0x1, %r9d
subq %rcx, %r9
xorl %ebx, %ebx
xorl %esi, %esi
movq %rbx, %r11
movb $0x3, %bl
subb %r10b, %bl
movq %rsi, %r10
shlq $0x2, %r10
movzbl %bl, %esi
orq %r10, %rsi
cmpq %r11, %r9
je 0x4bed
movsbq (%rdi,%r11), %r10
movb (%r10,%r8), %r10b
leaq -0x1(%r11), %rbx
cmpb $0x4, %r10b
jne 0x4bc0
movl $0x1, %edi
subq %r11, %rdi
cmpq %rcx, %rdi
setb %cl
testb %cl, %cl
je 0x4c06
movzbl %cl, %eax
negl %eax
jmp 0x4c12
cmpq %rax, %rsi
cmovbq %rsi, %rax
movq %rax, (%rdx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq %esi, %r15
movq %rdx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x20a0
testl %r15d, %r15d
jle 0x525a
movl %ebp, %eax
leaq 0x1289(%rip), %rcx      # 0x64ca
movl %r14d, %edx
andl $0x3, %edx
shrq $0x2, %r14
movb (%rdx,%rcx), %dl
movq (%rbx), %rsi
movb %dl, -0x1(%rsi,%rax)
decq %rax
jne 0x5241
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20f0
cmpl %eax, (%r14)
jne 0x52ee
movq 0x8(%r14), %rax
leaq 0x989680(%rax), %rcx
movq %rcx, 0x18(%r14)
movq %rcx, 0x10(%r14)
movb $0x0, 0x989680(%rax)
cmpl $0x0, (%r14)
jle 0x52e4
xorl %eax, %eax
leaq 0xd98(%rip), %rcx       # 0x6040
leaq 0x121b(%rip), %rdx      # 0x64ca
movsbq (%rbx,%rax), %rsi
movzbl (%rsi,%rcx), %esi
cmpq $0x4, %rsi
je 0x52d9
movb (%rsi,%rdx), %sil
movq 0x18(%r14), %rdi
movb %sil, (%rdi)
movq 0x18(%r14), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x18(%r14)
movb $0x0, 0x1(%rsi)
incq %rax
movslq (%r14), %rsi
cmpq %rsi, %rax
jl 0x52af
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x14e7(%rip), %rdi      # 0x67dc
leaq 0x1344(%rip), %rsi      # 0x6640
leaq 0x1504(%rip), %rcx      # 0x6807
movl $0xf9, %edx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rcx, %rcx
je 0x5339
leaq 0x150a(%rip), %rsi      # 0x6837
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22e0
jmp 0x534a
leaq 0x14f2(%rip), %rsi      # 0x6832
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22e0
xorps %xmm0, %xmm0
movups %xmm0, 0x2d(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x10(%r14), %r15
cmpq 0x18(%r14), %r15
jae 0x539e
movq %rsp, %r12
leaq 0x14c7(%rip), %r13      # 0x683b
movl $0x3c, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2110
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x22e0
addq $0x3c, %r15
cmpq 0x18(%r14), %r15
jb 0x5374
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
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), %r15
movq %r15, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movb $0x0, 0x48(%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe9d8(%rip), %rsi      # 0x132c0
leaq 0xe9d6(%rip), %rdx      # 0x132c5
leaq 0x8(%rsp), %rdi
callq 0x47cc
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56a6
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4918
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xe99f(%rip), %rsi      # 0x132c6
leaq 0xe99a(%rip), %rdx      # 0x132c8
callq 0x47cc
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56a6
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4952
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xe968(%rip), %rsi      # 0x132c9
leaq 0xe963(%rip), %rdx      # 0x132cb
callq 0x47cc
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56a6
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x498c
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xe931(%rip), %rsi      # 0x132cc
leaq 0xe92e(%rip), %rdx      # 0x132d0
callq 0x47cc
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56a6
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x49c6
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xe8fc(%rip), %rsi      # 0x132d1
leaq 0xe8f8(%rip), %rdx      # 0x132d4
callq 0x47cc
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56a6
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4a00
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xe8c6(%rip), %rsi      # 0x132d5
leaq 0xe8c4(%rip), %rdx      # 0x132da
callq 0x47cc
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56a6
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4a3a
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xe892(%rip), %rsi      # 0x132db
leaq 0xe891(%rip), %rdx      # 0x132e1
callq 0x47cc
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56a6
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4a74
callq 0x3230
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4a98
jmp 0x4aac
jmp 0x4a98
jmp 0x4aac
jmp 0x4a98
jmp 0x4aac
jmp 0x4a98
jmp 0x4aac
jmp 0x4a98
jmp 0x4aac
jmp 0x4a98
jmp 0x4aac
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4aaf
callq 0x3230
jmp 0x4aaf
movq %rax, %r14
movq 0x38(%rbx), %rdi
cmpq %r15, %rdi
je 0x4abd
callq 0x3230
movq %rbx, %rdi
callq 0x46a6
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r12
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x3360
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x4bf6
leaq 0x38(%r14), %r12
movq %rsp, %r13
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x33e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4b9e
movq $0x0, 0x58(%r14)
movq %r14, %rdi
callq 0x4c74
movq %rax, (%rsp)
incq 0x58(%r14)
cmpl $0x2, (%rax)
je 0x4b5f
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4b88
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x4b93
movq %rbx, %rdi
movq %r13, %rdx
callq 0x5ac2
movq (%rsp), %rax
cmpl $0x2, (%rax)
jae 0x4b5f
jmp 0x4b25
movl $0x28, %edi
callq 0x3260
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0x5d0e
movq %r15, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4bcd
movq %r15, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x4bd8
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x5bdc
leaq 0x8(%rsp), %rdi
callq 0x3080
movq %rbx, %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x173d3(%rip), %rdi     # 0x1bfd0
leaq 0xe6de(%rip), %rsi      # 0x132e2
movl $0xf, %edx
callq 0x32a0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq 0x173b2(%rip), %rdi     # 0x1bfd0
callq 0x32a0
leaq 0xecdd(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
jmp 0x4c51
movq %rax, %r14
movq %r15, %rdi
callq 0x3230
jmp 0x4c54
movq %rax, %r14
jmp 0x4c5e
jmp 0x4c51
jmp 0x4c51
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3080
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4c6b
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4f0a
movb (%rax,%rdx), %r8b
jmp 0x4f0d
xorl %r8d, %r8d
incq %rdx
cmpb $0xd, %r8b
ja 0x4ef7
movzbl %r8b, %r8d
btl %r8d, %esi
jae 0x4ef7
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
movq %rax, %rdi
movl $0x1, %esi
callq 0x5d0e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movsbl 0x60(%rdi), %edx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdi
callq 0x32b0
movq 0x58(%rbx), %rax
incq %rax
cmpq %rax, 0x40(%rbx)
jbe 0x4f9e
movq 0x38(%rbx), %rcx
movb (%rcx,%rax), %al
jmp 0x4fa0
xorl %eax, %eax
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jb 0x4fbf
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
setae %cl
cmpb $0x5f, %al
setne %dl
testb %cl, %dl
jne 0x4fd0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3200
incq 0x58(%rbx)
jmp 0x4f88
leaq 0xe328(%rip), %rsi      # 0x132ff
leaq 0x8(%rsp), %rdi
callq 0x30a0
testl %eax, %eax
je 0x5057
leaq 0xe318(%rip), %rsi      # 0x13304
leaq 0x8(%rsp), %rdi
callq 0x30a0
testl %eax, %eax
je 0x5057
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5cb2
testq %rax, %rax
je 0x50c7
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x473c
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
movl $0x9, %esi
callq 0x5d2c
movq 0x48(%rsp), %rdi
jmp 0x509c
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rdi
callq 0x473c
leaq 0x68(%rsp), %rdx
movq %rbx, %rdi
movl $0x6, %esi
callq 0x5d2c
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x50a6
callq 0x3230
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x50b5
callq 0x3230
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x473c
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x5d2c
movq 0x28(%rsp), %rdi
jmp 0x509c
movq %rax, %r14
movq 0x28(%rsp), %rdi
jmp 0x5130
jmp 0x513c
movq %rax, %r14
movq 0x48(%rsp), %rdi
jmp 0x5130
jmp 0x513c
jmp 0x514b
movq %rax, %r14
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x513f
callq 0x3230
jmp 0x513f
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
jmp 0x514e
jmp 0x514b
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x515d
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movsbl 0x60(%rdi), %edx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdi
callq 0x32b0
movq 0x40(%rbx), %rsi
movq 0x58(%rbx), %rdx
leaq 0x1(%rdx), %rax
cmpq %rax, %rsi
jbe 0x51ad
movq 0x38(%rbx), %rcx
movb (%rcx,%rax), %cl
jmp 0x51af
xorl %ecx, %ecx
leal -0x3a(%rcx), %edi
cmpb $-0xa, %dil
setb %dil
cmpb $0x2e, %cl
setne %r8b
testb %dil, %r8b
jne 0x51f4
cmpb $0x2e, %cl
jne 0x51e3
addq $0x2, %rdx
cmpq %rdx, %rsi
jbe 0x51f4
movq 0x38(%rbx), %rsi
movb (%rsi,%rdx), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x51f4
movq %rax, 0x58(%rbx)
movsbl %cl, %esi
movq %r14, %rdi
callq 0x3200
jmp 0x5193
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x473c
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5d2c
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x5243
callq 0x3230
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5252
callq 0x3230
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x5278
callq 0x3230
jmp 0x5278
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
jmp 0x5287
jmp 0x5284
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5296
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe64c(%rip), %rdx      # 0x13908
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x47cc
incq 0x58(%rbx)
movq 0x40(%rbx), %rcx
movq 0x58(%rbx), %rax
cmpq %rax, %rcx
jbe 0x5319
movq 0x38(%rbx), %rdx
cmpb $0x22, (%rdx,%rax)
je 0x5373
cmpq %rax, %rcx
jbe 0x5319
movq 0x38(%rbx), %rdx
cmpb $0x5c, (%rdx,%rax)
jne 0x530b
incq %rax
cmpq %rax, %rcx
jbe 0x5332
movq 0x38(%rbx), %rdx
movb (%rdx,%rax), %dl
jmp 0x5334
cmpq %rax, %rcx
jbe 0x5319
movq 0x38(%rbx), %rcx
movb (%rcx,%rax), %al
jmp 0x531b
xorl %eax, %eax
movl $0x1, %r12d
movsbl %al, %esi
movq %r14, %rdi
callq 0x3200
addq %r12, 0x58(%rbx)
jmp 0x52d0
xorl %edx, %edx
cmpb $0x6e, %dl
je 0x535a
movzbl %dl, %esi
cmpl $0x72, %esi
je 0x5356
movb $0x9, %dl
cmpl $0x74, %esi
je 0x5360
cmpq %rax, %rcx
jbe 0x535e
movq 0x38(%rbx), %rcx
movb (%rcx,%rax), %dl
jmp 0x5360
movb $0xd, %dl
jmp 0x5360
movb $0xa, %dl
jmp 0x5360
xorl %edx, %edx
movl $0x2, %r12d
movsbl %dl, %esi
movq %r14, %rdi
callq 0x3200
jmp 0x532c
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x473c
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5d2c
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x53c2
callq 0x3230
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x53d1
callq 0x3230
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x53f7
callq 0x3230
jmp 0x53f7
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
jmp 0x5406
jmp 0x5403
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5415
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x32b0
leaq 0x78(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x68(%rsp), %r12
movq 0x58(%rbx), %rax
incq %rax
cmpq %rax, 0x40(%rbx)
jbe 0x5474
movq 0x38(%rbx), %rcx
movb (%rcx,%rax), %bpl
jmp 0x5476
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x5521
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x473c
movq 0x10(%rsp), %rsi
movsbl %bpl, %ebp
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl %ebp, %r8d
callq 0x33f0
movq %r14, 0x68(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x473c
movq %r12, %rdi
callq 0x5dd2
movl %eax, %r13d
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x54ed
callq 0x3230
cmpl $0x2, %r13d
je 0x5503
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
callq 0x3200
incq 0x58(%rbx)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5517
callq 0x3230
cmpl $0x2, %r13d
jne 0x545d
movl $0x28, %edi
callq 0x3260
movq %rax, %r14
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x473c
leaq 0x48(%rsp), %rdx
movq %r14, %rdi
movl $0x11, %esi
callq 0x5d2c
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x556f
callq 0x3230
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5583
callq 0x3230
movq %r14, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x55af
callq 0x3230
jmp 0x55af
movq %rax, %rbx
movq %r14, %rdi
jmp 0x55e3
jmp 0x55b8
jmp 0x55d1
movq %rax, %rbx
jmp 0x55e8
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x55d4
callq 0x3230
jmp 0x55d4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x55e8
callq 0x3230
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x55fc
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rax, (%rdi)
movq %rbx, %rdi
callq 0x3150
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6c64
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movabsq $0x200000004, %rax      # imm = 0x200000004
movq %rax, (%rdi)
movq %rbx, %rdi
callq 0x3150
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6cba
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movabsq $0x200000009, %rax      # imm = 0x200000009
movq %rax, (%rdi)
movq %rbx, %rdi
callq 0x3150
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x473c
movq %rsp, %rdi
callq 0x5dd2
movl %eax, 0x4(%r14)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6d37
callq 0x3230
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6d5e
callq 0x3230
jmp 0x6d5e
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x6d6b
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movabsq $0x200000011, %rax      # imm = 0x200000011
movq %rax, (%rdi)
movq %rbx, %rdi
callq 0x3150
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x473c
movq %rsp, %rdi
callq 0x5dd2
movl %eax, 0x4(%r14)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6de9
callq 0x3230
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6e10
callq 0x3230
jmp 0x6e10
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x6e1d
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/lexer/token.cpp
// Function: lexer::Token::NAME(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Token Token::NAME(std::string val) {
	Token tok;
	tok.type = Type::NAME;
	tok.value = val;
	return tok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, (%rdi)
movq %rbx, %rdi
callq 0x3150
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6e74
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/lexer/token.cpp
// Function: lexer::Token::BOOL(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Token Token::BOOL(std::string val) {
	Token tok;
	tok.type = Type::BOOL;
	tok.value = val;
	return tok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movabsq $0x200000006, %rax      # imm = 0x200000006
movq %rax, (%rdi)
movq %rbx, %rdi
callq 0x3150
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6eca
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x15010(%rip), %r14     # 0x1c260
movq (%r14), %r14
testq %r14, %r14
je 0x727d
cmpl %esi, 0x28(%r14)
jne 0x7250
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x473c
testq %r14, %r14
jne 0x729a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xbe5a(%rip), %rsi      # 0x130e5
leaq 0xbe5a(%rip), %rdx      # 0x130ec
movq %rbx, %rdi
callq 0x47cc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcda2
testb %al, %al
je 0x79fa
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0xcc6c
movq %rax, %r12
movl 0x8(%rax), %eax
cmpl 0x8(%rbx), %eax
jne 0x7a2e
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xcbe6
movq 0x145cf(%rip), %rdi     # 0x1bfd0
leaq 0xb98d(%rip), %rsi      # 0x13395
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3220
leaq 0xb989(%rip), %rsi      # 0x133a8
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq 0x1459b(%rip), %r14     # 0x1bfd0
leaq 0xb988(%rip), %rsi      # 0x133c4
movl $0x2b, %edx
movq %r14, %rdi
callq 0x32a0
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0xd204
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x32a0
movq %rax, %r14
leaq 0xb979(%rip), %rsi      # 0x133f0
movl $0x4, %edx
movq %rax, %rdi
callq 0x32a0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xd204
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0xbe58(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
leaq 0x8(%rsp), %rdi
callq 0x3120
leaq 0x28(%rsp), %rdi
callq 0x3120
jmp 0x7a27
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7aed
callq 0x3230
jmp 0x7aed
jmp 0x7aea
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7b00
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x4(%rsp)
movl $0x0, (%rsp)
cmpl $0x7f, %esi
jg 0x7b65
movb %sil, (%rsp)
jmp 0x7bf9
movl %esi, %eax
cmpl $0x7ff, %esi            # imm = 0x7FF
jg 0x7b86
shrl $0x6, %eax
addb $-0x40, %al
movb %al, (%rsp)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x1(%rsp)
jmp 0x7bf9
andl $0x7ffff800, %eax       # imm = 0x7FFFF800
cmpl $0xd800, %eax           # imm = 0xD800
je 0x7bf9
cmpl $0xffff, %esi           # imm = 0xFFFF
jg 0x7bc0
movl %esi, %eax
shrl $0xc, %eax
addb $-0x20, %al
movb %al, (%rsp)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsp)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x2(%rsp)
jmp 0x7bf9
cmpl $0x10ffff, %esi         # imm = 0x10FFFF
jg 0x7bf9
movl %esi, %eax
shrl $0x12, %eax
addb $-0x10, %al
movb %al, (%rsp)
movl %esi, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsp)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rsp)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x3(%rsp)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x3110
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x47cc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, %edx
jne 0x7ca0
movq 0x8(%rbx), %rax
movq -0x8(%rax), %r15
cmpl $0x6, 0x8(%r15)
jne 0x7cd7
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x473c
movq 0x50(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x89c2
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x9b1c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7cc3
callq 0x3230
jmp 0x7cc3
movq 0x50(%r14), %rax
addq $0x8, %r14
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x89c2
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7924
movq %rbx, %rdi
callq 0xcaee
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x142f2(%rip), %rdi     # 0x1bfd0
leaq 0xb827(%rip), %rsi      # 0x1350c
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7d03
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, %edx
jne 0x7d8e
movq 0x8(%rbx), %rax
movq -0x8(%rax), %r15
cmpl $0x6, 0x8(%r15)
jne 0x7dc5
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x473c
movq 0x50(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x89c2
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x9be2
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7db1
callq 0x3230
jmp 0x7db1
movq 0x50(%r14), %rax
addq $0x8, %r14
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x89c2
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x79a8
movq %rbx, %rdi
callq 0xcaee
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x14204(%rip), %rdi     # 0x1bfd0
leaq 0xb78a(%rip), %rsi      # 0x1355d
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7df1
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop