LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: TracyLaiMan[P]GLib_Example/GLibExample.cpp
// Function: glib::GLibExample::init()
bool GLibExample::init(){
    std::cout << "GLibExample::init" << std::endl;

    m_workerContext = g_main_context_new();

    if (nullptr == m_workerContext) {
        return false;
    }

    m_eventLoop = g_main_loop_new(m_workerContext, false);
    if (nullptr == m_eventLoop) {
        return false;
    }

    m_eventThread = std::thread(&GLibExample::mainLoopThread, this);
 
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x7ac5(%rip), %rdi      # 0x9fd0
leaq 0x3b06(%rip), %rsi      # 0x6018
callq 0x21c0
movq %rax, %rdi
movq 0x7a87(%rip), %rsi      # 0x9fa8
callq 0x21f0
callq 0x2200
movq -0x38(%rbp), %rcx
movq %rax, 0x8(%rcx)
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
jne 0x2541
movb $0x0, -0x1(%rbp)
jmp 0x25ae
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x2150
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x2564
movb $0x0, -0x1(%rbp)
jmp 0x25ae
movq -0x38(%rbp), %rax
leaq 0x51(%rip), %rcx        # 0x25c0
movq %rcx, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2760
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
leaq -0x18(%rbp), %rsi
callq 0x2820
leaq -0x18(%rbp), %rdi
callq 0x2860
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: TracyLaiMan[P]GLib_Example/GLibExample.cpp
// Function: glib::GLibExample::mainLoopThread()
void GLibExample::mainLoopThread(){
    g_main_context_push_thread_default(m_workerContext);
    do{
        std::cout << "mainLoopThread running" << std::endl;
        g_main_loop_run(m_eventLoop);
    }while(false);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x2030
movq 0x79ec(%rip), %rdi      # 0x9fd0
leaq 0x3a3f(%rip), %rsi      # 0x602a
callq 0x21c0
movq %rax, %rdi
movq 0x79ae(%rip), %rsi      # 0x9fa8
callq 0x21f0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2130
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TracyLaiMan[P]GLib_Example/GLibExample.cpp
// Function: glib::GLibExample::SourceEventTest()
void GLibExample::SourceEventTest(){
    
    auto source = g_idle_source_new();
    g_source_set_callback(source, reinterpret_cast<GSourceFunc>(&onEventCallback), this, nullptr);
    g_source_attach(source, m_workerContext);
    g_source_unref(source);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x20c0
movq -0x18(%rbp), %rdx
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x34(%rip), %rsi        # 0x2680
xorl %eax, %eax
movl %eax, %ecx
callq 0x2250
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x21b0
movq -0x10(%rbp), %rdi
callq 0x20d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TracyLaiMan[P]GLib_Example/main.cpp
// Function: main
int main(int argc, char **argv){

    auto example = glib::GLibExample::create();
    std::cout << "***Hi GLib***" << std::endl;
    while(1)
    {
	example->SourceEventTest();
        sleep(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2430
movq 0x4b2a(%rip), %rdi      # 0x9fd0
leaq 0xd85(%rip), %rsi       # 0x6232
callq 0x21c0
movq %rax, -0x38(%rbp)
jmp 0x54b8
movq -0x38(%rbp), %rdi
movq 0x4ae5(%rip), %rsi      # 0x9fa8
callq 0x21f0
jmp 0x54ca
jmp 0x54cc
jmp 0x54ce
leaq -0x20(%rbp), %rdi
callq 0x2720
movq %rax, %rdi
callq 0x2620
jmp 0x54e1
movl $0x1, %edi
callq 0x2120
jmp 0x54ed
jmp 0x54cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2740
movq -0x28(%rbp), %rdi
callq 0x2280
// File: ke6jjj[P]r-dat/RDATDecoder.cc
// Function: RDATDecoder::RDATDecoder(float)
RDATDecoder::RDATDecoder(float sampleRate)
: mSyncWindowCurPos(0), mSyncWindowSyncPos(0),
  mClockDetected(false), mClockRatioThreshold(0.97),
  mClockAlpha(1.0 / 30.0),
  //
  // A track is 196 blocks in duration. Convert that to samples and
  // add padding.
  //
  mTrackDuration((sampleRate / kSymbolRate) * 10 * 36 * 196 * 1.05),
  mTrackInProgress(false)
{
  int i;
  
  //
  // Create a filter bank/window for the clock detector.
  //
  mSyncWindowSize = sampleRate / kSymbolRate;
  mSyncWindow = new float[mSyncWindowSize];
  mSyncWindowEvalPos = mSyncWindowSize / 2;
  mSyncWindowNextEvalPos = mSyncWindowEvalPos;
  
  for (i = 0; i < mSyncWindowSize; i++)
    mSyncWindow[i] = 0.0;

  //
  // Keep a history of the sign of the last sample.
  //
  mLastSign = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x11d18(%rip), %rcx     # 0x14898
movq %rcx, (%rax)
movl $0x0, 0x1c(%rax)
movl $0x0, 0x20(%rax)
movb $0x0, 0x2c(%rax)
movl $0x3f7851ec, 0x30(%rax) # imm = 0x3F7851EC
movl $0x3d088889, 0x34(%rax) # imm = 0x3D088889
movb $0x0, 0x40(%rax)
movss -0xc(%rbp), %xmm0
movss 0xb740(%rip), %xmm1     # 0xe2f4
divss %xmm1, %xmm0
movss 0xb738(%rip), %xmm1     # 0xe2f8
mulss %xmm1, %xmm0
movss 0xb730(%rip), %xmm1     # 0xe2fc
mulss %xmm1, %xmm0
movss 0xb728(%rip), %xmm1     # 0xe300
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xb720(%rip), %xmm1     # 0xe308
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movsd 0xb70d(%rip), %xmm1     # 0xe310
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
movq %rcx, 0x48(%rax)
movss -0xc(%rbp), %xmm0
movss 0xb6d1(%rip), %xmm1     # 0xe2f4
divss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x18(%rax)
movslq 0x18(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl 0x18(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
movl 0x24(%rax), %ecx
movl %ecx, 0x28(%rax)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x2caa
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2c7f
movq -0x18(%rbp), %rax
movb $0x0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ke6jjj[P]r-dat/RDATDecoder.cc
// Function: RDATDecoder::ClockDetect(float)
bool
RDATDecoder::ClockDetect(float sample)
{
  bool syncNow = false;
  
  mSyncWindow[mSyncWindowCurPos] *= (1.0 - mClockAlpha);
  mSyncWindow[mSyncWindowCurPos] += fabs(sample) * mClockAlpha;

  //
  // If we're at the currently suggested sync window position,
  // remember so.
  //
  if (mSyncWindowCurPos == mSyncWindowSyncPos) {
    syncNow = true;
    
    //
    // Do a staggered update of the sync window evaluation
    // position based on the last position calculation.
    //
    mSyncWindowEvalPos = mSyncWindowNextEvalPos;
  }

  if (mSyncWindowCurPos == mSyncWindowEvalPos) {
      //
      // Take this opportunity to rescan the window,
      // looking for the highest energy peak and thus, the
      // best synchronization point.
      //
      EvaluateClock();
  }
  
  //
  // Advance the window, wrapping if necessary.
  //
  if (++mSyncWindowCurPos == mSyncWindowSize)
    //
    // We've reached the end of the window.
    // Wrap around.
    //
    mSyncWindowCurPos = 0;  
  
  return mClockDetected && syncNow;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movb $0x0, -0xd(%rbp)
movss 0x34(%rcx), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xb43a(%rip), %xmm1     # 0xe318
subsd %xmm0, %xmm1
movq 0x10(%rcx), %rax
movslq 0x1c(%rcx), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movss -0xc(%rbp), %xmm0
callq 0x3190
movq -0x18(%rbp), %rcx
movss 0x34(%rcx), %xmm2
movq 0x10(%rcx), %rax
movslq 0x1c(%rcx), %rdx
movss (%rax,%rdx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rdx,4)
movl 0x1c(%rcx), %eax
cmpl 0x20(%rcx), %eax
jne 0x2f43
movq -0x18(%rbp), %rax
movb $0x1, -0xd(%rbp)
movl 0x28(%rax), %ecx
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rcx
movl 0x1c(%rcx), %eax
cmpl 0x24(%rcx), %eax
jne 0x2f58
movq -0x18(%rbp), %rdi
callq 0x2fc0
movq -0x18(%rbp), %rcx
movl 0x1c(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rcx)
cmpl 0x18(%rcx), %eax
jne 0x2f75
movq -0x18(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x2c(%rcx)
movb %al, -0x19(%rbp)
je 0x2f8a
movb -0xd(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/NRZISyncDeframer.cc
// Function: NRZISyncDeframer::Reset()
void
NRZISyncDeframer::Reset()
{
  mState = STATE_SYNC_SEARCH;
  mFrame = 0;
  mLastBit = false;
  mPreambleCheck = 0;
  mPreambleSymbolCount = 0;
  mTrackDetected = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movl $0x0, 0xc(%rax)
movb $0x0, 0x10(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x28(%rax)
movb $0x0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/NRZISyncDeframer.cc
// Function: NRZISyncDeframer::TrackDetected(bool)
void
NRZISyncDeframer::TrackDetected(bool detected)
{
  //
  // A track has begun or ended. Cache the state.
  //
  mTrackDetected = detected;
  
  //
  // If a track has stopped, reset the preamble detection logic
  // so that it is ready to detect a new track.
  //
  if (!detected) {
    mPreambleSymbolCount = 0;
    mPreambleCheck = 0;
  }
  
  //
  // Let the downstream word collector know that the track detection
  // has changed.
  //
  mReceiver->TrackDetected(detected);
}

// 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)
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x8(%rax)
testb $0x1, -0x9(%rbp)
jne 0x345f
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3790
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ke6jjj[P]r-dat/DATWordReceiver.cc
// Function: DATWordReceiver::ReceiveWord(int)
void
DATWordReceiver::ReceiveWord(int word)
{
  uint16_t decode;

  if (word > 0 && word <= 0x3ff) {
    //
    // Decode the ten-bit word into an eight-bit byte.
    //
    decode = TenToEightTable[word];
  } else {
    //
    // Caller is sending us something weird.
    //
    decode = WORD_INVALID;
  }

  if (mDump)
    DumpWord(word, decode);
  else
    ReceiveWord(word, decode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x359b
cmpl $0x3ff, -0xc(%rbp)      # imm = 0x3FF
jg 0x359b
movslq -0xc(%rbp), %rcx
leaq 0xaddf(%rip), %rax      # 0xe370
movw (%rax,%rcx,2), %ax
movw %ax, -0xe(%rbp)
jmp 0x35a1
movw $0x8000, -0xe(%rbp)     # imm = 0x8000
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
je 0x35bf
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movzwl %ax, %esi
movzwl -0xe(%rbp), %edx
callq 0x35e0
jmp 0x35d2
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movzwl %ax, %esi
movzwl -0xe(%rbp), %edx
callq 0x3690
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ke6jjj[P]r-dat/DATWordReceiver.cc
// Function: DATWordReceiver::DumpWord(unsigned short, unsigned short)
void
DATWordReceiver::DumpWord(uint16_t raw, uint16_t decode)
{
  if (decode & WORD_SYNC) {
    printf("\nSYNC");
  } else if (decode & WORD_ATF2) {
    printf(" AT2");
  } else if (decode & WORD_ATF3) {
    printf(" AT3");
  } else if (decode & WORD_INVALID) {
    printf(" XXX");
  } else {
    printf(" %02x", decode);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x3618
leaq 0xb561(%rip), %rdi      # 0xeb70
movb $0x0, %al
callq 0x2040
jmp 0x368a
movzwl -0xc(%rbp), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x3636
leaq 0xb549(%rip), %rdi      # 0xeb76
movb $0x0, %al
callq 0x2040
jmp 0x3688
movzwl -0xc(%rbp), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x3654
leaq 0xb530(%rip), %rdi      # 0xeb7b
movb $0x0, %al
callq 0x2040
jmp 0x3686
movzwl -0xc(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x3672
leaq 0xb517(%rip), %rdi      # 0xeb80
movb $0x0, %al
callq 0x2040
jmp 0x3684
movzwl -0xc(%rbp), %esi
leaq 0xb508(%rip), %rdi      # 0xeb85
movb $0x0, %al
callq 0x2040
jmp 0x3686
jmp 0x3688
jmp 0x368a
addq $0x10, %rsp
popq %rbp
retq
// File: ke6jjj[P]r-dat/DATWordReceiver.cc
// Function: DATWordReceiver::ReceiveWord(unsigned short, unsigned short)
void
DATWordReceiver::ReceiveWord(uint16_t raw, uint16_t decode)
{
  if (decode & WORD_SYNC)
    mBlock.Reset();
  if (decode & WORD_ATF2)
    mBlockReceiver->ReceiveATFTone(2);
  if (decode & WORD_ATF3)
    mBlockReceiver->ReceiveATFTone(3);

  bool complete = mBlock.AddByte(raw, decode);

  if (complete)
    DumpCurrentBlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzwl -0xc(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x36cd
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x38f0
movzwl -0xc(%rbp), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x36f1
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rdi
movq (%rdi), %rax
movl $0x2, %esi
callq *0x10(%rax)
movzwl -0xc(%rbp), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x3715
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rdi
movq (%rdi), %rax
movl $0x3, %esi
callq *0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movw -0xa(%rbp), %ax
movzwl %ax, %esi
movzwl -0xc(%rbp), %edx
callq 0x3910
andb $0x1, %al
movb %al, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
je 0x3741
movq -0x18(%rbp), %rdi
callq 0x3750
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ke6jjj[P]r-dat/DATWordReceiver.cc
// Function: DATWordReceiver::TrackDetected(bool)
void
DATWordReceiver::TrackDetected(bool up)
{
  if (mDump)
    return;

  if (up == false) {
    //
    // Track is ending. Dump any pending blocks.
    //
    DumpCurrentBlock();
  }

  //
  // Notify the block receiver of the new track state.
  //
  mBlockReceiver->TrackDetected(up);
}

// 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)
testb $0x1, (%rax)
je 0x37b3
jmp 0x37e2
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x37c9
movq -0x18(%rbp), %rdi
callq 0x3750
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rdi
movb -0x9(%rbp), %cl
movq (%rdi), %rax
andb $0x1, %cl
movzbl %cl, %esi
callq *(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ke6jjj[P]r-dat/DATWordReceiver.cc
// Function: DATWordReceiver::Stop()
void
DATWordReceiver::Stop()
{
  if (mBlock.Size() > 0)
    DumpCurrentBlock();
  if (mBlockReceiver != NULL)
    mBlockReceiver->Stop();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x3990
cmpq $0x0, %rax
jbe 0x381c
movq -0x10(%rbp), %rdi
callq 0x3750
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x383b
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ke6jjj[P]r-dat/DATBlock.cc
// Function: DATBlock::AddByte(unsigned short, unsigned short)
bool
DATBlock::AddByte(uint16_t line_word, uint16_t flagged_byte)
{
  if (mByteCount == 36)
    return true;

  mLineWords[mByteCount] = line_word;
  mBytes[mByteCount] = flagged_byte;

  mByteCount++;

  return (mByteCount == 36);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x24, 0x90(%rax)
jne 0x393e
movb $0x1, -0x1(%rbp)
jmp 0x3983
movq -0x20(%rbp), %rax
movw -0x12(%rbp), %dx
movq 0x90(%rax), %rcx
movw %dx, (%rax,%rcx,2)
movw -0x14(%rbp), %dx
movq 0x90(%rax), %rcx
movw %dx, 0x48(%rax,%rcx,2)
movq 0x90(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x90(%rax)
cmpq $0x24, 0x90(%rax)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: ke6jjj[P]r-dat/DATTrackFramer.cc
// Function: DATTrackFramer::ReceiveATFTone(int)
void
DATTrackFramer::ReceiveATFTone(int toneNumber)
{
  if (toneNumber == 2)
    mATF2Count++;
  else if (toneNumber == 3)
    mATF3Count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x3d58
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x3d6d
cmpl $0x3, -0xc(%rbp)
jne 0x3d6b
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x3d6d
popq %rbp
retq
nop
// File: ke6jjj[P]r-dat/RDATEQDecoder.cc
// Function: RDATEQDecoder::RDATEQDecoder(float)
RDATEQDecoder::RDATEQDecoder(float sampleRate)
: mSyncWindowCurPos(0), mSyncWindowSyncPos(0),
  mClockDetected(false), mClockRatioThreshold(0.97),
  mClockAlpha(1.0 / 30.0)
{
  int i;
  
  //
  // Create a filter bank/window for the clock detector.
  //
  mSyncWindowSize = sampleRate / kSymbolRate;
  mSyncWindow = new float[mSyncWindowSize];
  mSyncWindowEvalPos = mSyncWindowSize / 2;
  mSyncWindowNextEvalPos = mSyncWindowEvalPos;
  
  for (i = 0; i < mSyncWindowSize; i++)
    mSyncWindow[i] = 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x10bf8(%rip), %rcx     # 0x149f8
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x1c(%rax)
movl $0x0, 0x20(%rax)
movb $0x0, 0x2c(%rax)
movss 0xadab(%rip), %xmm0     # 0xebcc
movss %xmm0, 0x30(%rax)
movss 0xad9a(%rip), %xmm0     # 0xebc8
movss %xmm0, 0x34(%rax)
movss -0xc(%rbp), %xmm0
movss 0xa4b4(%rip), %xmm1     # 0xe2f4
divss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x18(%rax)
movslq 0x18(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl 0x18(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
movl 0x24(%rax), %ecx
movl %ecx, 0x28(%rax)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x3ec7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3e9c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/RDATEQDecoder.cc
// Function: RDATEQDecoder::Process(float*, unsigned long)
void
RDATEQDecoder::Process(float *samples, size_t count)
{
  size_t i;
  float signal;
  bool sign, zeroCross;
  
  for (i = 0; i < count; i++) {
    //
    // Look at the sample.
    //
    signal = samples[i];

    //
    // Send the baseband signal to the clock detector.
    // If it returns true, then the clock detector has
    // achieved a good lock and suggests sampling the
    // signal now.
    //
    if (ClockDetect(signal)) {
      //
      // Signal should be sampled now.
      //
      mDecoder->ReceiveSample(signal);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3fd7
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
callq 0x3fe0
testb $0x1, %al
jne 0x3fb4
jmp 0x3fc7
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movss -0x24(%rbp), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x3fc9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3f84
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/RDATEQDecoder.cc
// Function: RDATEQDecoder::EvaluateClock()
void
RDATEQDecoder::EvaluateClock()
{
  int i, maxI, minI;
  float max = 0.0, min = 100.0, ratio;

  for (i = maxI = 0; i < mSyncWindowSize; i++) {
    //
    // Find the highest peak.
    //
    if (mSyncWindow[i] > max) {
      max = mSyncWindow[i];
      maxI = i;
    }
    //
    // And the lowest valley.
    //
    if (mSyncWindow[i] < min)
      min = mSyncWindow[i];
  }
  
  if (maxI != mSyncWindowSyncPos) {
    //
    // We've found a new sync position.
    // In the future we might calculate clock error here.
    //
    mSyncWindowSyncPos = maxI;
    mSyncWindowNextEvalPos = (maxI + mSyncWindowSize / 2) %
                              mSyncWindowSize;
  }
  
  //
  // 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;

  if (ratio < mClockRatioThreshold)
    mClockDetected = true;
  else
    mClockDetected = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movss 0xa214(%rip), %xmm0     # 0xe304
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x4180
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss -0x18(%rbp), %xmm0
jbe 0x4142
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
movss -0x1c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4173
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0x4175
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4103
movq -0x28(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x20(%rcx), %eax
je 0x41b9
movq -0x28(%rbp), %rcx
movl -0x10(%rbp), %eax
movl %eax, 0x20(%rcx)
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl 0x18(%rcx), %eax
movl $0x2, %esi
cltd
idivl %esi
movl %eax, %edx
movl -0x2c(%rbp), %eax
addl %edx, %eax
cltd
idivl 0x18(%rcx)
movq -0x28(%rbp), %rax
movl %edx, 0x28(%rax)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x41dc
movss -0x1c(%rbp), %xmm0
divss -0x18(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
jmp 0x41e4
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x28(%rbp), %rax
movss -0x20(%rbp), %xmm1
movss 0x30(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4201
movq -0x28(%rbp), %rax
movb $0x1, 0x2c(%rax)
jmp 0x4209
movq -0x28(%rbp), %rax
movb $0x0, 0x2c(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: ke6jjj[P]r-dat/Track.cc
// Function: Track::Track(Track::Head)
Track::Track(Head head)
  : mHead(head), mHaveLastBlock(false), mC1Errors(0), mC1UncorrectableErrors(0),
    mC2UncorrectableErrors(0), mHaveControlID(false), mHaveDataID(false)
{
  int i, j;
  
  //
  // Invalidate all parsed sub-codes.
  //
  for (i = 0; i < 16; i++)
    mSubcodeIsValid[i] = false;
  
  //
  // Invalidate the sub-code signature.
  //
  for (i = 0; i < 7; i++)
    mSubcodeSignature[i] = 0;
  
  //
  // Invalidate all blocks.
  //
  for (i = 0; i < kBlocks; i++) {
    for (j = 0; j < kBlockSize; j++) {
      mDataIsValid[i][j] = false;
      mData[i][j] = 0;
    }
    mHeaderIsValid[i] = false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movb $0x0, 0x85(%rax)
movb $0x0, 0x87(%rax)
movb $0x0, 0x25af(%rax)
movq $0x0, 0x25b8(%rax)
movq $0x0, 0x25c0(%rax)
movq $0x0, 0x25c8(%rax)
movl $0x0, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0x42c3
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, 0x74(%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x42a5
movl $0x0, -0x10(%rbp)
cmpl $0x7, -0x10(%rbp)
jge 0x42eb
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, 0x88(%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x42ca
movl $0x0, -0x10(%rbp)
cmpl $0x90, -0x10(%rbp)
jae 0x4368
movl $0x0, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jae 0x434d
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x128f, %rcx           # imm = 0x128F
movslq -0x10(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movslq -0x14(%rbp), %rdx
movb $0x0, (%rcx,%rdx)
addq $0x8f, %rax
movslq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4302
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, 0x251f(%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x42f2
popq %rbp
retq
nopw (%rax,%rax)
// File: ke6jjj[P]r-dat/Track.cc
// Function: Track::AddBlock(DATBlock const&)
void
Track::AddBlock(const DATBlock& block)
{
  if (!BlockHeaderIsValid(block)) {
    //
    // Block doesn't have a valid header, but there might reason to
    // accept it.
    //
    if (mHaveLastBlock && block.Size() == 36) {
      if ((mLastBlockNumber >= 0    && mLastBlockNumber < 0x7f) ||
          (mLastBlockNumber >= 0x88 && mLastBlockNumber < 0x8f) ||
          (mLastBlockNumber >= 0x80 && mLastBlockNumber < 0x88)) {
        //
        // This block doesn't have a valid header but we've received blocks
        // before it that are ok and we're still expecting blocks in this
        // region. It is likely that this block simply has a bad header but
        // its byte payload is just fine. Let's interpret this block as being
        // the next block in the sequence.
        //
        AddGuessedBlock(mLastBlockNumber + 1, block);
        mLastBlockNumber++;
      }
    }
    return;
  }
  
  //
  // Block header checks out. Add the block data to the location
  // that it identifies itself as.
  //
  AddVerifiedBlock(block);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44b0
testb $0x1, %al
jne 0x4496
movq -0x18(%rbp), %rax
testb $0x1, 0x25af(%rax)
je 0x4494
movq -0x10(%rbp), %rdi
callq 0x3990
cmpq $0x24, %rax
jne 0x4494
movq -0x18(%rbp), %rax
movzbl 0x25b0(%rax), %eax
cmpl $0x0, %eax
jl 0x441d
movq -0x18(%rbp), %rax
movzbl 0x25b0(%rax), %eax
cmpl $0x7f, %eax
jl 0x4465
movq -0x18(%rbp), %rax
movzbl 0x25b0(%rax), %eax
cmpl $0x88, %eax
jl 0x4441
movq -0x18(%rbp), %rax
movzbl 0x25b0(%rax), %eax
cmpl $0x8f, %eax
jl 0x4465
movq -0x18(%rbp), %rax
movzbl 0x25b0(%rax), %eax
cmpl $0x80, %eax
jl 0x4492
movq -0x18(%rbp), %rax
movzbl 0x25b0(%rax), %eax
cmpl $0x88, %eax
jge 0x4492
movq -0x18(%rbp), %rdi
movzbl 0x25b0(%rdi), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rdx
movzbl %al, %esi
callq 0x4550
movq -0x18(%rbp), %rax
movb 0x25b0(%rax), %cl
addb $0x1, %cl
movb %cl, 0x25b0(%rax)
jmp 0x4494
jmp 0x44a3
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4590
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/Track.cc
// Function: BlockHeaderIsValid(DATBlock const&)
static bool
BlockHeaderIsValid(const DATBlock& block)
{
  //
  // (Blocks arrive with a SYNC byte prepended, hence the header starts
  // at byte 1).
  //
  if (block.Size() < 4) {
    //
    // Block doesn't even have enough bytes for a header.
    //
    return false;
  }
  
  const uint16_t *blockBytes = block.FlaggedBytes();
  
  //
  // Check that the header bytes are valid.
  //
  if ((blockBytes[1] | blockBytes[2] | blockBytes[3]) & DATBlock::INVALID) {
    //
    // One of the header bytes didn't even decode properly.
    //
    return false;
  }
  
  //
  // Check the parity of the block header.
  //
  uint8_t parity = (blockBytes[1] ^ blockBytes[2] ^ blockBytes[3]) & 0xff;
  
  if (parity != 0)
    return false;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3990
cmpq $0x4, %rax
jae 0x44d1
movb $0x0, -0x1(%rbp)
jmp 0x4541
movq -0x10(%rbp), %rdi
callq 0x39c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzwl 0x6(%rcx), %ecx
orl %ecx, %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x450a
movb $0x0, -0x1(%rbp)
jmp 0x4541
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
xorl %ecx, %eax
movq -0x18(%rbp), %rcx
movzwl 0x6(%rcx), %ecx
xorl %ecx, %eax
andl $0xff, %eax
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x453d
movb $0x0, -0x1(%rbp)
jmp 0x4541
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/Track.cc
// Function: Track::AddVerifiedBlock(DATBlock const&)
void
Track::AddVerifiedBlock(const DATBlock& block)
{
  //
  // What's this block's block number?
  //
  const uint16_t *bytes = block.FlaggedBytes();
  uint8_t block_number;
  if (bytes[2] & 0x80) {
    //
    // Sub-code block. Block number is 0x80-0x8f.
    //
    block_number = bytes[2] & 0x8f;
  } else {
    //
    // Data block. Block number is 0x00-0x7f
    //
    block_number = bytes[2] & 0xff;
  }
  
  
  //
  // Copy the header byte away.
  //
  mHeader[block_number] = bytes[1] & 0xff;
  mHeaderIsValid[block_number] = true;
  mHaveLastBlock = true;
  mLastBlockNumber = block_number;
  
  //
  // Copy the data.
  //
  DataFill(block_number, block);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x4(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x45d9
movq -0x18(%rbp), %rax
movzwl 0x4(%rax), %eax
andl $0x8f, %eax
movb %al, -0x19(%rbp)
jmp 0x45e9
movq -0x18(%rbp), %rax
movzwl 0x4(%rax), %eax
andl $0xff, %eax
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %eax
andl $0xff, %eax
movb %al, %cl
movzbl -0x19(%rbp), %eax
movb %cl, 0x248f(%rdi,%rax)
movzbl -0x19(%rbp), %eax
movb $0x1, 0x251f(%rdi,%rax)
movb $0x1, 0x25af(%rdi)
movb -0x19(%rbp), %al
movb %al, 0x25b0(%rdi)
movb -0x19(%rbp), %al
movq -0x10(%rbp), %rdx
movzbl %al, %esi
callq 0x4de0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ke6jjj[P]r-dat/Track.cc
// Function: Track::GetSubcode(int, unsigned char const**) const
bool
Track::GetSubcode(int id, const uint8_t **out) const
{
  if (id < 0 || id > 15 || !mSubcodeIsValid[id])
    return false;
  
  *out = &mSubcode[id][0];
  
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x4672
cmpl $0xf, -0x14(%rbp)
jg 0x4672
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
testb $0x1, 0x74(%rax,%rcx)
jne 0x4678
movb $0x0, -0x1(%rbp)
jmp 0x4696
movq -0x28(%rbp), %rcx
addq $0x4, %rcx
movslq -0x14(%rbp), %rax
imulq $0x7, %rax, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/Track.cc
// Function: Track::DataFill(unsigned char, DATBlock const&)
void
Track::DataFill(uint8_t block_number, const DATBlock& block)
{
  //
  // Copy the bytes into our large block array while also marking
  // those bytes which are valid and invalid.
  //
  size_t count = block.Size();
  if (count < 4)
    return;

  count -= 4;

  if (count > 32)
    count = 32;
  
  const uint16_t *bytes = block.FlaggedBytes();
  for (size_t i = 0; i < count; i++) {
    mData[block_number][i] = bytes[i+4] & 0xff;
    mDataIsValid[block_number][i] = (bytes[i+4] & 0x8000) == 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3990
movq %rax, -0x20(%rbp)
cmpq $0x4, -0x20(%rbp)
jae 0x4e17
jmp 0x4ecd
movq -0x20(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x20(%rbp)
cmpq $0x20, -0x20(%rbp)
jbe 0x4e32
movq $0x20, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x39c0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x4ecd
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
movzwl 0x8(%rcx,%rdx,2), %ecx
andl $0xff, %ecx
movb %cl, %sil
movq %rax, %rcx
addq $0x8f, %rcx
movzbl -0x9(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
movq -0x30(%rbp), %rdx
movb %sil, (%rcx,%rdx)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
movzwl 0x8(%rcx,%rdx,2), %ecx
andl $0x8000, %ecx           # imm = 0x8000
cmpl $0x0, %ecx
sete %dl
addq $0x128f, %rax           # imm = 0x128F
movzbl -0x9(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4e47
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/Track.cc
// Function: Track::GetControlID(unsigned char&) const
bool
Track::GetControlID(uint8_t& control_id) const
{
  if (!mHaveControlID)
    return false;
  
  control_id = mControlID;
  
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x85(%rax)
jne 0x4f03
movb $0x0, -0x1(%rbp)
jmp 0x4f17
movq -0x20(%rbp), %rax
movb 0x84(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: ke6jjj[P]r-dat/Track.cc
// Function: Track::GetDataID(unsigned char&) const
bool
Track::GetDataID(uint8_t& data_id) const
{
  if (!mHaveDataID)
    return false;
  
  data_id = mDataID;
  
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x87(%rax)
jne 0x4f43
movb $0x0, -0x1(%rbp)
jmp 0x4f57
movq -0x20(%rbp), %rax
movb 0x86(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: ke6jjj[P]r-dat/NRZIEQSyncDeframer.cc
// Function: NRZIEQSyncDeframer::Reset()
void
NRZIEQSyncDeframer::Reset()
{
  mState = STATE_SYNC_SEARCH;
  mFrame = 0;
  mLast1 = 0.0;
  mLast2 = 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movl $0x0, 0x8(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x10(%rax)
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/AudioFrameReceiver.cc
// Function: AudioFrameReceiver::IsFrame(Track const&, Track const&)
bool
AudioFrameReceiver::IsFrame(const Track& A, const Track& B)
{
  //
  // We have a previous track. Are these two a pair or are they
  // separate?
  //
  const uint8_t *A_abstime;
  const uint8_t *B_abstime;
  bool A_good;
  bool B_good;
      
  //
  // Examine their absolute times. (Subcode 2).
  //
  A_good = A.GetSubcode(2, &A_abstime);
  B_good = B.GetSubcode(2, &B_abstime);

  //
  // These two tracks are look like a pair if they have the same, measurable
  // absolute time.
  //
  bool timeGood = A_good && B_good && (memcmp(A_abstime, B_abstime, 7) == 0);
  
  //
  // Finally, just make sure that neither track is in the wrong spot.
  //
  printf("Pair times good: %d\n", timeGood);
  printf("Pairs          : %d %d\n", A.GetHead(), B.GetHead());

  return timeGood
         && A.GetHead() != Track::HEAD_B
         && B.GetHead() != Track::HEAD_A;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq -0x20(%rbp), %rdx
callq 0x4640
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
leaq -0x28(%rbp), %rdx
callq 0x4640
andb $0x1, %al
movb %al, -0x2a(%rbp)
xorl %eax, %eax
testb $0x1, -0x29(%rbp)
movb %al, -0x2c(%rbp)
je 0x5443
xorl %eax, %eax
testb $0x1, -0x2a(%rbp)
movb %al, -0x2c(%rbp)
je 0x5443
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x7, %edx
callq 0x20a0
cmpl $0x0, %eax
sete %al
movb %al, -0x2c(%rbp)
movb -0x2c(%rbp), %al
andb $0x1, %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
leaq 0x9876(%rip), %rdi      # 0xecd0
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x4380
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4380
movl -0x34(%rbp), %esi
movl %eax, %edx
leaq 0x9863(%rip), %rdi      # 0xece5
movb $0x0, %al
callq 0x2040
xorl %eax, %eax
testb $0x1, -0x2b(%rbp)
movb %al, -0x2d(%rbp)
je 0x54bb
movq -0x10(%rbp), %rdi
callq 0x4380
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, -0x2d(%rbp)
je 0x54bb
movq -0x18(%rbp), %rdi
callq 0x4380
cmpl $0x0, %eax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/AudioFrameReceiver.cc
// Function: SecondsSince1900(int, int, int, int, int, int)
static uint64_t
SecondsSince1900(int year, int mon, int day, int hour, int min, int sec)
{
  static const int kMonthDoyNormal[12] = {
    0, 31, 59, 91, 121, 152, 182, 213, 244, 274, 305, 335    
  };
  static const int kMonthDoyLeap[12] = {
    0, 31, 60, 92, 122, 153, 183, 214, 245, 275, 306, 336    
  };
  
  uint64_t seconds = ((uint64_t)year) * 86400 * 365;
  seconds += sec;
  seconds += min * 60;
  seconds += hour * 3600;
  seconds += (day - 1) * 86400;
  if ((year % 4) == 0 && ((year % 100) != 0 || (year % 400) == 0)) {
    seconds += kMonthDoyLeap[mon-1] * 86400;
  } else {
    seconds += kMonthDoyNormal[mon-1] * 86400;
  }
  
  //
  // Finally, account for number of leap days that have been inserted
  // since January 1, 1900.
  //
  if (year > 1904) {
    int leaps = ((year - 1)/ 4) - 475;
    leaps -= ((year - 1) / 100) - 19;
    leaps += ((year - 1) / 400) - 4;
    seconds += leaps * 86400;
  }
  
  return seconds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl %r9d, -0x18(%rbp)
movslq -0x4(%rbp), %rax
imulq $0x15180, %rax, %rax    # imm = 0x15180
imulq $0x16d, %rax, %rax      # imm = 0x16D
movq %rax, -0x20(%rbp)
movslq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
imull $0x3c, -0x14(%rbp), %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
imull $0xe10, -0x10(%rbp), %eax # imm = 0xE10
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
imull $0x15180, %eax, %eax    # imm = 0x15180
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x6682
movl -0x4(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x665f
movl -0x4(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x6682
movl -0x8(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x8631(%rip), %rax      # 0xeca0
imull $0x15180, (%rax,%rcx,4), %eax # imm = 0x15180
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x66a3
movl -0x8(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x85de(%rip), %rax      # 0xec70
imull $0x15180, (%rax,%rcx,4), %eax # imm = 0x15180
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x770, -0x4(%rbp)      # imm = 0x770
jle 0x6705
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl $0x4, %ecx
cltd
idivl %ecx
subl $0x1db, %eax            # imm = 0x1DB
movl %eax, -0x24(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %ecx
subl $0x13, %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
subl $0x4, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
imull $0x15180, -0x24(%rbp), %eax # imm = 0x15180
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: ke6jjj[P]r-dat/AudioFrameReceiver.cc
// Function: AudioFrameReceiver::SetDumpFile(char const*)
bool
AudioFrameReceiver::SetDumpFile(const char *path)
{
  mFile = fopen(path, "wb");
  mFramesWritten = 0;
  
  if (mFile != NULL) {
    uint8_t header_space[kWAVHeaderSize + kWAVFormatChunkHeaderSize +
                         kWAVDataChunkHeaderSize];
    memset(header_space, 0, sizeof(header_space));
    fwrite(header_space, sizeof(header_space), 1, mFile);
  }
  
  return mFile != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8742(%rip), %rsi      # 0xf135
callq 0x2130
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
cmpq $0x0, 0x8(%rax)
je 0x6a3d
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x2c, %edx
callq 0x20b0
movq -0x48(%rbp), %rax
leaq -0x40(%rbp), %rdi
movq 0x8(%rax), %rcx
movl $0x2c, %esi
movl $0x1, %edx
callq 0x21f0
movq -0x48(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ke6jjj[P]r-dat/DDSFrameReceiver.cc
// Function: DDSFrameReceiver::IsFrame(Track const&, Track const&)
bool
DDSFrameReceiver::IsFrame(const Track& A, const Track& B)
{
  //
  // Are these two tracks a pair (a frame) or are they
  // separate? We must check subcode 3, the absolute frame number.
  //
  const uint8_t *A_absframe;
  const uint8_t *B_absframe;
  bool A_good;
  bool B_good;
      
  //
  // Examine their absolute frame numbers. (Subcode 3).
  //
  A_good = A.GetSubcode(3, &A_absframe);
  B_good = B.GetSubcode(3, &B_absframe);

  //
  // These tracks pair if their absolute frame numbers match.
  //
  return (A_good && B_good && memcmp(A_absframe, B_absframe, 7) == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
leaq -0x20(%rbp), %rdx
callq 0x4640
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rdi
movl $0x3, %esi
leaq -0x28(%rbp), %rdx
callq 0x4640
andb $0x1, %al
movb %al, -0x2a(%rbp)
xorl %eax, %eax
testb $0x1, -0x29(%rbp)
movb %al, -0x2b(%rbp)
je 0x6c93
xorl %eax, %eax
testb $0x1, -0x2a(%rbp)
movb %al, -0x2b(%rbp)
je 0x6c93
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x7, %edx
callq 0x20a0
cmpl $0x0, %eax
sete %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: ke6jjj[P]r-dat/DDSFrameReceiver.cc
// Function: DDSFrameReceiver::DumpGroup()
void
DDSFrameReceiver::DumpGroup()
{
  //
  // Perform ECC3 correction on the group. It's likely complete now.
  //
  bool correct = mBasicGroup->Correct();
  uint32_t group_id = mBasicGroup->BasicGroupID();
  printf("Group ECC3    : %s (Group %d)\n", correct ? "GOOD" : "----BAD---",
         group_id);
  printf("------------------------------------------------------------\n");
  
  //
  // Figure out what file name we should store this group's data under.
  //
  char *groupFilename, *validName, *eccName, *eccValidName;
  groupFilename = validName = eccName = eccValidName = NULL;
  GenerateGroupFilenames(group_id, groupFilename, validName, eccName,
    eccValidName);
  
  //
  // Dump the group data to disk.
  //
  mBasicGroup->DumpToFile(groupFilename, validName, eccName, eccValidName);

  free(groupFilename);
  free(validName);
  free(eccName);
  free(eccValidName);

  //
  // Mark that we now have no group.
  //
  mHaveGroup = false;
  delete mBasicGroup;
  mBasicGroup = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%rax), %rdi
callq 0xb570
movb %al, %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, -0x9(%rbp)
movq 0x8(%rax), %rdi
callq 0xb6f0
movl %eax, -0x10(%rbp)
movb -0x9(%rbp), %cl
leaq 0x80a4(%rip), %rsi      # 0xf2b3
leaq 0x8098(%rip), %rax      # 0xf2ae
testb $0x1, %cl
cmovneq %rax, %rsi
movl -0x10(%rbp), %edx
leaq 0x8068(%rip), %rdi      # 0xf28f
movb $0x0, %al
callq 0x2040
leaq 0x8089(%rip), %rdi      # 0xf2be
movb $0x0, %al
callq 0x2040
movq -0x40(%rbp), %rdi
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x10(%rbp), %esi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x30(%rbp), %r9
callq 0x7560
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xb0e0
movq -0x18(%rbp), %rdi
callq 0x2140
movq -0x20(%rbp), %rdi
callq 0x2140
movq -0x28(%rbp), %rdi
callq 0x2140
movq -0x30(%rbp), %rdi
callq 0x2140
movq -0x40(%rbp), %rax
movb $0x0, 0x10(%rax)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x72e6
movq -0x38(%rbp), %rdi
callq 0xae60
movq -0x38(%rbp), %rdi
movl $0x40a4c, %esi          # imm = 0x40A4C
callq 0x2100
movq -0x40(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ke6jjj[P]r-dat/DDSFrameReceiver.cc
// Function: DDSFrameReceiver::AddFrame(DDSGroup3&)
void
DDSFrameReceiver::AddFrame(DDSGroup3& frame)
{
  //
  // Is this a continuation of the last group or a new group?
  //
  if (mHaveGroup && mGroupNumber != frame.BasicGroupID()) {
    //
    // We have a basic group but this frame is outside of it.
    // Dump the current group.
    //
    DumpGroup();
  }
  
  //
  // Is this the start of a new group?
  //
  if (!mHaveGroup) {      
    //
    // Prepare a new group with this frame's group number.
    // This may also entail loading anything we currently know about this
    // group from a previous decoding process.
    //
    NewGroup(frame.BasicGroupID());
  }
  
  //
  // De-whiten the data into a G1 group.
  //
  DDSGroup1 g1(frame);
  
  //
  // Copy it into the basic group in the appropriate spot.
  //
  mBasicGroup->AddSubFrame(g1);
    
  //
  // If this was the last frame of the group, dump the group.
  //
  if (frame.IsLastLogicalFrame())
    DumpGroup();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2d40, %rsp           # imm = 0x2D40
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2d28(%rbp)
testb $0x1, 0x10(%rax)
je 0x7355
movq -0x2d28(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x2d2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x76c0
movl %eax, %ecx
movl -0x2d2c(%rbp), %eax
cmpl %ecx, %eax
je 0x7355
movq -0x2d28(%rbp), %rdi
callq 0x71d0
movq -0x2d28(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x7379
movq -0x10(%rbp), %rdi
callq 0x76c0
movq -0x2d28(%rbp), %rdi
movl %eax, %esi
callq 0x7460
movq -0x10(%rbp), %rsi
leaq -0x2d10(%rbp), %rdi
movq %rdi, -0x2d38(%rbp)
callq 0xa830
movq -0x2d28(%rbp), %rax
movq -0x2d38(%rbp), %rsi
movq 0x8(%rax), %rdi
callq 0xb330
jmp 0x73a9
movq -0x10(%rbp), %rdi
callq 0x7700
movb %al, -0x2d39(%rbp)
jmp 0x73ba
movb -0x2d39(%rbp), %al
testb $0x1, %al
jne 0x73c6
jmp 0x73f6
movq -0x2d28(%rbp), %rdi
callq 0x71d0
jmp 0x73d4
jmp 0x73f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2d18(%rbp)
movl %eax, -0x2d1c(%rbp)
leaq -0x2d10(%rbp), %rdi
callq 0xa9d0
jmp 0x740b
leaq -0x2d10(%rbp), %rdi
callq 0xa9d0
addq $0x2d40, %rsp           # imm = 0x2D40
popq %rbp
retq
movq -0x2d18(%rbp), %rdi
callq 0x21d0
nopw (%rax,%rax)