LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: joncampbell123[P]floppytools/kryoflux2.cpp
// Function: main
int main(int argc,char **argv) {
    if (argc < 2) {
        fprintf(stderr,"%s <raw>\n",argv[0]);
        return 1;
    }

    FILE *fp = fopen(argv[1],"rb");
    if (fp == NULL) return 1;

    struct kryoflux_event ev;

    for (size_t i=0;i < 256;i++) histogram[i] = 0;

    while (kryoflux_read(ev,fp)) {
        if (ev.message == MSG_FLUX) {
            unsigned long ofs = ev.flux_interval;
            if (ofs > 255ul) ofs = 255ul;
            histogram[ofs]++;
        }
    }

    printf("Histogram:\n");
    for (size_t i=0;i < 256;i++) {
        if (histogram[i] != 0ul)
            printf("%zu: %lu\n",i,histogram[i]);
    }

    fclose(fp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x2377
movq 0x5c8d(%rip), %rax      # 0x7fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x2ca0(%rip), %rsi      # 0x5004
movb $0x0, %al
callq 0x21c0
movl $0x1, -0x4(%rbp)
jmp 0x24d9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x2c88(%rip), %rsi      # 0x500e
callq 0x2170
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x23a2
movl $0x1, -0x4(%rbp)
jmp 0x24d9
leaq -0x40(%rbp), %rdi
callq 0x24f0
movq $0x0, -0x48(%rbp)
cmpq $0x100, -0x48(%rbp)     # imm = 0x100
jae 0x23de
movq -0x48(%rbp), %rcx
leaq 0x5d78(%rip), %rax      # 0x8140
movq $0x0, (%rax,%rcx,8)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x23b3
jmp 0x23e0
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2820
movb %al, -0x69(%rbp)
jmp 0x23f2
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x23fb
jmp 0x2459
movzbl -0x3c(%rbp), %eax
cmpl $0x1, %eax
jne 0x2457
movl -0x40(%rbp), %eax
movq %rax, -0x60(%rbp)
cmpq $0xff, -0x60(%rbp)
jbe 0x2439
movq $0xff, -0x60(%rbp)
jmp 0x2439
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2510
jmp 0x24e2
movq -0x60(%rbp), %rcx
leaq 0x5cfc(%rip), %rax      # 0x8140
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
leaq 0x5ced(%rip), %rax      # 0x8140
movq %rdx, (%rax,%rcx,8)
jmp 0x23e0
leaq 0x2bb1(%rip), %rdi      # 0x5011
xorl %eax, %eax
callq 0x2050
jmp 0x2469
movq $0x0, -0x68(%rbp)
cmpq $0x100, -0x68(%rbp)     # imm = 0x100
jae 0x24be
movq -0x68(%rbp), %rcx
leaq 0x5cba(%rip), %rax      # 0x8140
cmpq $0x0, (%rax,%rcx,8)
je 0x24ae
movq -0x68(%rbp), %rsi
leaq 0x5ca8(%rip), %rax      # 0x8140
movq (%rax,%rsi,8), %rdx
leaq 0x2b7a(%rip), %rdi      # 0x501d
xorl %eax, %eax
callq 0x2050
jmp 0x24ac
jmp 0x24ae
jmp 0x24b0
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x2471
movq -0x18(%rbp), %rdi
callq 0x2140
jmp 0x24c9
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2510
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2210
nopl (%rax,%rax)
// File: danomatika[P]miditester/src/main.cpp
// Function: printMessage(std::vector<unsigned char, std::allocator<unsigned char>>&, bool, bool)
void printMessage(std::vector<unsigned char> &message, bool hex, bool name) {
    if(message.size() < 1) {return;}
    if(hex) {std::cout << std::hex << std::uppercase;}
    for(int byte : message) {
        if(name && (byte & 0x80)) {
            std::cout << statusByteName(byte) << " ";
        }
        else {
            std::cout << byte << " ";
        }
    }
    if(hex) {std::cout << std::nouppercase << std::dec; }
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8890
cmpq $0x1, %rax
jae 0x5040
jmp 0x5186
testb $0x1, -0x9(%rbp)
je 0x5068
movq 0x12f83(%rip), %rdi     # 0x17fd0
leaq 0x385c(%rip), %rsi      # 0x88b0
callq 0x30a0
movq %rax, %rdi
leaq 0x387d(%rip), %rsi      # 0x88e0
callq 0x30a0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8910
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8940
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8970
testb $0x1, %al
jne 0x50a0
jmp 0x514b
leaq -0x20(%rbp), %rdi
callq 0x89b0
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
testb $0x1, -0xa(%rbp)
je 0x511d
movl -0x2c(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x511d
movzbl -0x2c(%rbp), %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x7a90
movq -0x70(%rbp), %rsi
movq 0x12ef2(%rip), %rdi     # 0x17fd0
callq 0x31c0
movq %rax, -0x68(%rbp)
jmp 0x50e9
movq -0x68(%rbp), %rdi
leaq 0xb1fc(%rip), %rsi      # 0x102f0
callq 0x31d0
jmp 0x50fb
leaq -0x50(%rbp), %rdi
callq 0x3150
jmp 0x513b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
jmp 0x518c
movl -0x2c(%rbp), %esi
movq 0x12ea9(%rip), %rdi     # 0x17fd0
callq 0x3310
movq %rax, %rdi
leaq 0xb1ba(%rip), %rsi      # 0x102f0
callq 0x31d0
jmp 0x513d
leaq -0x20(%rbp), %rdi
callq 0x89d0
jmp 0x508a
testb $0x1, -0x9(%rbp)
je 0x5173
movq 0x12e78(%rip), %rdi     # 0x17fd0
leaq 0x3891(%rip), %rsi      # 0x89f0
callq 0x30a0
movq %rax, %rdi
leaq 0x38b2(%rip), %rsi      # 0x8a20
callq 0x30a0
movq 0x12e56(%rip), %rdi     # 0x17fd0
movq 0x12e37(%rip), %rsi     # 0x17fb8
callq 0x3200
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3320
nopw %cs:(%rax,%rax)
// File: danomatika[P]miditester/src/RtMidi.cpp
// Function: RtMidiIn::openMidiApi(RtMidi::Api, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
void RtMidiIn :: openMidiApi( RtMidi::Api api, const std::string clientName, unsigned int queueSizeLimit )
{
  if ( rtapi_ )
    delete rtapi_;
  rtapi_ = 0;

#if defined(__UNIX_JACK__)
  if ( api == UNIX_JACK )
    rtapi_ = new MidiInJack( clientName, queueSizeLimit );
#endif
#if defined(__LINUX_ALSA__)
  if ( api == LINUX_ALSA )
    rtapi_ = new MidiInAlsa( clientName, queueSizeLimit );
#endif
#if defined(__WINDOWS_MM__)
  if ( api == WINDOWS_MM )
    rtapi_ = new MidiInWinMM( clientName, queueSizeLimit );
#endif
#if defined(__MACOSX_CORE__)
  if ( api == MACOSX_CORE )
    rtapi_ = new MidiInCore( clientName, queueSizeLimit );
#endif
#if defined(__RTMIDI_DUMMY__)
  if ( api == RTMIDI_DUMMY )
    rtapi_ = new MidiInDummy( clientName, queueSizeLimit );
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xc797
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0xc795
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xc797
movq -0x58(%rbp), %rax
movq $0x0, 0x8(%rax)
cmpl $0x5, -0xc(%rbp)
jne 0xc836
movl $0xb8, %edi
callq 0x31e0
movq -0x60(%rbp), %rsi
movq %rax, -0x70(%rbp)
movb $0x1, -0x4d(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x30e0
jmp 0xc7ce
movq -0x70(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x40(%rbp), %rsi
callq 0xd8b0
jmp 0xc7e0
movq -0x58(%rbp), %rax
movq -0x70(%rbp), %rcx
movb $0x0, -0x4d(%rbp)
movq %rcx, 0x8(%rax)
leaq -0x40(%rbp), %rdi
callq 0x3150
jmp 0xc836
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xc81e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3150
testb $0x1, -0x4d(%rbp)
jne 0xc826
jmp 0xc834
movq -0x70(%rbp), %rdi
movl $0xb8, %esi
callq 0x31f0
jmp 0xc83c
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3320
nopw %cs:(%rax,%rax)
// File: danomatika[P]miditester/src/RtMidi.cpp
// Function: RtMidiOut::openMidiApi(RtMidi::Api, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void RtMidiOut :: openMidiApi( RtMidi::Api api, const std::string clientName )
{
  if ( rtapi_ )
    delete rtapi_;
  rtapi_ = 0;

#if defined(__UNIX_JACK__)
  if ( api == UNIX_JACK )
    rtapi_ = new MidiOutJack( clientName );
#endif
#if defined(__LINUX_ALSA__)
  if ( api == LINUX_ALSA )
    rtapi_ = new MidiOutAlsa( clientName );
#endif
#if defined(__WINDOWS_MM__)
  if ( api == WINDOWS_MM )
    rtapi_ = new MidiOutWinMM( clientName );
#endif
#if defined(__MACOSX_CORE__)
  if ( api == MACOSX_CORE )
    rtapi_ = new MidiOutCore( clientName );
#endif
#if defined(__RTMIDI_DUMMY__)
  if ( api == RTMIDI_DUMMY )
    rtapi_ = new MidiOutDummy( clientName );
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xcbd4
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xcbd2
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xcbd4
movq -0x50(%rbp), %rax
movq $0x0, 0x8(%rax)
cmpl $0x5, -0xc(%rbp)
jne 0xcc70
movl $0x50, %edi
callq 0x31e0
movq -0x58(%rbp), %rsi
movq %rax, -0x68(%rbp)
movb $0x1, -0x45(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x30e0
jmp 0xcc0b
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xdac0
jmp 0xcc1a
movq -0x50(%rbp), %rax
movq -0x68(%rbp), %rcx
movb $0x0, -0x45(%rbp)
movq %rcx, 0x8(%rax)
leaq -0x38(%rbp), %rdi
callq 0x3150
jmp 0xcc70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xcc58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3150
testb $0x1, -0x45(%rbp)
jne 0xcc60
jmp 0xcc6e
movq -0x68(%rbp), %rdi
movl $0x50, %esi
callq 0x31f0
jmp 0xcc76
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3320
nop
// File: danomatika[P]miditester/src/RtMidi.cpp
// Function: MidiApi::error(RtMidiError::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void MidiApi :: error( RtMidiError::Type type, std::string errorString )
{
  if ( errorCallback_ ) {

    if ( firstErrorOccurred_ )
      return;

    firstErrorOccurred_ = true;
    const std::string errorMessage = errorString;

    errorCallback_( type, errorMessage, errorCallbackUserData_);
    firstErrorOccurred_ = false;
    return;
  }

  if ( type == RtMidiError::WARNING ) {
    std::cerr << '\n' << errorString << "\n\n";
  }
  else if ( type == RtMidiError::DEBUG_WARNING ) {
#if defined(__RTMIDI_DEBUG__)
    std::cerr << '\n' << errorString << "\n\n";
#endif
  }
  else {
    std::cerr << '\n' << errorString << "\n\n";
    throw RtMidiError( errorString, type );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, 0x38(%rax)
je 0xd125
movq -0x50(%rbp), %rax
testb $0x1, 0x40(%rax)
je 0xd0c5
jmp 0xd1c3
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rsi
movb $0x1, 0x40(%rax)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x30e0
movq -0x50(%rbp), %rcx
movq -0x60(%rbp), %rsi
movl -0xc(%rbp), %edi
movq 0x38(%rcx), %rax
movq 0x48(%rcx), %rdx
callq *%rax
jmp 0xd0f5
movq -0x50(%rbp), %rax
movb $0x0, 0x40(%rax)
leaq -0x38(%rbp), %rdi
callq 0x3150
jmp 0xd1c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3150
jmp 0xd1c9
cmpl $0x0, -0xc(%rbp)
jne 0xd159
movq 0xaebe(%rip), %rdi      # 0x17ff0
movl $0xa, %esi
callq 0x3250
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x31c0
movq %rax, %rdi
leaq 0x3766(%rip), %rsi      # 0x108b8
callq 0x31d0
jmp 0xd1c3
cmpl $0x1, -0xc(%rbp)
jne 0xd161
jmp 0xd1c1
movq 0xae88(%rip), %rdi      # 0x17ff0
movl $0xa, %esi
callq 0x3250
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x31c0
movq %rax, %rdi
leaq 0x3730(%rip), %rsi      # 0x108b8
callq 0x31d0
movl $0x30, %edi
callq 0x3100
movq -0x58(%rbp), %rsi
movq %rax, %rdi
movq %rdi, -0x68(%rbp)
movl -0xc(%rbp), %edx
callq 0xd9c0
movq -0x68(%rbp), %rdi
leaq 0xaa93(%rip), %rsi      # 0x17c48
leaq 0x864(%rip), %rdx       # 0xda20
callq 0x3300
jmp 0xd1c3
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3320
nopw %cs:(%rax,%rax)
// File: danomatika[P]miditester/src/RtMidi.cpp
// Function: MidiInApi::MidiInApi(unsigned int)
MidiInApi :: MidiInApi( unsigned int queueSizeLimit )
  : MidiApi()
{
  // Allocate the MIDI queue.
  inputData_.queue.ringSize = queueSizeLimit;
  if ( inputData_.queue.ringSize > 0 )
    inputData_.queue.ring = new MidiMessage[ inputData_.queue.ringSize ];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xcfc0
movq -0x30(%rbp), %rdi
leaq 0xa90e(%rip), %rax      # 0x17b18
movq %rax, (%rdi)
addq $0x50, %rdi
movq %rdi, -0x28(%rbp)
callq 0xdb70
jmp 0xd21c
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x5c(%rax)
cmpl $0x0, 0x5c(%rax)
jbe 0xd321
movq -0x30(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, %edi
movq %rdi, -0x48(%rbp)
shlq $0x5, %rdi
orq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x3030
movq %rax, -0x38(%rbp)
jmp 0xd254
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x50(%rbp)
cmpq $0x0, %rax
je 0xd2ab
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xdbd0
jmp 0xd296
movq -0x60(%rbp), %rcx
movq -0x68(%rbp), %rax
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0xd287
movq -0x30(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x60(%rax)
jmp 0xd321
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xd333
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xd32a
movq -0x50(%rbp), %rcx
movq %rax, %rsi
movq -0x68(%rbp), %rax
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq %rax, %rcx
movq %rax, -0x70(%rbp)
je 0xd312
movq -0x70(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x78(%rbp)
callq 0xdc40
movq -0x50(%rbp), %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x70(%rbp)
jne 0xd2f0
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x3360
jmp 0xd32a
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xdc60
movq -0x30(%rbp), %rdi
callq 0xd020
movq -0x18(%rbp), %rdi
callq 0x3320
nopw %cs:(%rax,%rax)
// File: danomatika[P]miditester/src/RtMidi.cpp
// Function: MidiInApi::setCallback(void (*)(double, std::vector<unsigned char, std::allocator<unsigned char>>*, void*), void*)
void MidiInApi :: setCallback( RtMidiIn::RtMidiCallback callback, void *userData )
{
  if ( inputData_.usingCallback ) {
    errorString_ = "MidiInApi::setCallback: a callback function is already set!";
    error( RtMidiError::WARNING, errorString_ );
    return;
  }

  if ( !callback ) {
    errorString_ = "RtMidiIn::setCallback: callback function value is invalid!";
    error( RtMidiError::WARNING, errorString_ );
    return;
  }

  inputData_.userCallback = callback;
  inputData_.userData = userData;
  inputData_.usingCallback = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
testb $0x1, 0x98(%rax)
je 0xd4aa
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x80(%rbp)
leaq 0x3519(%rip), %rsi      # 0x10974
callq 0x3290
movq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x30e0
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rdx
xorl %esi, %esi
callq 0xd090
jmp 0xd482
leaq -0x38(%rbp), %rdi
callq 0x3150
jmp 0xd53a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3150
jmp 0xd543
cmpq $0x0, -0x10(%rbp)
jne 0xd519
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x90(%rbp)
leaq 0x34e9(%rip), %rsi      # 0x109b0
callq 0x3290
movq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x30e0
movq -0x70(%rbp), %rdi
movq -0x88(%rbp), %rdx
xorl %esi, %esi
callq 0xd090
jmp 0xd4f7
leaq -0x68(%rbp), %rdi
callq 0x3150
jmp 0xd53a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3150
jmp 0xd543
movq -0x70(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0xa0(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movb $0x1, 0x98(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3320
nopl (%rax)
// File: danomatika[P]miditester/src/RtMidi.cpp
// Function: MidiInApi::cancelCallback()
void MidiInApi :: cancelCallback()
{
  if ( !inputData_.usingCallback ) {
    errorString_ = "RtMidiIn::cancelCallback: no callback function was set!";
    error( RtMidiError::WARNING, errorString_ );
    return;
  }

  inputData_.userCallback = 0;
  inputData_.userData = 0;
  inputData_.usingCallback = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0x98(%rax)
jne 0xd5c9
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x50(%rbp)
leaq 0x346b(%rip), %rsi      # 0x109eb
callq 0x3290
movq -0x50(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x30e0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
xorl %esi, %esi
callq 0xd090
jmp 0xd5a7
leaq -0x28(%rbp), %rdi
callq 0x3150
jmp 0xd5ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3150
jmp 0xd5f0
movq -0x40(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq $0x0, 0xa8(%rax)
movb $0x0, 0x98(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3320
nopl (%rax)
// File: danomatika[P]miditester/src/RtMidi.cpp
// Function: MidiInApi::ignoreTypes(bool, bool, bool)
void MidiInApi :: ignoreTypes( bool midiSysex, bool midiTime, bool midiSense )
{
  inputData_.ignoreFlags = 0;
  if ( midiSysex ) inputData_.ignoreFlags = 0x01;
  if ( midiTime ) inputData_.ignoreFlags |= 0x02;
  if ( midiSense ) inputData_.ignoreFlags |= 0x04;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
andb $0x1, %dl
movb %dl, -0x9(%rbp)
andb $0x1, %cl
movb %cl, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, 0x88(%rax)
testb $0x1, -0x9(%rbp)
je 0xd640
movq -0x18(%rbp), %rax
movb $0x1, 0x88(%rax)
testb $0x1, -0xa(%rbp)
je 0xd65a
movq -0x18(%rbp), %rax
movzbl 0x88(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x88(%rax)
testb $0x1, -0xb(%rbp)
je 0xd674
movq -0x18(%rbp), %rax
movzbl 0x88(%rax), %ecx
orl $0x4, %ecx
movb %cl, 0x88(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: danomatika[P]miditester/src/RtMidi.cpp
// Function: MidiInApi::getMessage(std::vector<unsigned char, std::allocator<unsigned char>>*)
double MidiInApi :: getMessage( std::vector<unsigned char> *message )
{
  message->clear();

  if ( inputData_.usingCallback ) {
    errorString_ = "RtMidiIn::getNextMessage: a user callback is currently set for this port.";
    error( RtMidiError::WARNING, errorString_ );
    return 0.0;
  }

  if ( inputData_.queue.size == 0 ) return 0.0;

  // Copy queued message to the vector pointer argument and then "pop" it.
  std::vector<unsigned char> *bytes = &(inputData_.queue.ring[inputData_.queue.front].bytes);
  message->assign( bytes->begin(), bytes->end() );
  double deltaTime = inputData_.queue.ring[inputData_.queue.front].timeStamp;
  inputData_.queue.size--;
  inputData_.queue.front++;
  if ( inputData_.queue.front == inputData_.queue.ringSize )
    inputData_.queue.front = 0;

  return deltaTime;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x82f0
movq -0x70(%rbp), %rax
testb $0x1, 0x98(%rax)
je 0xd71b
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x80(%rbp)
leaq 0x335f(%rip), %rsi      # 0x10a23
callq 0x3290
movq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x30e0
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rdx
xorl %esi, %esi
callq 0xd090
jmp 0xd6eb
leaq -0x38(%rbp), %rdi
callq 0x3150
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xd7cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3150
jmp 0xd7da
movq -0x70(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jne 0xd732
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xd7cc
movq -0x70(%rbp), %rcx
movq 0x60(%rcx), %rax
movl 0x50(%rcx), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x50(%rbp), %rdi
callq 0x8910
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x8940
movq -0x88(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0xdc80
movq -0x70(%rbp), %rcx
movq 0x60(%rcx), %rax
movl 0x50(%rcx), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movl 0x58(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x58(%rcx)
movl 0x50(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x50(%rcx)
movl 0x50(%rcx), %eax
cmpl 0x5c(%rcx), %eax
jne 0xd7c2
movq -0x70(%rbp), %rax
movl $0x0, 0x50(%rax)
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3320
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/mshalign/mshalign.cpp
// Function: WriteMesh(gaps::R3Mesh*, char const*)
static int
WriteMesh(R3Mesh *mesh, const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Write mesh to file
  if (!mesh->WriteFile(filename)) {
    return 0;
  }

  // Print statistics
  if (print_verbose) {
    printf("Wrote mesh to %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh->NFaces());
    printf("  # Edges = %d\n", mesh->NEdges());
    printf("  # Vertices = %d\n", mesh->NVertices());
    fflush(stdout);
  }

  // Return succes
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsp, %rdi
callq 0xa2b30
movq %rsp, %rdi
callq 0x15df0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x1d0(%rax)
cmpl $0x0, %eax
jne 0x13073
movl $0x0, 0x24(%rsp)
jmp 0x1310e
cmpl $0x0, 0xbab96(%rip)     # 0xcdc10
je 0x13106
movq 0x10(%rsp), %rsi
leaq 0x944cd(%rip), %rdi     # 0xa7559
movb $0x0, %al
callq 0xd070
movq %rsp, %rdi
callq 0xa2bf0
leaq 0x94171(%rip), %rdi     # 0xa7213
movb $0x1, %al
callq 0xd070
movq 0x18(%rsp), %rdi
callq 0x15e10
movl %eax, %esi
leaq 0x9416e(%rip), %rdi     # 0xa722a
movb $0x0, %al
callq 0xd070
movq 0x18(%rsp), %rdi
callq 0x15e30
movl %eax, %esi
leaq 0x94164(%rip), %rdi     # 0xa723a
movb $0x0, %al
callq 0xd070
movq 0x18(%rsp), %rdi
callq 0x15e50
movl %eax, %esi
leaq 0x9415a(%rip), %rdi     # 0xa724a
movb $0x0, %al
callq 0xd070
movq 0xb9ea2(%rip), %rax     # 0xccfa0
movq (%rax), %rdi
callq 0xd4c0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/mshalign/mshalign.cpp
// Function: CreatePointCorrespondences(gaps::R3Mesh*, gaps::R3Point const*, int, gaps::R3Mesh*, gaps::R3Point const*, int, gaps::R3Affine const&, gaps::R3Affine const&, gaps::R3Point*, gaps::R3Point*, int)
static int
CreatePointCorrespondences(
  R3Mesh *mesh1, const R3Point *points1, int npoints1,
  R3Mesh *mesh2, const R3Point *points2, int npoints2, 
  const R3Affine& affine12, const R3Affine& affine21,
  R3Point *correspondences1, R3Point *correspondences2, 
  int max_correspondences)
{
  // Check method
  if (correspondence_method == 0) {
    return CreatePointPointCorrespondences(
      mesh1, points1, npoints1, 
      mesh2, points2, npoints2, 
      affine12, affine21, 
      correspondences1, correspondences2, max_correspondences);
  }
  else {
    return CreatePointSurfaceCorrespondences(
      mesh1, points1, npoints1, 
      mesh2, points2, npoints2, 
      affine12, affine21, 
      correspondences1, correspondences2, max_correspondences);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl 0xa0(%rsp), %eax
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rax
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movl %r9d, 0x34(%rsp)
cmpl $0x0, 0xb867e(%rip)     # 0xcdc20
jne 0x1560a
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x4c(%rsp), %edx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movl 0x34(%rsp), %r9d
movq 0x80(%rsp), %r14
movq 0x88(%rsp), %rbx
movq 0x90(%rsp), %r11
movq 0x98(%rsp), %r10
movl 0xa0(%rsp), %eax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x15680
movl %eax, 0x64(%rsp)
jmp 0x1566e
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x4c(%rsp), %edx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movl 0x34(%rsp), %r9d
movq 0x80(%rsp), %r14
movq 0x88(%rsp), %rbx
movq 0x90(%rsp), %r11
movq 0x98(%rsp), %r10
movl 0xa0(%rsp), %eax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x15a90
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
nopw (%rax,%rax)
// File: czmccrory[P]ManchesterBaby/./assembler.h
// Function: Assembler::Assembler(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Assembler::Assembler(string path)
{
	this -> iSet = InstructionSet();
	this -> buffer = list<string>();
	this -> sTable = SymbolTable();
	this -> filePath = path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
callq 0x37a0
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x90(%rbp)
callq 0x74f0
movq -0x88(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x80(%rbp)
callq 0x4b10
jmp 0x3671
movq -0x98(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3390
leaq -0x40(%rbp), %rdi
callq 0x37a0
jmp 0x3693
movq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
callq 0x7510
movq -0xb8(%rbp), %rdi
callq 0x7550
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x74f0
movq -0x98(%rbp), %rdi
movq -0xb0(%rbp), %rsi
addq $0x20, %rdi
callq 0x7570
movq -0xb0(%rbp), %rdi
callq 0x75a0
leaq -0x78(%rbp), %rdi
callq 0x4b10
jmp 0x3703
movq -0x98(%rbp), %rdi
addq $0x38, %rdi
leaq -0x78(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
callq 0x75c0
movq -0xc0(%rbp), %rdi
callq 0x75f0
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
addq $0x50, %rdi
callq 0x3030
jmp 0x3743
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x377b
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31c0
movq -0x80(%rbp), %rdi
callq 0x75f0
movq -0x90(%rbp), %rdi
callq 0x75a0
movq -0x88(%rbp), %rdi
callq 0x7550
movq -0x18(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: czmccrory[P]ManchesterBaby/./assembler.h
// Function: InstructionSet::contains(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool InstructionSet::contains(string mne)
{
	for (vector<InstructionNode>::iterator it = vec.begin(); it != vec.end(); ++it)
	{
		if ((*it).getMnemonic() == mne)
		{
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7ae0
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rdi
callq 0x7b50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7b10
testb $0x1, %al
jne 0x4145
jmp 0x418f
leaq -0x20(%rbp), %rdi
callq 0x7c10
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x41a0
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x7b80
movb %al, -0x59(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31c0
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x417c
jmp 0x4182
movb $0x1, -0x1(%rbp)
jmp 0x4193
jmp 0x4184
leaq -0x20(%rbp), %rdi
callq 0x7c30
jmp 0x4125
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: czmccrory[P]ManchesterBaby/./assembler.h
// Function: InstructionSet::getOpcode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int InstructionSet::getOpcode(string mne)
{
	vector<InstructionNode>::iterator it;

	for (it = vec.begin(); it != vec.end(); ++it)
	{
		if ((*it).getMnemonic() == mne)
		{
			return (*it).getNumber();
		}
	}

	return -1;
	// compile error
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7c50
movq -0x58(%rbp), %rdi
callq 0x7ae0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rdi
callq 0x7b50
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7b10
testb $0x1, %al
jne 0x422a
jmp 0x4284
leaq -0x20(%rbp), %rdi
callq 0x7c10
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0x41a0
movq -0x60(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x7b80
movb %al, -0x61(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31c0
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x4261
jmp 0x4277
leaq -0x20(%rbp), %rdi
callq 0x7c10
movq %rax, %rdi
callq 0x42a0
movl %eax, -0x4(%rbp)
jmp 0x428b
jmp 0x4279
leaq -0x20(%rbp), %rdi
callq 0x7c30
jmp 0x420a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: czmccrory[P]ManchesterBaby/./assembler.h
// Function: SymbolTable::contains(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool SymbolTable::contains(string label)
{
	list<SymbolNode>::iterator it;

	for(it = table.begin(); it != table.end(); ++it)
	{
		string cLabel = (*it).getLabel();

		if(label == cLabel)
		{
			return true;
		}
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7c70
movq -0x60(%rbp), %rdi
callq 0x7c90
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x60(%rbp), %rdi
callq 0x7cf0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7cc0
testb $0x1, %al
jne 0x43fa
jmp 0x4457
leaq -0x20(%rbp), %rdi
callq 0x7d20
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0x7d40
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7b80
testb $0x1, %al
jne 0x4422
jmp 0x442f
movb $0x1, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0x4436
movl $0x0, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31c0
movl -0x54(%rbp), %eax
testl %eax, %eax
je 0x444a
jmp 0x4448
jmp 0x445b
jmp 0x444c
leaq -0x20(%rbp), %rdi
callq 0x7d70
jmp 0x43da
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: czmccrory[P]ManchesterBaby/./assembler.h
// Function: SymbolTable::printTable()
void SymbolTable::printTable()
{
	list<SymbolNode>::iterator it;

	cout << "SYMBOL TABLE: " << endl;

	for(it = table.begin(); it != table.end(); ++it)
	{
		cout << "Label: " << (*it).getLabel() << "\t Address: " << (*it).getAddress() << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7c70
movq 0xbb39(%rip), %rdi      # 0xffd0
leaq 0x6ba0(%rip), %rsi      # 0xb03e
callq 0x3290
movq %rax, %rdi
movq 0xbb0b(%rip), %rsi      # 0xffb8
callq 0x32d0
movq -0x78(%rbp), %rdi
callq 0x7c90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x78(%rbp), %rdi
callq 0x7cf0
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7cc0
testb $0x1, %al
jne 0x44ea
jmp 0x45e5
movq 0xbadf(%rip), %rdi      # 0xffd0
leaq 0x6b55(%rip), %rsi      # 0xb04d
callq 0x3290
movq %rax, -0x90(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7d20
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x7d40
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x3270
movq %rax, -0x80(%rbp)
jmp 0x4539
movq -0x80(%rbp), %rdi
leaq 0x6b11(%rip), %rsi      # 0xb055
callq 0x3290
movq %rax, -0x98(%rbp)
jmp 0x4552
leaq -0x10(%rbp), %rdi
callq 0x7d20
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x7d90
jmp 0x4569
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3270
movq %rax, -0xa0(%rbp)
jmp 0x4582
movq -0xa0(%rbp), %rdi
movq 0xba28(%rip), %rsi      # 0xffb8
callq 0x32d0
jmp 0x4597
leaq -0x70(%rbp), %rdi
callq 0x31c0
leaq -0x40(%rbp), %rdi
callq 0x31c0
leaq -0x10(%rbp), %rdi
callq 0x7d70
jmp 0x44c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x45da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x31c0
leaq -0x40(%rbp), %rdi
callq 0x31c0
jmp 0x45ee
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: czmccrory[P]ManchesterBaby/./assembler.h
// Function: SymbolTable::addAddress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SymbolTable::addAddress(string label, string address)
{
	if(contains(label))
	{
		list<SymbolNode>::iterator it;

		for (it = table.begin(); it != table.end(); ++it)
		{
			if ((*it).getLabel() == label)
			{
				(*it).setAddress(address);
				return;
			}
		}

	}


	cout << "error undeclared variable" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3100
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x43a0
movb %al, -0xa1(%rbp)
jmp 0x478b
leaq -0x38(%rbp), %rdi
callq 0x31c0
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x47a3
jmp 0x48ba
leaq -0x50(%rbp), %rdi
callq 0x7c70
movq -0xb8(%rbp), %rdi
callq 0x7c90
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x7cf0
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7cc0
testb $0x1, %al
jne 0x47ea
jmp 0x48b8
leaq -0x50(%rbp), %rdi
callq 0x7d20
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x7d40
movq -0xc8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x7b80
movb %al, -0xc9(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31c0
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x482a
jmp 0x48a8
leaq -0x50(%rbp), %rdi
callq 0x7d20
movq -0xc0(%rbp), %rsi
movq %rax, -0xe0(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3100
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0x7ec0
jmp 0x4869
leaq -0xa0(%rbp), %rdi
callq 0x31c0
jmp 0x48dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31c0
jmp 0x48e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x31c0
jmp 0x48e5
jmp 0x48aa
leaq -0x50(%rbp), %rdi
callq 0x7d70
jmp 0x47c4
jmp 0x48ba
movq 0xb70f(%rip), %rdi      # 0xffd0
leaq 0x6799(%rip), %rsi      # 0xb061
callq 0x3290
movq %rax, %rdi
movq 0xb6e1(%rip), %rsi      # 0xffb8
callq 0x32d0
addq $0xe0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3450
nop
// File: czmccrory[P]ManchesterBaby/./assembler.h
// Function: SymbolTable::getAddress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string SymbolTable::getAddress(string label)
{
	if (contains(label))
	{
		list<SymbolNode>::iterator it;

		for(it = table.begin(); it != table.end(); ++it)
		{
			if ((*it).getLabel() == label)
			{
				return (*it).getAddress();
			}
		}
	}
	else
	{
		// return mem address 0 will be overwritten "later"
		return "000000";
	}
	//Should never get here
	return "000000";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0xb0(%rbp)
movq %rsi, %rax
movq -0xb0(%rbp), %rsi
movq %rdi, -0xa8(%rbp)
movq %rdi, %rcx
movq %rcx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3100
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x43a0
movb %al, -0x83(%rbp)
jmp 0x495f
leaq -0x38(%rbp), %rdi
callq 0x31c0
movb -0x83(%rbp), %al
testb $0x1, %al
jne 0x4977
jmp 0x4a47
leaq -0x50(%rbp), %rdi
callq 0x7c70
movq -0x98(%rbp), %rdi
callq 0x7c90
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x98(%rbp), %rdi
callq 0x7cf0
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7cc0
testb $0x1, %al
jne 0x49be
jmp 0x4a45
leaq -0x50(%rbp), %rdi
callq 0x7d20
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x7d40
movq -0xb0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x7b80
movb %al, -0xb1(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31c0
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x49fe
jmp 0x4a35
leaq -0x50(%rbp), %rdi
callq 0x7d20
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x7d90
jmp 0x4af5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31c0
jmp 0x4b05
jmp 0x4a37
leaq -0x50(%rbp), %rdi
callq 0x7d70
jmp 0x4998
jmp 0x4a9e
leaq -0x81(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3460
movq -0xa8(%rbp), %rdi
movq -0xc0(%rbp), %rdx
leaq 0x660c(%rip), %rsi      # 0xb07b
callq 0x7630
jmp 0x4a76
leaq -0x81(%rbp), %rdi
callq 0x32f0
jmp 0x4af5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x81(%rbp), %rdi
callq 0x32f0
jmp 0x4b05
leaq -0x82(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3460
movq -0xa8(%rbp), %rdi
movq -0xc8(%rbp), %rdx
leaq 0x65b5(%rip), %rsi      # 0xb07b
callq 0x7630
jmp 0x4acd
leaq -0x82(%rbp), %rdi
callq 0x32f0
jmp 0x4af5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x82(%rbp), %rdi
callq 0x32f0
jmp 0x4b05
movq -0xa0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3450
nop
// File: czmccrory[P]ManchesterBaby/./assembler.h
// Function: decToBinaryString[abi:cxx11](int, int)
string decToBinaryString(int dec, int length)
{
	string bin = ""; // vector to hold binary value (in this case size 8 for rule.)
	//cout << dec << endl;

	int i;
	for ( i=length; dec>0; i--)
	{
		// take the remainder of the dec / 2 and save it to the vector
		// this value will always be 1 or 0
		int mod = (dec%2);

		if (mod == 1)
		{
			bin += "1";
		}
		else
		{
			bin += "0";
		}

		// update dec
		dec /= 2;
	}

	while (i > 0)
	{
		bin += "0";
		i--;
	}
		//cout << bin <<endl;
		return bin;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3460
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x6547(%rip), %rsi      # 0xb0e4
callq 0x7630
jmp 0x4ba4
leaq -0x12(%rbp), %rdi
callq 0x32f0
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x4c46
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
jne 0x4c16
movq -0x40(%rbp), %rdi
leaq 0x64a6(%rip), %rsi      # 0xb082
callq 0x3280
jmp 0x4be3
jmp 0x4c2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x32f0
jmp 0x4c88
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31c0
jmp 0x4c88
movq -0x40(%rbp), %rdi
leaq 0x645f(%rip), %rsi      # 0xb080
callq 0x3280
jmp 0x4c28
jmp 0x4c2a
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4bb3
jmp 0x4c48
cmpl $0x0, -0x28(%rbp)
jle 0x4c6b
movq -0x40(%rbp), %rdi
leaq 0x6427(%rip), %rsi      # 0xb080
callq 0x3280
jmp 0x4c60
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4c48
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4c7e
movq -0x40(%rbp), %rdi
callq 0x31c0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: czmccrory[P]ManchesterBaby/assembler.cpp
// Function: Assembler::assemble()
void Assembler::assemble()
{
	try
	{
		assembleFirstPass();
		assembleSecondPass();
		flushBufferToFile();
	}
	catch(AssemblerException e)
	{
		cout << "\033[1;31mAssembler Error: \033[0m" << e.what() << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4da0
jmp 0x4cbb
movq -0x48(%rbp), %rdi
callq 0x51b0
jmp 0x4cc6
movq -0x48(%rbp), %rdi
callq 0x5490
jmp 0x4cd1
jmp 0x4d6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4d8e
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3350
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x7f60
jmp 0x4d0d
movq -0x50(%rbp), %rdi
callq 0x30e0
movq 0xb2b3(%rip), %rdi      # 0xffd0
leaq 0x6360(%rip), %rsi      # 0xb084
callq 0x3290
movq %rax, -0x58(%rbp)
jmp 0x4d2f
leaq -0x40(%rbp), %rdi
callq 0x7fe0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x3290
movq %rax, -0x60(%rbp)
jmp 0x4d4a
movq -0x60(%rbp), %rdi
movq 0xb263(%rip), %rsi      # 0xffb8
callq 0x32d0
jmp 0x4d5c
leaq -0x40(%rbp), %rdi
callq 0x8000
callq 0x3420
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8000
callq 0x3420
jmp 0x4d8c
jmp 0x4d8e
movq -0x10(%rbp), %rdi
callq 0x3450
movq %rax, %rdi
callq 0x7fd0
nop
// File: czmccrory[P]ManchesterBaby/assembler.cpp
// Function: Assembler::flushBufferToFile()
void Assembler::flushBufferToFile()
{
	ofstream ofs("a." + filePath);

	if (!ofs)
	{
		cerr << "Error opening file for output" << endl;
	}

	list<string>::iterator it;

	for(it = buffer.begin(); it != buffer.end(); ++it)
	{
		ofs << (*it) << endl;
	}

	ofs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x260(%rbp)
addq $0x50, %rdx
leaq 0x5cfe(%rip), %rsi      # 0xb1b3
leaq -0x228(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x8240
movq -0x258(%rbp), %rsi
leaq -0x208(%rbp), %rdi
movl $0x10, %edx
callq 0x3490
jmp 0x54e2
leaq -0x228(%rbp), %rdi
callq 0x31c0
movq -0x208(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x208(%rbp,%rax), %rdi
callq 0x3130
movb %al, -0x261(%rbp)
jmp 0x550e
movb -0x261(%rbp), %al
testb $0x1, %al
jne 0x551a
jmp 0x5593
movq 0xaacf(%rip), %rdi      # 0xfff0
leaq 0x5c8e(%rip), %rsi      # 0xb1b6
callq 0x3290
movq %rax, -0x270(%rbp)
jmp 0x5536
movq -0x270(%rbp), %rdi
movq 0xaa74(%rip), %rsi      # 0xffb8
callq 0x32d0
jmp 0x554b
jmp 0x5593
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x31c0
jmp 0x5660
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x33c0
jmp 0x5660
leaq -0x240(%rbp), %rdi
callq 0x8350
movq -0x260(%rbp), %rdi
addq $0x20, %rdi
callq 0x8110
movq %rax, -0x248(%rbp)
movq -0x248(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x260(%rbp), %rdi
addq $0x20, %rdi
callq 0x83a0
movq %rax, -0x250(%rbp)
leaq -0x240(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x8370
testb $0x1, %al
jne 0x55f4
jmp 0x563d
leaq -0x240(%rbp), %rdi
callq 0x81d0
movq %rax, %rsi
leaq -0x208(%rbp), %rdi
callq 0x3270
movq %rax, -0x278(%rbp)
jmp 0x5618
movq -0x278(%rbp), %rdi
movq 0xa992(%rip), %rsi      # 0xffb8
callq 0x32d0
jmp 0x562d
jmp 0x562f
leaq -0x240(%rbp), %rdi
callq 0x83d0
jmp 0x55c4
leaq -0x208(%rbp), %rdi
callq 0x33a0
jmp 0x564b
leaq -0x208(%rbp), %rdi
callq 0x33c0
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x230(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: czmccrory[P]ManchesterBaby/assembler.cpp
// Function: Assembler::addVariableToSymbolTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Assembler::addVariableToSymbolTable(string label, int address)
{
	// add label (if not already defined)
	sTable.addLabel(label);

	// convert address to binary and add to symboltable
	
	string strAddress = decToBinaryString(address, 6);
	sTable.addAddress(label, strAddress);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
addq $0x38, %rax
movq %rax, -0xb8(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3100
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x4600
jmp 0x6318
leaq -0x38(%rbp), %rdi
callq 0x31c0
movl -0x14(%rbp), %esi
leaq -0x68(%rbp), %rdi
movl $0x6, %edx
callq 0x4b60
movq -0xc0(%rbp), %rax
movq -0xc8(%rbp), %rsi
addq $0x38, %rax
movq %rax, -0xd0(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3100
jmp 0x6359
leaq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3100
jmp 0x636b
movq -0xd0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x4730
jmp 0x6387
leaq -0xa8(%rbp), %rdi
callq 0x31c0
leaq -0x88(%rbp), %rdi
callq 0x31c0
leaq -0x68(%rbp), %rdi
callq 0x31c0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31c0
jmp 0x6411
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6408
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x63fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x31c0
leaq -0x88(%rbp), %rdi
callq 0x31c0
leaq -0x68(%rbp), %rdi
callq 0x31c0
movq -0x40(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)