LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compressor::endSegment(char const*)
void Compressor::endSegment(const char* sha1string) {
  if (state==SEG1)
    postProcess();
  assert(state==SEG2);
  enc.compress(-1);
  if (verify && pz.hend) {
    pz.run(-1);
    pz.flush();
  }
  enc.out->put(0);
  enc.out->put(0);
  enc.out->put(0);
  enc.out->put(0);
  if (sha1string) {
    enc.out->put(253);
    for (int i=0; i<20; ++i)
      enc.out->put(sha1string[i]);
  }
  else
    enc.out->put(254);
  state=BLOCK2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, 0x1b25c(%rdi)
jne 0xd921
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd6fa
leaq 0x180(%rbx), %r15
pushq $-0x1
popq %rsi
movq %r15, %rdi
callq 0xc790
cmpb $0x1, 0x1b260(%rbx)
jne 0xd95f
cmpl $0x0, 0xf0(%rbx)
je 0xd95f
leaq 0xc0(%rbx), %r12
pushq $-0x1
popq %rsi
movq %r12, %rdi
callq 0xbb08
movq %r12, %rdi
callq 0x993c
movq (%r15), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq (%r15), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq (%r15), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq (%r15), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq (%r15), %rdi
movq (%rdi), %rax
movq (%rax), %rax
testq %r14, %r14
je 0xd9b7
movl $0xfd, %esi
callq *%rax
xorl %r12d, %r12d
cmpq $0x14, %r12
je 0xd9be
movq (%r15), %rdi
movsbl (%r14,%r12), %esi
movq (%rdi), %rax
callq *(%rax)
incq %r12
jmp 0xd99f
movl $0xfe, %esi
callq *%rax
movl $0x3, 0x1b25c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compressor::endSegmentChecksum(long*, bool)
char* Compressor::endSegmentChecksum(int64_t* size, bool dosha1) {
  if (state==SEG1)
    postProcess();
  assert(state==SEG2);
  enc.compress(-1);
  if (verify && pz.hend) {
    pz.run(-1);
    pz.flush();
  }
  enc.out->put(0);
  enc.out->put(0);
  enc.out->put(0);
  enc.out->put(0);
  if (verify) {
    if (size) *size=sha1.usize();
    memcpy(sha1result, sha1.result(), 20);
  }
  if (verify && dosha1) {
    enc.out->put(253);
    for (int i=0; i<20; ++i)
      enc.out->put(sha1result[i]);
  }
  else
    enc.out->put(254);
  state=BLOCK2;
  return verify ? sha1result : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x2, 0x1b25c(%rdi)
jne 0xd9f9
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd6fa
leaq 0x180(%rbx), %r14
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0xc790
cmpb $0x1, 0x1b260(%rbx)
jne 0xda37
cmpl $0x0, 0xf0(%rbx)
je 0xda37
leaq 0xc0(%rbx), %r12
pushq $-0x1
popq %rsi
movq %r12, %rdi
callq 0xbb08
movq %r12, %rdi
callq 0x993c
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movb 0x1b260(%rbx), %al
cmpb $0x1, %al
jne 0xdab1
testq %r15, %r15
je 0xda8c
movq 0x1b1d8(%rbx), %rax
shrq $0x3, %rax
movq %rax, (%r15)
leaq 0x1b1d8(%rbx), %rdi
callq 0x4cd8
movups (%rax), %xmm0
movups %xmm0, 0x1b248(%rbx)
movl 0x10(%rax), %eax
movl %eax, 0x1b258(%rbx)
movb 0x1b260(%rbx), %al
andb %bpl, %al
movq (%r14), %rdi
movq (%rdi), %rcx
movq (%rcx), %rcx
cmpb $0x1, %al
jne 0xdaeb
movl $0xfd, %esi
callq *%rcx
pushq $-0x14
popq %r14
testq %r14, %r14
je 0xdaf2
movq 0x180(%rbx), %rdi
movsbl 0x1b25c(%rbx,%r14), %esi
movq (%rdi), %rax
callq *(%rax)
incq %r14
jmp 0xdacc
movl $0xfe, %esi
callq *%rcx
movl $0x3, 0x1b25c(%rbx)
xorl %eax, %eax
cmpb $0x0, 0x1b260(%rbx)
leaq 0x1b248(%rbx), %rcx
cmovneq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::compress(libzpaq::Reader*, libzpaq::Writer*, char const*, char const*, char const*, bool)
void compress(Reader* in, Writer* out, const char* method,
              const char* filename, const char* comment, bool dosha1) {

  // Get block size
  int bs=4;
  if (method && method[0] && method[1]>='0' && method[1]<='9') {
    bs=method[1]-'0';
    if (method[2]>='0' && method[2]<='9') bs=bs*10+method[2]-'0';
    if (bs>11) bs=11;
  }
  bs=(0x100000<<bs)-4096;

  // Compress in blocks
  StringBuffer sb(bs);
  sb.write(0, bs);
  int n=0;
  while (in && (n=in->read((char*)sb.data(), bs))>0) {
    sb.resize(n);
    compressBlock(&sb, out, method, filename, comment, dosha1);
    filename=0;
    comment=0;
    sb.resize(0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %r14d
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, %r15
pushq $0x4
popq %rcx
testq %rdx, %rdx
je 0xdb8f
cmpb $0x0, (%rbx)
je 0xdb8f
movb 0x1(%rbx), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0xdb8f
movzbl %al, %eax
movsbl 0x2(%rbx), %ecx
leal -0x30(%rcx), %edx
imull $0xa, %eax, %esi
cmpb $0xa, %dl
leal -0x30(%rsi,%rcx), %edx
cmovael %eax, %edx
cmpl $0xb, %edx
pushq $0xb
popq %rcx
cmovll %edx, %ecx
movl $0x100000, %ebp         # imm = 0x100000
shll %cl, %ebp
leaq 0x1d163(%rip), %rax     # 0x2ad00
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1d194(%rip), %rax     # 0x2ad40
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
orq $-0x1, 0x30(%rdi)
addl $0xfffff000, %ebp       # imm = 0xFFFFF000
movslq %ebp, %rdx
movq %rdx, 0x38(%rdi)
xorl %esi, %esi
callq 0x1c9f2
testq %r15, %r15
je 0xdc46
movzbl %r14b, %r14d
movq 0x18(%rsp), %rsi
movq (%r15), %rax
movq %r15, %rdi
movl %ebp, %edx
callq *0x8(%rax)
testl %eax, %eax
jle 0xdc46
movl %eax, %eax
movq %rax, 0x28(%rsp)
cmpq %rax, 0x30(%rsp)
jbe 0xdc04
movq %rax, 0x30(%rsp)
leaq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
movq %r12, %r8
movl %r14d, %r9d
callq 0xdca6
andq $0x0, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
movl $0x0, %r12d
movl $0x0, %r13d
je 0xdbdd
andq $0x0, 0x30(%rsp)
xorl %r12d, %r12d
xorl %r13d, %r13d
jmp 0xdbdd
leaq 0x1d0b3(%rip), %rax     # 0x2ad00
movq %rax, 0x8(%rsp)
leaq 0x1d0e7(%rip), %rax     # 0x2ad40
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4200
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdc79
movq %rax, %rbx
leaq 0x1d07d(%rip), %rax     # 0x2ad00
movq %rax, 0x8(%rsp)
leaq 0x1d0b1(%rip), %rax     # 0x2ad40
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4200
movq %rbx, %rdi
callq 0x4320
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::oplen(unsigned char const*)
static int oplen(const U8* hcomp) {
  if (*hcomp==255) return 3;
  if (*hcomp%8==7) return 2;
  if (*hcomp<51 && (*hcomp%8-1)/2==0) {  // ++ or -- opcode
    int i;
    for (i=1; i<127 && hcomp[i]==hcomp[0]; ++i);
    return i;
  }
  return 1;
}

// Assembly:
movb (%rdi), %cl
cmpb $-0x1, %cl
je 0x111a7
movl %ecx, %eax
andb $0x7, %al
cmpb $0x7, %al
jne 0x111ab
pushq $0x2
jmp 0x111d2
pushq $0x3
jmp 0x111d2
cmpb $0x33, %cl
setae %dl
cmpb $0x3, %al
setae %al
orb %dl, %al
jne 0x111d0
pushq $0x1
popq %rdx
pushq $0x7f
popq %rax
cmpq $0x7f, %rdx
je 0x111d6
cmpb %cl, (%rdi,%rdx)
jne 0x111d4
incq %rdx
jmp 0x111c0
pushq $0x1
popq %rax
retq
movl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::itos[abi:cxx11](long, int)
std::string itos(int64_t x, int n=1) {
  assert(x>=0);
  assert(n>=0);
  std::string r;
  for (; x || n>0; x/=10, --n) r=std::string(1, '0'+x%10)+r;
  return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movl %edx, %ebp
movq %rsi, %r13
movb $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r14
pushq $0x1
popq %r15
leaq 0x28(%rsp), %r12
testq %r13, %r13
setne %al
testl %ebp, %ebp
setg %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x16a6b
movq %r13, %rax
cqto
pushq $0xa
popq %rcx
idivq %rcx
addb $0x30, %dl
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movsbl %dl, %edx
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x41d0
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ca70
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4220
movq %r12, %rdi
callq 0x43a8
movq %r14, %rdi
callq 0x43a8
decl %ebp
jmp 0x16a03
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x43a8
jmp 0x16a8f
movq %rax, %r14
movq %rbx, %rdi
callq 0x43a8
movq %r14, %rdi
callq 0x4320
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::e8e9(unsigned char*, int)
void e8e9(unsigned char* buf, int n) {
  for (int i=n-5; i>=0; --i) {
    if (((buf[i]&254)==0xe8) && ((buf[i+4]+1)&254)==0) {
      unsigned a=(buf[i+1]|buf[i+2]<<8|buf[i+3]<<16)+i;
      buf[i+1]=a;
      buf[i+2]=a>>8;
      buf[i+3]=a>>16;
    }
  }
}

// Assembly:
addl $-0x5, %esi
testl %esi, %esi
js 0x16ae2
movl %esi, %eax
movb (%rdi,%rax), %cl
andb $-0x2, %cl
cmpb $-0x18, %cl
jne 0x16ade
movb 0x4(%rdi,%rax), %cl
incb %cl
cmpb $0x1, %cl
ja 0x16ade
movzwl 0x1(%rdi,%rax), %edx
movzbl 0x3(%rdi,%rax), %ecx
shll $0x10, %ecx
addl %esi, %edx
addl %edx, %ecx
movb %dl, 0x1(%rdi,%rax)
movb %ch, 0x2(%rdi,%rax)
shrl $0x10, %ecx
movb %cl, 0x3(%rdi,%rax)
decl %esi
jmp 0x16aa2
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::LZBuffer::read(char*, int)
int LZBuffer::read(char* p, int n) {
  if (rpos==wpos) fill();
  int nr=n;
  if (nr>int(wpos-rpos)) nr=wpos-rpos;
  if (nr) memcpy(p, buf+rpos, nr);
  rpos+=nr;
  assert(rpos<=wpos);
  if (rpos==wpos) rpos=wpos=0;
  return nr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x74(%rdi), %eax
movl 0x78(%rdi), %ecx
cmpl %ecx, %eax
jne 0x16b66
movq %rbx, %rdi
callq 0x16bae
movl 0x74(%rbx), %eax
movl 0x78(%rbx), %ecx
movl %ecx, %ebp
subl %eax, %ebp
cmpl %r15d, %ebp
cmovgel %r15d, %ebp
testl %ebp, %ebp
je 0x16b93
movl %eax, %eax
leaq (%rbx,%rax), %rsi
addq $0x90, %rsi
movslq %ebp, %rdx
movq %r14, %rdi
callq 0x4140
movl 0x74(%rbx), %eax
movl 0x78(%rbx), %ecx
addl %ebp, %eax
movl %eax, 0x74(%rbx)
cmpl %ecx, %eax
jne 0x16ba1
andq $0x0, 0x74(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::LZBuffer::write_literal(unsigned int, unsigned int&)
void LZBuffer::write_literal(unsigned i, unsigned& lit) {
  assert(lit>=0);
  assert(i>=0 && i<=n);
  assert(i>=lit);
  if (level==1) {
    if (lit<1) return;
    int ll=lg(lit);
    assert(ll>=1 && ll<=24);
    putb(0, 2);
    --ll;
    while (--ll>=0) {
      putb(1, 1);
      putb((lit>>ll)&1, 1);
    }
    putb(0, 1);
    while (lit) putb(in[i-lit--], 8);
  }
  else {
    assert(level==2);
    while (lit>0) {
      unsigned lit1=lit;
      if (lit1>64) lit1=64;
      put(lit1-1);
      for (unsigned j=i-lit; j<i-lit+lit1; ++j) put(in[j]);
      lit-=lit1;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
cmpl $0x1, 0x2c(%rdi)
movl (%rdx), %edi
jne 0x1780d
testl %edi, %edi
je 0x178b6
callq 0x16ae3
movl %eax, %ebp
pushq $0x2
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x1cab0
decl %ebp
pushq $0x1
popq %r12
testl %ebp, %ebp
jle 0x17882
decl %ebp
movq %r15, %rdi
movl %r12d, %esi
movl %r12d, %edx
callq 0x1cab0
movl (%rbx), %eax
xorl %esi, %esi
btl %ebp, %eax
setb %sil
movq %r15, %rdi
movl %r12d, %edx
callq 0x1cab0
jmp 0x177dd
pushq $0x40
popq %rax
testl %edi, %edi
je 0x178b6
cmpl $0x40, %edi
cmovael %eax, %edi
leal -0x1(%rdi), %ecx
movl 0x78(%r15), %r9d
leal 0x1(%r9), %edx
movl %edx, 0x78(%r15)
movb %cl, 0x90(%r15,%r9)
movl (%rbx), %r8d
movl %r14d, %ecx
subl %r8d, %ecx
leal (%rdi,%r14), %edx
movq 0x20(%r15), %rsi
addl $0x2, %r9d
movl %edx, %r10d
subl %r8d, %r10d
cmpq %r10, %rcx
jae 0x17877
leal -0x1(%r9), %r8d
movb (%rsi,%rcx), %r10b
movl %r9d, 0x78(%r15)
movl %r8d, %r8d
movb %r10b, 0x90(%r15,%r8)
incq %rcx
movl (%rbx), %r8d
incl %r9d
jmp 0x1784a
subl %edi, %r8d
movl %r8d, (%rbx)
movl %r8d, %edi
jmp 0x17810
pushq $0x1
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x1cab0
pushq $0x8
popq %rbp
movl (%rbx), %eax
testl %eax, %eax
je 0x178b6
movq 0x20(%r15), %rcx
leal -0x1(%rax), %edx
movl %edx, (%rbx)
movl %r14d, %edx
subl %eax, %edx
movzbl (%rcx,%rdx), %esi
movq %r15, %rdi
movl %ebp, %edx
callq 0x1cab0
jmp 0x17892
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/./libzpaq.h
// Function: libzpaq::SHA1::put(int)
void put(int c) {  // hash 1 byte
    U32& r=w[U32(len)>>5&15];
    r=(r<<8)|(c&255);
    len+=8;
    if ((U32(len)&511)==0) process();
  }

// Assembly:
movq (%rdi), %rax
movl %eax, %ecx
shrl $0x3, %ecx
andl $0x3c, %ecx
movl 0x1c(%rdi,%rcx), %edx
shll $0x8, %edx
movzbl %sil, %esi
orl %edx, %esi
movl %esi, 0x1c(%rdi,%rcx)
addq $0x8, %rax
movq %rax, (%rdi)
testw $0x1ff, %ax             # imm = 0x1FF
je 0x4e5c
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/./libzpaq.h
// Function: libzpaq::SHA256::put(int)
void put(int c) {  // hash 1 byte
    unsigned& r=w[len0>>5&15];
    r=(r<<8)|(c&255);
    if (!(len0+=8)) ++len1;
    if ((len0&511)==0) process();
  }

// Assembly:
movl (%rdi), %eax
movl %eax, %ecx
shrl $0x3, %ecx
andl $0x3c, %ecx
movl 0x28(%rdi,%rcx), %edx
shll $0x8, %edx
movzbl %sil, %esi
orl %edx, %esi
movl %esi, 0x28(%rdi,%rcx)
addl $0x8, %eax
movl %eax, (%rdi)
je 0x1c377
testw $0x1ff, %ax             # imm = 0x1FF
je 0x60f2
retq
incl 0x4(%rdi)
jmp 0x60f2
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/./libzpaq.h
// Function: libzpaq::Array<unsigned int>::resize(unsigned long, int)
void Array<T>::resize(size_t sz, int ex) {
  assert(size_t(-1)>0);  // unsigned type?
  while (ex>0) {
    if (sz>sz*2) error("Array too big");
    sz*=2, --ex;
  }
  if (n>0) {
    assert(offset>0 && offset<=64);
    assert((char*)data-offset);
    ::free((char*)data-offset);
  }
  n=0;
  offset=0;
  if (sz==0) return;
  n=sz;
  const size_t nb=128+n*sizeof(T);  // test for overflow
  if (nb<=128 || (nb-128)/sizeof(T)!=n) n=0, error("Array too big");
  data=(T*)::calloc(nb, 1);
  if (!data) n=0, error("Out of memory");
  offset=64-(((char*)data-(char*)0)&63);
  assert(offset>0 && offset<=64);
  data=(T*)((char*)data+offset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8a3f(%rip), %r15      # 0x24df9
testl %ebp, %ebp
jle 0x1c3d2
testq %r14, %r14
jns 0x1c3cb
movq %r15, %rdi
callq 0x44dc
addq %r14, %r14
decl %ebp
jmp 0x1c3ba
cmpq $0x0, 0x8(%rbx)
je 0x1c3e8
movq (%rbx), %rdi
movslq 0x10(%rbx), %rax
subq %rax, %rdi
callq 0x4200
andq $0x0, 0x8(%rbx)
andl $0x0, 0x10(%rbx)
testq %r14, %r14
je 0x1c462
movq %r14, 0x8(%rbx)
leaq 0x80(,%r14,4), %r15
cmpq $0x81, %r15
setae %al
shrq $0x3e, %r14
sete %cl
testb %cl, %al
jne 0x1c428
andq $0x0, 0x8(%rbx)
leaq 0x89d6(%rip), %rdi      # 0x24df9
callq 0x44dc
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x4100
movq %rax, (%rbx)
testq %rax, %rax
jne 0x1c44f
andq $0x0, 0x8(%rbx)
leaq 0x6296(%rip), %rdi      # 0x226dd
callq 0x44dc
movq (%rbx), %rax
movl %eax, %ecx
andl $0x3f, %ecx
pushq $0x40
popq %rdx
subl %ecx, %edx
movl %edx, 0x10(%rbx)
addq %rax, %rdx
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/./libzpaq.h
// Function: libzpaq::Decoder::get()
int get() {        // return 1 byte of buffered input or EOF
    if (rpos==wpos) {
      rpos=0;
      wpos=in ? in->read(&buf[0], BUFSIZE) : 0;
      assert(wpos<=BUFSIZE);
    }
    return rpos<wpos ? U8(buf[rpos++]) : -1;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x1c(%rdi), %ecx
movl 0x20(%rdi), %eax
cmpl %eax, %ecx
jne 0x1c8b3
andl $0x0, 0x1c(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1c8ac
movq 0x1b050(%rbx), %rsi
movq (%rdi), %rax
movl $0x10000, %edx          # imm = 0x10000
callq *0x8(%rax)
movl 0x1c(%rbx), %ecx
jmp 0x1c8b0
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, 0x20(%rbx)
cmpl %eax, %ecx
jae 0x1c8cc
leal 0x1(%rcx), %eax
movl %eax, 0x1c(%rbx)
movl %ecx, %eax
movq 0x1b050(%rbx), %rcx
movzbl (%rcx,%rax), %eax
jmp 0x1c8cf
pushq $-0x1
popq %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/./libzpaq.h
// Function: libzpaq::StringBuffer::write(char const*, int)
void write(const char* buf, int n) {
    if (n<1) return;
    lengthen(n);
    assert(p);
    assert(wpos+n<=al);
    if (buf) memcpy(p+wpos, buf, n);
    wpos+=n;
  }

// Assembly:
testl %edx, %edx
jle 0x1ca2d
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %r15d
movq %r15, %rsi
callq 0x1cf0c
testq %r14, %r14
je 0x1ca24
movq 0x10(%rbx), %rdi
addq 0x20(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4140
addq %r15, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::LZBuffer::putb(unsigned int, int)
void putb(unsigned x, int k) {
    x&=(1<<k)-1;
    bits|=x<<nbits;
    nbits+=k;
    while (nbits>7) {
      assert(wpos<BUFSIZE);
      buf[wpos++]=bits, bits>>=8, nbits-=8;
    }
  }

// Assembly:
pushq $-0x1
popq %rax
movl %edx, %ecx
shll %cl, %eax
notl %eax
andl %esi, %eax
movl 0x70(%rdi), %ecx
movl 0x78(%rdi), %esi
shll %cl, %eax
orl 0x6c(%rdi), %eax
movl %eax, 0x6c(%rdi)
addl %edx, %ecx
cmpl $0x8, %ecx
jb 0x1cae9
movl %esi, %edx
incl %esi
movl %esi, 0x78(%rdi)
movb %al, 0x90(%rdi,%rdx)
shrl $0x8, %eax
movl %eax, 0x6c(%rdi)
addl $-0x8, %ecx
jmp 0x1cacb
movl %ecx, 0x70(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::LZBuffer::get()
int get() {
    int c=-1;
    if (rpos==wpos) fill();
    if (rpos<wpos) c=buf[rpos++];
    if (rpos==wpos) rpos=wpos=0;
    return c;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x74(%rdi), %edx
movl 0x78(%rdi), %ecx
cmpl %ecx, %edx
jne 0x1cd64
movq %rbx, %rdi
callq 0x16bae
movl 0x74(%rbx), %edx
movl 0x78(%rbx), %ecx
cmpl %ecx, %edx
jae 0x1cd79
movl %edx, %eax
incl %edx
movl %edx, 0x74(%rbx)
movzbl 0x90(%rbx,%rax), %eax
jmp 0x1cd7c
pushq $-0x1
popq %rax
cmpl %ecx, %edx
jne 0x1cd85
andq $0x0, 0x74(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/./libzpaq.h
// Function: libzpaq::StringBuffer::read(char*, int)
int read(char* buf, int n) {
    assert(rpos<=wpos);
    assert(wpos<=al);
    assert(!al==!p);
    if (rpos+n>wpos) n=wpos-rpos;
    if (n>0 && buf) memcpy(buf, p+rpos, n);
    rpos+=n;
    return n;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %rsi
movslq %edx, %r14
leaq (%rsi,%r14), %rdx
movl %ecx, %edi
subl %esi, %edi
cmpq %rcx, %rdx
cmoval %edi, %r14d
testq %rax, %rax
je 0x1ce8d
testl %r14d, %r14d
jle 0x1ce8d
addq 0x10(%rbx), %rsi
movl %r14d, %edx
movq %rax, %rdi
callq 0x4140
movq 0x28(%rbx), %rsi
movslq %r14d, %rax
addq %rsi, %rax
movq %rax, 0x28(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/./libzpaq.h
// Function: libzpaq::StringBuffer::lengthen(unsigned long)
void lengthen(size_t n) {
    assert(wpos<=al);
    if (wpos+n>limit || wpos+n<wpos) error("StringBuffer overflow");
    if (wpos+n<=al) return;
    size_t a=al;
    while (wpos+n>=a) a=a*2+init;
    reserve(a);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
addq %rsi, %rax
setae %cl
cmpq 0x30(%rdi), %rax
setbe %dl
testb %cl, %dl
jne 0x1cf3e
movq %rsi, %r14
leaq 0x7eb1(%rip), %rdi      # 0x24de3
callq 0x44dc
addq 0x20(%rbx), %r14
movq %r14, %rax
movq 0x18(%rbx), %rsi
cmpq %rsi, %rax
jbe 0x1cf56
movq 0x38(%rbx), %rcx
cmpq %rsi, %rax
jb 0x1cf5e
leaq (%rcx,%rsi,2), %rsi
jmp 0x1cf4b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1cf6e
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/./libzpaq.h
// Function: libzpaq::StringBuffer::reserve(unsigned long)
void reserve(size_t a) {
    assert(!al==!p);
    if (a<=al) return;
    unsigned char* q=0;
    if (a>0) q=(unsigned char*)(p ? realloc(p, a) : malloc(a));
    if (a>0 && !q) error("Out of memory");
    p=q;
    al=a;
  }

// Assembly:
cmpq %rsi, 0x18(%rdi)
jae 0x1cfbb
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1cf92
movq %rbx, %rsi
callq 0x4300
jmp 0x1cf9a
movq %rbx, %rdi
callq 0x4240
movq %rax, %r15
testq %rax, %rax
jne 0x1cfae
leaq 0x5734(%rip), %rdi      # 0x226dd
callq 0x44dc
movq %r15, 0x10(%r14)
movq %rbx, 0x18(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %edi
jle 0x13af
movq 0x8(%rsi), %rdi
leaq 0x1d1d(%rip), %rsi      # 0x300e
callq 0x1110
testq %rax, %rax
je 0x13ca
movq %rax, %r14
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %eax, %eax
leaq 0x3df6(%rip), %r13      # 0x5110
cmpq $0x800, %rax            # imm = 0x800
je 0x132d
andq $0x0, (%rax,%r13)
addq $0x8, %rax
jmp 0x131a
leaq -0x50(%rbp), %r15
movl $0xff, %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x1404
testb %al, %al
je 0x135d
cmpb $0x1, -0x4c(%rbp)
jne 0x1337
movl -0x50(%rbp), %eax
cmpl %r12d, %eax
cmovael %r12d, %eax
incq (%r13,%rax,8)
jmp 0x1337
leaq 0x1cb7(%rip), %rdi      # 0x301b
callq 0x1170
leaq 0x1ca1(%rip), %r15      # 0x3011
xorl %r12d, %r12d
cmpq $0x100, %r12            # imm = 0x100
je 0x139b
movq (%r13), %rdx
testq %rdx, %rdx
je 0x1392
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1040
incq %r12
addq $0x8, %r13
jmp 0x1373
movq %r14, %rdi
callq 0x10e0
movq %rbx, %rdi
callq 0x13f0
xorl %eax, %eax
jmp 0x13cd
movq 0x3c2a(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movq (%rsi), %rdx
leaq 0x1c41(%rip), %rsi      # 0x3004
xorl %eax, %eax
callq 0x1160
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x13f0
movq %r14, %rdi
callq 0x11a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/danomatika[P]miditester/src/main.cpp
// Function: statusByteName[abi:cxx11](unsigned char)
std::string statusByteName(unsigned char status) {
    if(status < MIDI_SYSEX) status = status & 0xF0;
    switch(status) {
        case MIDI_NOTEOFF:        return "NOTEOFF";
        case MIDI_NOTEON:         return "NOTEON";
        case MIDI_POLYAFTERTOUCH: return "POLYAFTERTOUCH";
        case MIDI_CONTROLCHANGE:  return "CONTROLCHANGE";
        case MIDI_PROGRAMCHANGE:  return "PROGRAMCHANGE";
        case MIDI_AFTERTOUCH:     return "AFTERTOUCH";
        case MIDI_PITCHBEND:      return "PITCHBEND";
        case MIDI_SYSEX:          return "SYSEX";
        case MIDI_TIMECODE:       return "TIMECODE";
        case MIDI_SONGPOS:        return "SONGPOS";
        case MIDI_SONGSELECT:     return "SONGSELECT";
        case MIDI_TUNEREQUEST:    return "TUNEREQUEST";
        case MIDI_SYSEXEND:       return "SYSEXEND";
        case MIDI_CLOCK:          return "CLOCK";
        case MIDI_START:          return "START";
        case MIDI_CONTINUE:       return "CONTINUE";
        case MIDI_STOP:           return "STOP";
        case MIDI_ACTIVESENSING:  return "ACTIVESENSE";
        case MIDI_SYSTEMRESET:    return "SYSTEMRESET";
        default:                  return "UNKNOWN";
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %eax
andb $-0x10, %al
cmpb $-0x10, %sil
movzbl %al, %eax
cmovael %esi, %eax
movq %rdi, %rbx
movzbl %al, %eax
leal -0xe0(%rax), %ecx
cmpl $0x1f, %ecx
ja 0x5000
leaq 0x2025(%rip), %rax      # 0x7010
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x22e3(%rip), %rsi      # 0x72de
jmp 0x50f3
cmpl $0xd0, %eax
je 0x50ec
cmpl $0x90, %eax
je 0x50e3
cmpl $0xa0, %eax
je 0x50c8
cmpl $0xb0, %eax
je 0x50da
cmpl $0xc0, %eax
je 0x50d1
cmpl $0x80, %eax
jne 0x504a
leaq 0x225f(%rip), %rsi      # 0x72a4
jmp 0x50f3
leaq 0x2300(%rip), %rsi      # 0x7351
jmp 0x50f3
leaq 0x22dc(%rip), %rsi      # 0x7339
jmp 0x50f3
leaq 0x22bc(%rip), %rsi      # 0x7325
jmp 0x50f3
leaq 0x22bf(%rip), %rsi      # 0x7334
jmp 0x50f3
leaq 0x22ad(%rip), %rsi      # 0x732b
jmp 0x50f3
leaq 0x2261(%rip), %rsi      # 0x72e8
jmp 0x50f3
leaq 0x226f(%rip), %rsi      # 0x72ff
jmp 0x50f3
leaq 0x225e(%rip), %rsi      # 0x72f7
jmp 0x50f3
leaq 0x2274(%rip), %rsi      # 0x7316
jmp 0x50f3
leaq 0x2243(%rip), %rsi      # 0x72ee
jmp 0x50f3
leaq 0x2256(%rip), %rsi      # 0x730a
jmp 0x50f3
leaq 0x2262(%rip), %rsi      # 0x731f
jmp 0x50f3
leaq 0x227f(%rip), %rsi      # 0x7345
jmp 0x50f3
leaq 0x21e4(%rip), %rsi      # 0x72b3
jmp 0x50f3
leaq 0x21f8(%rip), %rsi      # 0x72d0
jmp 0x50f3
leaq 0x21e1(%rip), %rsi      # 0x72c2
jmp 0x50f3
leaq 0x21c2(%rip), %rsi      # 0x72ac
jmp 0x50f3
leaq 0x21c4(%rip), %rsi      # 0x72b7
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x510a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5cab
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%r14)
cmpl $0x5, %ebx
jne 0x5cec
movl $0xb8, %edi
callq 0x3180
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x31e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x65e2
movq %rbx, 0x8(%r14)
leaq 0x8(%rsp), %rdi
callq 0x30b0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x30b0
jmp 0x5d09
movq %rax, %r14
movl $0xb8, %esi
movq %rbx, %rdi
callq 0x3190
movq %r14, %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5ef7
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rbx)
cmpl $0x5, %ebp
jne 0x5f34
pushq $0x50
popq %rdi
callq 0x3180
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x31e0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x66b0
movq %r14, 0x8(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x30b0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30b0
jmp 0x5f51
movq %rax, %rbx
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %ebp
cmpq $0x0, 0x38(%rdi)
je 0x619e
movq %rdi, %r14
cmpb $0x0, 0x40(%rdi)
jne 0x61da
movb $0x1, 0x40(%r14)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x31e0
movq 0x48(%r14), %rdx
movl %ebp, %edi
movq %r15, %rsi
callq *0x38(%r14)
movb $0x0, 0x40(%r14)
leaq 0x8(%rsp), %rdi
callq 0x30b0
jmp 0x61da
cmpl $0x1, %ebp
je 0x61da
movq 0x5e46(%rip), %rdi      # 0xbff0
pushq $0xa
popq %rsi
testl %ebp, %ebp
jne 0x61e5
callq 0x31a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3160
leaq 0x1588(%rip), %rsi      # 0x7750
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3170
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x31a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3160
leaq 0x1554(%rip), %rsi      # 0x7750
movq %rax, %rdi
callq 0x3170
pushq $0x30
popq %rdi
callq 0x30d0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x6660
leaq 0x5a35(%rip), %rsi      # 0xbc58
leaq 0x466(%rip), %rdx       # 0x6690
movq %r14, %rdi
callq 0x3240
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x6110
leaq 0x58c4(%rip), %rax      # 0xbb28
movq %rax, (%rbx)
leaq 0x50(%rbx), %rdi
callq 0x672c
movl %ebp, 0x5c(%rbx)
testl %ebp, %ebp
je 0x62ba
movl %ebp, %r14d
movq %r14, %rbp
shlq $0x5, %rbp
leaq 0x8(%rbp), %rdi
movq %rdi, (%rsp)
callq 0x3030
movq %rax, %r15
movq %r14, (%rax)
leaq 0x8(%rax), %r14
negq %rbp
xorl %r13d, %r13d
movq %r14, %r12
movq %r12, %rdi
callq 0x6760
addq $-0x20, %r13
addq $0x20, %r12
cmpq %r13, %rbp
jne 0x62a1
movq %r14, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x6300
movq %rax, %r12
jmp 0x6309
movq %rax, %r12
testq %r13, %r13
je 0x62f4
negq %r13
movq %r15, %r14
addq $-0x18, %r14
leaq (%r14,%r13), %rdi
callq 0x52e4
addq $-0x20, %r13
jne 0x62e5
movq %r15, %rdi
movq (%rsp), %rsi
callq 0x32a0
leaq 0x68(%rbx), %rdi
callq 0x52e4
movq %rbx, %rdi
callq 0x65ce
movq %r12, %rdi
callq 0x3260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, 0x98(%rdi)
jne 0x6368
leaq 0x18(%r14), %r15
leaq 0x14d0(%rip), %rsi      # 0x780c
movq %r15, %rdi
callq 0x3290
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31e0
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x614c
leaq 0x20(%rsp), %rdi
jmp 0x63b6
testq %rsi, %rsi
je 0x6385
movq %rsi, 0xa0(%r14)
movq %rdx, 0xa8(%r14)
movb $0x1, 0x98(%r14)
jmp 0x63bb
leaq 0x18(%r14), %r15
leaq 0x14b8(%rip), %rsi      # 0x7848
movq %r15, %rdi
callq 0x3290
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31e0
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x614c
movq %rsp, %rdi
callq 0x30b0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x63c7
movq %rax, %r14
movq %rbx, %rdi
callq 0x30b0
movq %r14, %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x98(%rdi)
je 0x6402
movb $0x0, 0x98(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rbx)
jmp 0x6438
leaq 0x18(%rbx), %r14
leaq 0x1476(%rip), %rsi      # 0x7883
movq %r14, %rdi
callq 0x3290
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x31e0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x614c
movq %rsp, %rdi
callq 0x30b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x648d
movq %rax, 0x8(%rsi)
cmpb $0x1, 0x98(%rbx)
jne 0x64ce
leaq 0x18(%rbx), %r14
leaq 0x141a(%rip), %rsi      # 0x78bb
movq %r14, %rdi
callq 0x3290
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x31e0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x614c
movq %rsp, %rdi
callq 0x30b0
jmp 0x651a
cmpl $0x0, 0x58(%rbx)
je 0x651a
movq 0x60(%rbx), %rcx
movl 0x50(%rbx), %edx
shlq $0x5, %rdx
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %rdx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x6c62
movq 0x60(%rbx), %rax
movl 0x50(%rbx), %ecx
movq %rcx, %rdx
shlq $0x5, %rdx
movsd 0x18(%rax,%rdx), %xmm0
decl 0x58(%rbx)
leal 0x1(%rcx), %eax
xorl %ecx, %ecx
cmpl 0x5c(%rbx), %eax
cmovnel %eax, %ecx
movl %ecx, 0x50(%rbx)
jmp 0x651d
xorps %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/mshalign/mshalign.cpp
// Function: ReadMesh(char const*)
static R3Mesh *
ReadMesh(const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate mesh
  R3Mesh *mesh = new R3Mesh();
  assert(mesh);

  // Read mesh from file
  if (!mesh->ReadFile(filename)) {
    delete mesh;
    return NULL;
  }

  // Check if mesh is valid
  assert(mesh->IsValid());

  // Print statistics
  if (print_verbose) {
    printf("Read mesh from %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 mesh
  return mesh;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4dc92
movq %rbx, %rdi
callq 0x10fda
movl $0x138, %edi            # imm = 0x138
callq 0xc380
movq %rax, %rbx
movq %rax, %rdi
callq 0x1faf8
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x180(%rax)
testl %eax, %eax
je 0xfe84
cmpb $0x1, 0x68cd3(%rip)     # 0x78ae8
jne 0xfe8f
leaq 0x413c0(%rip), %rdi     # 0x511de
movq %r14, %rsi
xorl %eax, %eax
callq 0xc070
leaq 0x8(%rsp), %rdi
callq 0x4dccc
leaq 0x413bc(%rip), %rdi     # 0x511f5
movb $0x1, %al
callq 0xc070
movl 0x34(%rbx), %esi
leaq 0x413c2(%rip), %rdi     # 0x5120c
xorl %eax, %eax
callq 0xc070
movl 0x24(%rbx), %esi
leaq 0x413c1(%rip), %rdi     # 0x5121c
xorl %eax, %eax
callq 0xc070
movl 0x14(%rbx), %esi
leaq 0x413c0(%rip), %rdi     # 0x5122c
xorl %eax, %eax
callq 0xc070
movq 0x6811e(%rip), %rax     # 0x77f98
movq (%rax), %rdi
callq 0xc450
jmp 0xfe8f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x138, %esi            # imm = 0x138
movq %rbx, %rdi
callq 0xc390
movq %r14, %rdi
callq 0xc650
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %rbx
callq 0x2590
leaq 0x20(%rbx), %r14
movq %r14, 0x28(%rbx)
movq %r14, 0x20(%rbx)
andq $0x0, 0x30(%rbx)
leaq 0x38(%rbx), %r15
movq %r15, %rdi
callq 0x2d9e
leaq 0x50(%rbx), %r12
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x2590
leaq 0x8(%rsp), %rbp
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x460e
movq %rbp, %rdi
callq 0x47dc
movq %rbp, 0x8(%rbp)
movq %rbp, (%rbp)
andq $0x0, 0x10(%rbp)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x4b76
movq %rbp, %rdi
callq 0x4a7e
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x2d9e
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4bfa
movq %rbp, %rdi
callq 0x4abe
movq %r12, %rdi
movq %r13, %rsi
callq 0x2120
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2565
movq %rax, %r13
movq %r12, %rdi
callq 0x20e0
movq %r15, %rdi
callq 0x4abe
movq %r14, %rdi
callq 0x4a7e
movq %rbx, %rdi
callq 0x47dc
movq %r13, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x8(%rsp), %r15
movq %rax, %r12
movq 0x8(%r14), %r13
cmpq %r13, %rax
je 0x28ee
movq %r15, %rdi
movq %r12, %rsi
callq 0x2250
movq %r15, %rdi
movq %rbx, %rsi
callq 0x47fd
movl %eax, %ebp
movq %r15, %rdi
callq 0x20e0
leaq 0x28(%r12), %rax
testb %bpl, %bpl
je 0x28b8
cmpq %r13, %r12
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %r15
pushq $-0x1
popq %rbx
leaq 0x8(%rsp), %r13
cmpq 0x8(%r12), %r15
je 0x2967
movq %r13, %rdi
movq %r15, %rsi
callq 0x2250
movq %r13, %rdi
movq %r14, %rsi
callq 0x47fd
movl %eax, %ebp
movq %r13, %rdi
callq 0x20e0
testb %bpl, %bpl
jne 0x2963
addq $0x28, %r15
jmp 0x2931
movl 0x20(%r15), %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %rdi, %r12
movq (%r12), %r12
cmpq %rbx, %r12
je 0x2a40
leaq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x2250
movq %r14, %rdi
movq %r15, %rsi
callq 0x47fd
movl %eax, %ebp
movq %r15, %rdi
callq 0x20e0
testb %bpl, %bpl
je 0x2a10
cmpq %rbx, %r12
setne %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
movq 0x7564(%rip), %rdi      # 0x9fd0
leaq 0x35cb(%rip), %rsi      # 0x603e
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x28(%rsp), %r12
leaq 0x35c9(%rip), %r13      # 0x6055
leaq 0x8(%rsp), %rbp
movq %r15, %rbx
movq (%rbx), %rbx
cmpq %r15, %rbx
je 0x2b08
movq 0x752d(%rip), %rdi      # 0x9fd0
leaq 0x35a3(%rip), %rsi      # 0x604d
callq 0x21e0
movq %rax, %r14
leaq 0x10(%rbx), %rsi
movq %r12, %rdi
callq 0x2250
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
movq %rax, %rdi
movq %r13, %rsi
callq 0x21e0
movq %rax, %r14
leaq 0x30(%rbx), %rsi
movq %rbp, %rdi
callq 0x2250
movq %r14, %rdi
movq %rbp, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
movq %rbp, %rdi
callq 0x20e0
movq %r12, %rdi
callq 0x20e0
jmp 0x2a94
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b28
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
jmp 0x2b2b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x2250
movq %r15, %rdi
movq %r12, %rsi
callq 0x29f8
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x20e0
testb %bpl, %bpl
je 0x2c96
leaq 0x48(%rsp), %r12
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x2c96
leaq 0x10(%r13), %rsi
movq %r12, %rdi
callq 0x2250
movq %r12, %rdi
movq %r14, %rsi
callq 0x47fd
movl %eax, %ebp
movq %r12, %rdi
callq 0x20e0
testb %bpl, %bpl
je 0x2c3c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2250
addq $0x30, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2120
leaq 0x8(%rsp), %rdi
callq 0x20e0
jmp 0x2cb1
movq 0x7333(%rip), %rdi      # 0x9fd0
leaq 0x33bd(%rip), %rsi      # 0x6061
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2cc2
movq %rax, %rbx
movq %r12, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x2250
movq %r15, %rdi
movq %r12, %rsi
callq 0x29f8
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x20e0
testb %bpl, %bpl
je 0x2d62
leaq 0x8(%rsp), %r13
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x2d62
leaq 0x10(%r12), %rsi
movq %r13, %rdi
callq 0x2250
movq %r13, %rdi
movq %r14, %rsi
callq 0x47fd
movl %eax, %ebp
movq %r13, %rdi
callq 0x20e0
testb %bpl, %bpl
je 0x2d21
addq $0x30, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2250
jmp 0x2d76
leaq 0x3312(%rip), %rsi      # 0x607b
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x4630
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22f0
nop