LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ke6jjj[P]r-dat/TimeCode.cc
// Function: TimeCode::AbsoluteFrame() const
uint32_t
TimeCode::AbsoluteFrame() const
{
  //
  // DAT timecode is structured to tick 100 frames every
  // three seconds. To calculate absolute time, first determine the number
  // of 3-second time periods that have elapsed.
  //
  uint32_t frames = (mSecond / 3) * 100 + mFrame;
  
  //
  // In a three-second group, the first two seconds have 33 frames, in the
  // last second there are 34.
  //
  frames += (mSecond % 3) * 33;
  
  //
  // There are 2000 frames every minute.
  //
  frames += static_cast<uint32_t>(mMinute) * 2000;
  
  //
  // And there are 120000 frames an hour.
  //
  frames += static_cast<uint32_t>(mHour) * 120000;
  
  return frames;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzbl 0x5(%rax), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
imull $0x64, %ecx, %ecx
movzbl 0x6(%rax), %edx
addl %edx, %ecx
movl %ecx, -0xc(%rbp)
movzbl 0x5(%rax), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movq -0x18(%rbp), %rax
imull $0x21, %edx, %ecx
addl -0xc(%rbp), %ecx
movl %ecx, -0xc(%rbp)
movzbl 0x4(%rax), %ecx
imull $0x7d0, %ecx, %ecx      # imm = 0x7D0
addl -0xc(%rbp), %ecx
movl %ecx, -0xc(%rbp)
movzbl 0x3(%rax), %eax
imull $0x1d4c0, %eax, %eax    # imm = 0x1D4C0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/BCDDecode.cc
// Function: BCDDecode(unsigned short)
uint8_t
BCDDecode(uint16_t word)
{
  int ten, unit;

  ten  = (word >> 4) & 0xf;
  unit = (word     ) & 0xf;

  if (ten > 9 || unit > 9)
    return 100;
  else
    return ten * 10 + unit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x4(%rbp)
movzwl -0x4(%rbp), %eax
sarl $0x4, %eax
andl $0xf, %eax
movl %eax, -0x8(%rbp)
movzwl -0x4(%rbp), %eax
andl $0xf, %eax
movl %eax, -0xc(%rbp)
cmpl $0x9, -0x8(%rbp)
jg 0xce4e
cmpl $0x9, -0xc(%rbp)
jle 0xce54
movb $0x64, -0x1(%rbp)
jmp 0xce5e
imull $0xa, -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq 0x20(%rax), %rdi
movq (%rax), %rsi
callq 0xcf90
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movb $0x0, 0x1c(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq (%rcx), %rax
jae 0xcf6e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xcf3f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/DifferentialClockDetector.cc
// Function: DifferentialClockDetector::AddAndDetect(float)
bool
DifferentialClockDetector::AddAndDetect(float sample)
{
  bool syncNow = false;

  //
  // Calculate the difference from the last sample.
  //
  float difference = sample - mLastSample;
  
  //
  // Update the current position within the sample window with the
  // new differential value.
  //
  mWindow[mCurrentPos] *= (1.0 - mAlpha);
  mWindow[mCurrentPos] += fabs(difference) * mAlpha;

  if (mCurrentPos == mMaximumDiffPos) {
    //
    // Update the state machine to trigger on the next queued
    // trigger position.
    //
    mSyncPos = mNextSyncPos;
  } else if (mCurrentPos == mSyncPos) {
    //
    // Remember to return "evaluate symbol now" to the caller.
    //
    syncNow = true;
    
    //
    // Scan through the window to determine where the maximum
    // historical differential appears to be.
    //
    EvaluateClock();
  }
  
  //
  // Update positions and samples.
  //
  mCurrentPos += 1;
  mLastSample = sample;

  if (mCurrentPos == mWindowSize) {
    //
    // We've reached the end of the window.
    // Wrap around.
    //
    mCurrentPos = 0;  
  }
  
  return mDetected && syncNow;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, -0xd(%rbp)
movss -0xc(%rbp), %xmm0
subss 0x18(%rcx), %xmm0
movss %xmm0, -0x14(%rbp)
movss 0x8(%rcx), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x131b(%rip), %xmm1     # 0xe318
subsd %xmm0, %xmm1
movq 0x10(%rcx), %rax
movq 0x38(%rcx), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movss -0x14(%rbp), %xmm0
callq 0x3190
movq -0x20(%rbp), %rcx
movss 0x8(%rcx), %xmm2
movq 0x10(%rcx), %rax
movq 0x38(%rcx), %rdx
movss (%rax,%rdx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rdx,4)
movq 0x38(%rcx), %rax
cmpq 0x20(%rcx), %rax
jne 0xd064
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x28(%rax)
jmp 0xd081
movq -0x20(%rbp), %rcx
movq 0x38(%rcx), %rax
cmpq 0x28(%rcx), %rax
jne 0xd07f
movq -0x20(%rbp), %rdi
movb $0x1, -0xd(%rbp)
callq 0xd0d0
jmp 0xd081
movq -0x20(%rbp), %rcx
movq 0x38(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x38(%rcx)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x18(%rcx)
movq 0x38(%rcx), %rax
cmpq (%rcx), %rax
jne 0xd0b0
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x1c(%rcx)
movb %al, -0x21(%rbp)
je 0xd0c5
movb -0xd(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x10, %rdi
callq 0xcef0
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0xd8a0
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x88(%rax)
movb $0x0, 0x80(%rax)
movq $0x0, 0x78(%rax)
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/SyncDeframer.cc
// Function: SyncDeframer::Reset()
void
SyncDeframer::Reset()
{
  mState = STATE_SYNC_SEARCH;
  mFrame = 0;
  mPreambleCheck = 0;
  mPreambleSymbolCount = 0;
  mTrackDetected = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movl $0x0, 0xc(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x20(%rax)
movb $0x0, 0x8(%rax)
popq %rbp
retq
// File: ke6jjj[P]r-dat/SyncDeframer.cc
// Function: SyncDeframer::ReceiveBit(bool)
void
SyncDeframer::ReceiveBit(bool bit)
{
  //
  // Accumulate a new bit into the large shift register.
  //
  mFrame  &= 0x1ff;
  mFrame <<= 1;
  mFrame  |= bit;

  //
  // If the caller is trying to detect a track start, do pre-amble
  // detection.
  //  
  if (!mTrackDetected) {
    //
    // Check for pre-amble words every ten symbols.
    //
    if (++mPreambleCheck == 10) {
      //
      // If this is a pre-amble sequence (all ones) then increment the preamble
      // count. Otherwise, reset it. (This is used in track start/stop
      // detection)
      //
      mPreambleCheck = 0;
      if (mFrame == 0x3ff)
        mPreambleSymbolCount++;
      else
        mPreambleSymbolCount = 0;
    }
  }
  
  //
  // Are we currently searching for frame sync and have we received
  // a sync word?
  //
  if ((mFrame & 0x1ff) == 0x111) {
    //
    // We've found a sync pattern. Enter sync state.
    //
    mSyncBitCount = 0;
    mState = STATE_SYNCED;

    //
    // Notify the upstream frame receiver of the sync word.
    //
    mReceiver->ReceiveWord(mFrame);
  } else if (mState == STATE_SYNCED) {
    //
    // We're in a synchronized state. We should keep accepting bits into
    // the accumulator until a full frame is built up. Has a frame been
    // built up?
    //
    mSyncBitCount += 1;
    if (mSyncBitCount == 10) {
      //
      // There's a full frame built up.
      //
      mSyncBitCount = 0;
      
      //
      // Deliver it upstream.
      //
      mReceiver->ReceiveWord(mFrame);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0xc(%rax), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movl %ecx, 0xc(%rax)
movl 0xc(%rax), %ecx
shll %ecx
movl %ecx, 0xc(%rax)
movb -0x9(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
testb $0x1, 0x8(%rax)
jne 0xdbf2
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x28(%rcx)
cmpq $0xa, %rax
jne 0xdbf0
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
cmpl $0x3ff, 0xc(%rax)       # imm = 0x3FF
jne 0xdbe2
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0xdbee
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0xdbf0
jmp 0xdbf2
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x111, %eax            # imm = 0x111
jne 0xdc26
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x1, 0x18(%rax)
movq 0x30(%rax), %rdi
movl 0xc(%rax), %esi
callq 0x3560
jmp 0xdc63
movq -0x18(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0xdc61
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
cmpq $0xa, 0x10(%rax)
jne 0xdc5f
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq 0x30(%rax), %rdi
movl 0xc(%rax), %esi
callq 0x3560
jmp 0xdc61
jmp 0xdc63
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2450
leaq -0x30(%rbp), %rdi
callq 0x2610
leaq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2650
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2680
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x26b0
testb $0x1, %al
jne 0x23dd
jmp 0x2429
leaq -0x40(%rbp), %rdi
callq 0x26f0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2710
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x30(%rbp), %rsi
callq *%rax
jmp 0x2405
jmp 0x2407
leaq -0x40(%rbp), %rdi
callq 0x2730
jmp 0x23ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2750
jmp 0x2442
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2750
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x21b0
nopl (%rax,%rax)
// File: johnbeard[P]visitor-double-dispatch/visitor-double-dispatch.cpp
// Function: getObjects()
static DObjContainer getObjects()
{
    DObjContainer objCont;
    objCont.push_back(std::make_unique<StringObject>("Hello", "utf-8"));
    objCont.push_back(std::make_unique<IntegerObject>(16, 32));
    objCont.push_back(std::make_unique<FloatObject>(3.14f, "ieee-754"));

    return objCont;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x28f0
leaq 0x3bc4(%rip), %rsi      # 0x603e
leaq 0x3bc3(%rip), %rdx      # 0x6044
leaq -0x20(%rbp), %rdi
callq 0x2940
jmp 0x248c
leaq -0x18(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x2ab0
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x2910
jmp 0x24ac
leaq -0x18(%rbp), %rdi
callq 0x2b00
leaq -0x20(%rbp), %rdi
callq 0x2b60
movl $0x10, -0x44(%rbp)
movl $0x20, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x2bc0
jmp 0x24df
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x2c40
movq -0x70(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x2910
jmp 0x24ff
leaq -0x38(%rbp), %rdi
callq 0x2b00
leaq -0x40(%rbp), %rdi
callq 0x2c90
movl $0x4048f5c3, -0x5c(%rbp) # imm = 0x4048F5C3
leaq 0x3b2b(%rip), %rdx      # 0x604a
leaq -0x58(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0x2cf0
jmp 0x252e
leaq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x2df0
movq -0x70(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x2910
jmp 0x2554
leaq -0x50(%rbp), %rdi
callq 0x2b00
leaq -0x58(%rbp), %rdi
callq 0x2e40
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x25e9
jmp 0x25e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x25f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2b00
leaq -0x20(%rbp), %rdi
callq 0x2b60
jmp 0x25f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2b00
leaq -0x40(%rbp), %rdi
callq 0x2c90
jmp 0x25f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2b00
leaq -0x58(%rbp), %rdi
callq 0x2e40
jmp 0x25f6
movq -0x70(%rbp), %rdi
callq 0x2750
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2750
movq -0x28(%rbp), %rdi
callq 0x21b0
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x2eea(%rip), %eax      # 0x4044
jge 0x120f
movslq 0x10(%rsp), %rcx
leaq 0x2ee4(%rip), %rax      # 0x4050
shlq $0x7, %rcx
addq %rcx, %rax
movslq 0xc(%rsp), %rcx
testb $0x1, (%rax,%rcx)
je 0x11fd
movslq 0xc(%rsp), %rcx
leaq 0x6ec6(%rip), %rax      # 0x8050
testb $0x1, (%rax,%rcx)
je 0x1192
jmp 0x11ff
movslq 0xc(%rsp), %rcx
leaq 0x6eb2(%rip), %rax      # 0x8050
movb $0x1, (%rax,%rcx)
movslq 0xc(%rsp), %rcx
leaq 0x7122(%rip), %rax      # 0x82d0
cmpl $0x0, (%rax,%rcx,4)
jl 0x11ce
movslq 0xc(%rsp), %rcx
leaq 0x7110(%rip), %rax      # 0x82d0
movl (%rax,%rcx,4), %edi
callq 0x1140
testb $0x1, %al
jne 0x11ce
jmp 0x11fb
movl 0xc(%rsp), %edx
movslq 0x10(%rsp), %rcx
leaq 0x6ef2(%rip), %rax      # 0x80d0
movl %edx, (%rax,%rcx,4)
movl 0x10(%rsp), %edx
movslq 0xc(%rsp), %rcx
leaq 0x70df(%rip), %rax      # 0x82d0
movl %edx, (%rax,%rcx,4)
movb $0x1, 0x17(%rsp)
jmp 0x1214
jmp 0x11fd
jmp 0x11ff
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1150
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: 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 %rax
leaq 0x6ea8(%rip), %rdi      # 0x80d0
movl $0xff, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x1030
leaq 0x7092(%rip), %rdi      # 0x82d0
movl $0xff, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x1030
movl $0x0, 0x4(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x2ddb(%rip), %eax      # 0x4040
jge 0x12a0
leaq 0x6de2(%rip), %rdi      # 0x8050
xorl %esi, %esi
movl $0x80, %edx
callq 0x1030
movl (%rsp), %edi
callq 0x1140
testb $0x1, %al
jne 0x1288
jmp 0x1293
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1295
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x125c
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq 0xe9e5(%rip), %rdi      # 0x11ff0
leaq 0x8f52(%rip), %rsi      # 0xc564
callq 0x3270
movq %rax, %rdi
leaq 0x8beb(%rip), %rsi      # 0xc20c
callq 0x3270
movq %rax, %rdi
leaq 0x8c1f(%rip), %rsi      # 0xc24f
callq 0x3270
movq %rax, %rdi
leaq 0x8c21(%rip), %rsi      # 0xc260
callq 0x3270
movq %rax, %rdi
leaq 0x8f16(%rip), %rsi      # 0xc564
callq 0x3270
movq %rax, %rdi
leaq 0x8c36(%rip), %rsi      # 0xc293
callq 0x3270
movq %rax, %rdi
leaq 0x8ef8(%rip), %rsi      # 0xc564
callq 0x3270
movq %rax, %rdi
leaq 0x8c36(%rip), %rsi      # 0xc2b1
callq 0x3270
movq %rax, %rdi
leaq 0x8c5c(%rip), %rsi      # 0xc2e6
callq 0x3270
movq %rax, %rdi
leaq 0x8c7f(%rip), %rsi      # 0xc318
callq 0x3270
movq %rax, %rdi
leaq 0x8cb7(%rip), %rsi      # 0xc35f
callq 0x3270
movq %rax, %rdi
leaq 0x8cf5(%rip), %rsi      # 0xc3ac
callq 0x3270
movq %rax, %rdi
leaq 0x8d12(%rip), %rsi      # 0xc3d8
callq 0x3270
movq %rax, %rdi
leaq 0x8e8f(%rip), %rsi      # 0xc564
callq 0x3270
movq %rax, %rdi
leaq 0x8d19(%rip), %rsi      # 0xc3fd
callq 0x3270
movq %rax, %rdi
leaq 0x8d24(%rip), %rsi      # 0xc417
callq 0x3270
movq %rax, %rdi
leaq 0x8d2c(%rip), %rsi      # 0xc42e
callq 0x3270
movq %rax, %rdi
leaq 0x8d57(%rip), %rsi      # 0xc468
callq 0x3270
movq %rax, %rdi
leaq 0x8d92(%rip), %rsi      # 0xc4b2
callq 0x3270
movq %rax, %rdi
leaq 0x8dba(%rip), %rsi      # 0xc4e9
callq 0x3270
movq %rax, %rdi
leaq 0x8dd9(%rip), %rsi      # 0xc517
callq 0x3270
movq %rax, %rdi
leaq 0x8e17(%rip), %rsi      # 0xc564
callq 0x3270
movq %rax, %rdi
leaq 0x8dd3(%rip), %rsi      # 0xc52f
callq 0x3270
movq %rax, %rdi
movq 0xe84d(%rip), %rsi      # 0x11fb8
callq 0x32b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3230
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3150
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5340
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31b0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x38fe
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x34b0
movsbl (%rax), %eax
movslq %eax, %rcx
leaq 0x8853(%rip), %rax      # 0xc100
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x4, %eax
jge 0x38ca
movsbl -0x1d(%rbp), %ecx
movl $0x3, %eax
subl %ecx, %eax
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
movslq %eax, %rcx
leaq 0x8928(%rip), %rax      # 0xc200
movb (%rax,%rcx), %al
movb %al, -0x25(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x34b0
movb -0x25(%rbp), %cl
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x387a
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa1e0
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x5cbb
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x5830
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xaf10
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xaf40
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa480
testb $0x1, %al
jne 0x5c86
jmp 0x5cab
leaq -0x30(%rbp), %rdi
callq 0xa850
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xaf70
leaq -0x30(%rbp), %rdi
callq 0xa900
jmp 0x5c73
jmp 0x5cad
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5c27
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x85e0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x8554
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8593
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x8670
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x8575
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8593
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7960
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8660
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x3ae1(%rip), %rax      # 0xc100
movb (%rax,%rcx), %al
movb %al, -0x25(%rbp)
movzbl -0x25(%rbp), %eax
cmpl $0x4, %eax
jne 0x8637
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8667
movq -0x20(%rbp), %rax
movq (%rax), %rcx
shlq $0x2, %rcx
movq %rcx, (%rax)
movzbl -0x25(%rbp), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8601
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8706
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x3a49(%rip), %rax      # 0xc100
movb (%rax,%rcx), %al
movb %al, -0x25(%rbp)
movzbl -0x25(%rbp), %eax
cmpl $0x4, %eax
jne 0x86cf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x870d
movzbl -0x25(%rbp), %ecx
movl $0x3, %eax
subl %ecx, %eax
movb %al, -0x25(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
shlq $0x2, %rcx
movq %rcx, (%rax)
movzbl -0x25(%rbp), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8691
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl (%rax), %eax
addl $0x1312d00, %eax        # imm = 0x1312D00
addl $0x1, %eax
movslq %eax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x3030
movq -0x28(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
callq 0x3130
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rax), %rcx
addq $0x1312d00, %rcx        # imm = 0x1312D00
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x3390
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xb1de
movq -0x8(%rbp), %rax
andq $0x3, %rax
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movq %rax, -0x8(%rbp)
movzbl -0x1d(%rbp), %eax
movl %eax, %ecx
leaq 0x104d(%rip), %rax      # 0xc200
movb (%rax,%rcx), %al
movb %al, -0x1e(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
subl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x34b0
movb -0x1e(%rbp), %cl
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb187
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3100
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xb21b
jmp 0xb23a
leaq 0x1680(%rip), %rdi      # 0xc8a2
leaq 0x14dd(%rip), %rsi      # 0xc706
movl $0xf9, %edx
leaq 0x1698(%rip), %rcx      # 0xc8cd
callq 0x3180
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x989680, %rcx         # imm = 0x989680
movq %rcx, 0x18(%rax)
movq %rcx, 0x10(%rax)
movq 0x18(%rax), %rax
movb $0x0, (%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0xb28a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0xb390
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb25f
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl -0x11(%rbp), %eax
movslq %eax, %rcx
leaq 0xd4c(%rip), %rax       # 0xc100
movb (%rax,%rcx), %al
movb %al, -0x12(%rbp)
movzbl -0x12(%rbp), %eax
cmpl $0x4, %eax
jne 0xb3cc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb400
movq -0x20(%rbp), %rax
movzbl -0x12(%rbp), %ecx
movl %ecx, %edx
leaq 0xe23(%rip), %rcx       # 0xc200
movb (%rcx,%rdx), %dl
movq 0x18(%rax), %rcx
movb %dl, (%rcx)
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rax
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: prophyle[P]prophasm/src/prophasm.cpp
// Function: contig_t::l_extend(char)
int32_t l_extend(char c){
		uint8_t nt4 = nt256_nt4[static_cast<int32_t>(c)];

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

		--l_ext;
		*l_ext=nt4_nt256[3-nt4];
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl -0x11(%rbp), %eax
movslq %eax, %rcx
leaq 0xccc(%rip), %rax       # 0xc100
movb (%rax,%rcx), %al
movb %al, -0x12(%rbp)
movzbl -0x12(%rbp), %eax
cmpl $0x4, %eax
jne 0xb44c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb481
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movzbl -0x12(%rbp), %edx
movl $0x3, %ecx
subl %edx, %ecx
movslq %ecx, %rdx
leaq 0xd8f(%rip), %rcx       # 0xc200
movb (%rcx,%rdx), %cl
movq 0x10(%rax), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb52f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x13d2(%rip), %rsi      # 0xc8f8
movb $0x0, %al
callq 0x33c0
jmp 0xb549
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x13bb(%rip), %rsi      # 0xc8fd
movb $0x0, %al
callq 0x33c0
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x3d, %edx
callq 0x3130
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0xb5a9
leaq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl $0x3c, %edx
callq 0x3110
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rdx
leaq 0x136d(%rip), %rsi      # 0xc901
movb $0x0, %al
callq 0x33c0
movq -0x68(%rbp), %rax
addq $0x3c, %rax
movq %rax, -0x68(%rbp)
jmp 0xb565
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 0x36730(%rip), %rdi     # 0x39fd8
leaq 0x27799(%rip), %rsi     # 0x2b048
callq 0x32d0
movq %rax, %rdi
leaq 0x27790(%rip), %rsi     # 0x2b04e
callq 0x32d0
movq %rax, %rdi
leaq 0x27f94(%rip), %rsi     # 0x2b861
callq 0x32d0
movq %rax, %rdi
leaq 0x27778(%rip), %rsi     # 0x2b054
callq 0x32d0
movq %rax, %rdi
leaq 0x27793(%rip), %rsi     # 0x2b07e
callq 0x32d0
movq %rax, %rdi
leaq 0x27799(%rip), %rsi     # 0x2b093
callq 0x32d0
movq %rax, %rdi
leaq 0x2779e(%rip), %rsi     # 0x2b0a7
callq 0x32d0
popq %rax
retq
// File: kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::char_at_pos(unsigned long)
char Lexer::char_at_pos(size_t index) {
	// Indicate nothingness
	if (index >= this->row.size()) {
		return '\0';
	}

	return this->row[index];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
callq 0x3220
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x821e
movb $0x0, 0x27(%rsp)
jmp 0x8236
movq (%rsp), %rdi
addq $0x38, %rdi
movq 0x10(%rsp), %rsi
callq 0x3500
movb (%rax), %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x58(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x58(%rdi)
movq 0x58(%rdi), %rsi
addq $0x1, %rsi
callq 0x81e0
movb %al, 0x2f(%rsp)
movsbl 0x2f(%rsp), %eax
cmpl $0xa, %eax
je 0x8293
movsbl 0x2f(%rsp), %eax
cmpl $0xd, %eax
je 0x8293
movsbl 0x2f(%rsp), %eax
cmpl $0x0, %eax
jne 0x8295
jmp 0x8297
jmp 0x8253
movl $0x28, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0x1, %esi
callq 0xaf20
jmp 0x82b8
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x32b0
movq 0x20(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movsbl 0x60(%rax), %eax
movl %eax, 0x24(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x34a0
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %rcx
leaq 0x70(%rsp), %rdi
movl $0x1, %esi
callq 0x3210
jmp 0x879d
leaq 0x6f(%rsp), %rdi
callq 0x3310
jmp 0x87a9
movq 0x18(%rsp), %rdi
movq 0x58(%rdi), %rsi
incq %rsi
callq 0x81e0
movb %al, 0x17(%rsp)
jmp 0x87c0
movb 0x17(%rsp), %al
movb %al, 0x5b(%rsp)
movsbl 0x5b(%rsp), %eax
cmpl $0x30, %eax
jl 0x87dc
movsbl 0x5b(%rsp), %eax
cmpl $0x39, %eax
jle 0x881b
movsbl 0x5b(%rsp), %eax
cmpl $0x2e, %eax
je 0x881b
jmp 0x8883
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6f(%rsp), %rdi
callq 0x3310
jmp 0x892d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x8923
movsbl 0x5b(%rsp), %eax
cmpl $0x2e, %eax
jne 0x885d
movq 0x18(%rsp), %rdi
movq 0x58(%rdi), %rsi
addq $0x2, %rsi
callq 0x81e0
movb %al, 0x16(%rsp)
jmp 0x883d
movb 0x16(%rsp), %al
movb %al, 0x5a(%rsp)
movsbl 0x5a(%rsp), %eax
cmpl $0x30, %eax
jl 0x8859
movsbl 0x5a(%rsp), %eax
cmpl $0x39, %eax
jle 0x885b
jmp 0x8883
jmp 0x885d
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rcx
incq %rcx
movq %rcx, 0x58(%rax)
movsbl 0x5b(%rsp), %esi
leaq 0x70(%rsp), %rdi
callq 0x3200
jmp 0x887e
jmp 0x87a7
movl $0x28, %edi
callq 0x32e0
movq %rax, 0x8(%rsp)
jmp 0x8894
movb $0x1, 0x37(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x3140
jmp 0x88aa
movq 0x8(%rsp), %rdi
movl $0x4, %esi
leaq 0x38(%rsp), %rdx
callq 0xaf60
jmp 0x88c0
movb $0x0, 0x37(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x31f0
leaq 0x70(%rsp), %rdi
callq 0x31f0
movq 0x8(%rsp), %rax
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x890e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x31f0
testb $0x1, 0x37(%rsp)
jne 0x8917
jmp 0x8921
movq 0x8(%rsp), %rdi
callq 0x32b0
jmp 0x8923
leaq 0x70(%rsp), %rdi
callq 0x31f0
movq 0x60(%rsp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x10(%rsp)
movsbl 0x60(%rax), %eax
movl %eax, 0x1c(%rsp)
leaq 0xaf(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x34a0
movl 0x1c(%rsp), %edx
movq 0x20(%rsp), %rcx
leaq 0xb0(%rsp), %rdi
movl $0x1, %esi
callq 0x3210
jmp 0x8c23
leaq 0xaf(%rsp), %rdi
callq 0x3310
jmp 0x8c32
movq 0x10(%rsp), %rdi
movq 0x58(%rdi), %rsi
incq %rsi
callq 0x81e0
movb %al, 0xf(%rsp)
jmp 0x8c49
movb 0xf(%rsp), %al
movb %al, 0x9b(%rsp)
movsbl 0x9b(%rsp), %eax
cmpl $0x0, %eax
jne 0x8ca5
jmp 0x8d91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xaf(%rsp), %rdi
callq 0x3310
jmp 0x8e54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x8e47
movsbl 0x9b(%rsp), %edx
leaq 0x78(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x90b0
jmp 0x8cc1
leaq 0x58(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x3140
jmp 0x8cd2
leaq 0x58(%rsp), %rdi
callq 0xb030
movl %eax, 0x8(%rsp)
jmp 0x8ce2
leaq 0x58(%rsp), %rdi
callq 0x31f0
movl 0x8(%rsp), %eax
cmpl $0x2, %eax
je 0x8d55
movsbl 0x9b(%rsp), %esi
leaq 0xb0(%rsp), %rdi
callq 0x3200
jmp 0x8d0c
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
jmp 0x8d5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x8d82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x31f0
jmp 0x8d82
movl $0x3, 0x54(%rsp)
jmp 0x8d67
movl $0x0, 0x54(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x31f0
movl 0x54(%rsp), %eax
testl %eax, %eax
je 0x8d7d
jmp 0x8d7b
jmp 0x8d91
jmp 0x8c30
leaq 0x78(%rsp), %rdi
callq 0x31f0
jmp 0x8e47
movl $0x28, %edi
callq 0x32e0
movq %rax, (%rsp)
jmp 0x8da1
movb $0x1, 0x2f(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x3140
jmp 0x8dba
movq (%rsp), %rdi
movl $0x11, %esi
leaq 0x30(%rsp), %rdx
callq 0xaf60
jmp 0x8dcf
movb $0x0, 0x2f(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x31f0
movl $0x1, 0x54(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x31f0
movq (%rsp), %rax
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x8e33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x31f0
testb $0x1, 0x2f(%rsp)
jne 0x8e3c
jmp 0x8e45
movq (%rsp), %rdi
callq 0x32b0
jmp 0x8e47
leaq 0xb0(%rsp), %rdi
callq 0x31f0
movq 0xa0(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
callq 0xaee0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x3, (%rdi)
addq $0x8, %rdi
callq 0x3040
jmp 0xd625
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0xd657
jmp 0xd64d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xdeb0
jmp 0xd661
movq 0x10(%rsp), %rdi
callq 0xdeb0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
callq 0xaee0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x4, (%rdi)
addq $0x8, %rdi
callq 0x3040
jmp 0xd6b5
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0xd6e7
jmp 0xd6dd
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xdeb0
jmp 0xd6f1
movq 0x10(%rsp), %rdi
callq 0xdeb0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
callq 0xaee0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x9, (%rdi)
addq $0x8, %rdi
callq 0x3040
jmp 0xd745
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3140
jmp 0xd756
leaq 0x20(%rsp), %rdi
callq 0xb030
movl %eax, 0x4(%rsp)
jmp 0xd766
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, 0x4(%rax)
leaq 0x20(%rsp), %rdi
callq 0x31f0
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0xd7be
jmp 0xd7b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xd7c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x31f0
jmp 0xd7c8
movq 0x10(%rsp), %rdi
callq 0xdeb0
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0xdeb0
movq 0x48(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
callq 0xaee0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x11, (%rdi)
addq $0x8, %rdi
callq 0x3040
jmp 0xd825
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3140
jmp 0xd836
leaq 0x20(%rsp), %rdi
callq 0xb030
movl %eax, 0x4(%rsp)
jmp 0xd846
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, 0x4(%rax)
leaq 0x20(%rsp), %rdi
callq 0x31f0
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0xd89e
jmp 0xd894
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xd8a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x31f0
jmp 0xd8a8
movq 0x10(%rsp), %rdi
callq 0xdeb0
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0xdeb0
movq 0x48(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
callq 0xaee0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x5, (%rdi)
addq $0x8, %rdi
callq 0x3040
jmp 0xd905
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0xd937
jmp 0xd92d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xdeb0
jmp 0xd941
movq 0x10(%rsp), %rdi
callq 0xdeb0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
callq 0xaee0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x6, (%rdi)
addq $0x8, %rdi
callq 0x3040
jmp 0xd995
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0xd9c7
jmp 0xd9bd
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xdeb0
jmp 0xd9d1
movq 0x10(%rsp), %rdi
callq 0xdeb0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x3490
nopl (%rax,%rax)