LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compiler::matchToken(char const*)
bool Compiler::matchToken(const char* word) {
  const char* a=in;
  for (; (*a>' ' && *a!='(' && *word); ++a, ++word)
    if (tolower(*a)!=tolower(*word)) return false;
  return !*word && (*a<=' ' || *a=='(');
}

// Assembly:
movq (%rdi), %rcx
movb (%rcx), %al
cmpb $0x21, %al
setl %dil
cmpb $0x28, %al
sete %dl
orb %dl, %dil
jne 0xd0df
movb (%rsi), %dil
testb %dil, %dil
je 0xd0df
incq %rsi
incq %rcx
movq %rsi, %r8
movsbl %al, %eax
leal -0x41(%rax), %edx
leal 0x20(%rax), %r9d
cmpl $0x1a, %edx
cmovael %eax, %r9d
movsbl %dil, %eax
leal -0x41(%rax), %edx
leal 0x20(%rax), %edi
cmpl $0x1a, %edx
cmovael %eax, %edi
cmpl %edi, %r9d
jne 0xd0e4
movq %r8, %rsi
movb (%rcx), %al
cmpb $0x28, %al
sete %dl
cmpb $0x21, %al
jl 0xd0df
cmpb $0x28, %al
je 0xd0df
movb (%rsi), %dil
leaq 0x1(%rsi), %r8
incq %rcx
testb %dil, %dil
jne 0xd098
cmpb $0x0, (%rsi)
je 0xd0e7
xorl %eax, %eax
retq
cmpb $0x21, %al
setl %al
orb %dl, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compiler::syntaxError(char const*, char const*)
void Compiler::syntaxError(const char* msg, const char* expected) {
  Array<char> sbuf(128);  // error message to report
  char* s=&sbuf[0];
  strcat(s, "Config line ");
  for (int i=strlen(s), r=1000000; r; r/=10)  // append line number
    if (line/r) s[i++]='0'+line/r%10;
  strcat(s, " at ");
  for (int i=strlen(s); i<40 && *in>' '; ++i)  // append token found
    s[i]=*in++;
  strcat(s, ": ");
  strncat(s, msg, 40);  // append message
  if (expected) {
    strcat(s, ", expected: ");
    strncat(s, expected, 20);  // append expected token if any
  }
  error(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movl $0x0, 0x10(%r14)
movl $0x80, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x4a2d2
movq (%r14), %r14
movq %r14, %rdi
callq 0x40b0
movabsq $0x6c206769666e6f43, %rcx # imm = 0x6C206769666E6F43
movq %rcx, (%r14,%rax)
movabsq $0x20656e696c2067, %rcx # imm = 0x20656E696C2067
movq %rcx, 0x5(%r14,%rax)
movq %r14, %rdi
callq 0x40b0
movq %rax, %rcx
movl $0xf4240, %esi          # imm = 0xF4240
movl 0x28(%r12), %eax
cltd
idivl %esi
testl %eax, %eax
je 0xd192
movslq %eax, %rdx
imulq $0x66666667, %rdx, %rdx # imm = 0x66666667
movq %rdx, %rdi
shrq $0x3f, %rdi
shrq $0x22, %rdx
addl %edi, %edx
addl %edx, %edx
leal (%rdx,%rdx,4), %edx
subl %edx, %eax
addb $0x30, %al
movslq %ecx, %rdx
incl %ecx
movb %al, (%r14,%rdx)
movslq %esi, %rax
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rax
addl %edx, %eax
addl $0x9, %esi
cmpl $0x13, %esi
movl %eax, %esi
jae 0xd15d
movq %r14, %rdi
callq 0x40b0
movl $0x20746120, (%r14,%rax) # imm = 0x20746120
movb $0x0, 0x4(%r14,%rax)
movq %r14, %rdi
callq 0x40b0
cmpl $0x27, %eax
jg 0xd201
cltq
incq %rax
movq (%r12), %rcx
cmpb $0x20, (%rcx)
jle 0xd201
leaq 0x1(%rcx), %rdx
movq %rdx, (%r12)
movb (%rcx), %cl
movb %cl, -0x1(%r14,%rax)
movq %rax, %rcx
incq %rcx
cmpl $0x28, %eax
movq %rcx, %rax
jne 0xd1db
movq %r14, %rdi
callq 0x40b0
movw $0x203a, (%r14,%rax)    # imm = 0x203A
movb $0x0, 0x2(%r14,%rax)
movl $0x28, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4110
testq %rbx, %rbx
je 0xd260
movq %r14, %rdi
callq 0x40b0
movabsq $0x746365707865202c, %rcx # imm = 0x746365707865202C
movq %rcx, (%r14,%rax)
movabsq $0x203a6465746365, %rcx # imm = 0x203A6465746365
movq %rcx, 0x5(%r14,%rax)
movl $0x14, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4110
movq %r14, %rdi
callq 0x455c
movq %rsp, %rdi
callq 0x4a034
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4a034
movq %rbx, %rdi
callq 0x4310
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compiler::rtoken(char const**)
int Compiler::rtoken(const char* list[]) {
  assert(in);
  assert(list);
  next();
  for (int i=0; list[i]; ++i)
    if (matchToken(list[i]))
      return i;
  syntaxError("unexpected");
  assert(0);
  return -1; // not reached
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xcfe2
movq (%r14), %rsi
testq %rsi, %rsi
sete %bpl
je 0xd2e2
movq %rbx, %rdi
callq 0xd072
xorl %r15d, %r15d
testb %al, %al
jne 0xd2dd
xorl %r15d, %r15d
movq 0x8(%r14,%r15,8), %rsi
testq %rsi, %rsi
sete %bpl
je 0xd2e2
movq %rbx, %rdi
callq 0xd072
incq %r15
testb %al, %al
je 0xd2c0
testb %bpl, %bpl
je 0xd2f9
leaq 0x42230(%rip), %rsi     # 0x4f519
movq %rbx, %rdi
xorl %edx, %edx
callq 0xd0f0
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compiler::rtoken(int, int)
int Compiler::rtoken(int low, int high) {
  next();
  int r=0;
  if (in[0]=='$' && in[1]>='1' && in[1]<='9') {
    if (in[2]=='+') r=atoi(in+3);
    if (args) r+=args[in[1]-'1'];
  }
  else if (in[0]=='-' || (in[0]>='0' && in[0]<='9')) r=atoi(in);
  else syntaxError("expected a number");
  if (r<low) syntaxError("number too low");
  if (r>high) syntaxError("number too high");
  return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0xcfe2
movq (%rbx), %rdi
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0xd3ab
cmpl $0x24, %eax
jne 0xd3a4
movzbl 0x1(%rdi), %r12d
leal -0x31(%r12), %ecx
cmpb $0x8, %cl
ja 0xd3b5
xorl %r15d, %r15d
cmpb $0x2b, 0x2(%rdi)
jne 0xd391
addq $0x3, %rdi
callq 0x42a0
movl %eax, %r15d
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xd3da
addl -0xc4(%rax,%r12,4), %r15d
jmp 0xd3da
addl $-0x30, %eax
cmpb $0x9, %al
ja 0xd3c6
callq 0x42a0
movl %eax, %r15d
jmp 0xd3da
cmpb $0x2d, %al
sete %cl
addl $-0x30, %eax
cmpb $0xa, %al
setb %al
orb %cl, %al
jne 0xd3ab
leaq 0x42157(%rip), %rsi     # 0x4f524
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0xd0f0
cmpl %r14d, %r15d
jge 0xd3f0
leaq 0x42150(%rip), %rsi     # 0x4f536
movq %rbx, %rdi
xorl %edx, %edx
callq 0xd0f0
cmpl %ebp, %r15d
jle 0xd406
leaq 0x42149(%rip), %rsi     # 0x4f545
movq %rbx, %rdi
xorl %edx, %edx
callq 0xd0f0
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compressor::writeTag()
void Compressor::writeTag() {
  assert(state==INIT);
  enc.out->put(0x37);
  enc.out->put(0x6b);
  enc.out->put(0x53);
  enc.out->put(0x74);
  enc.out->put(0xa0);
  enc.out->put(0x31);
  enc.out->put(0x83);
  enc.out->put(0xd3);
  enc.out->put(0x8c);
  enc.out->put(0xb2);
  enc.out->put(0x28);
  enc.out->put(0xb0);
  enc.out->put(0xd3);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x180(%rdi), %rdi
movq (%rdi), %rax
movl $0x37, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x6b, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x53, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x74, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0xa0, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x31, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x83, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0xd3, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x8c, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0xb2, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x28, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0xb0, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movl $0xd3, %esi
popq %rbx
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compressor::startBlock(char const*)
void Compressor::startBlock(const char* hcomp) {
  assert(state==INIT);
  MemoryReader m(hcomp);
  z.read(&m);
  pz.sha1=&sha1;
  assert(z.header.isize()>6);
  enc.out->put('z');
  enc.out->put('P');
  enc.out->put('Q');
  enc.out->put(1+(z.header[6]==0));  // level 1 or 2
  enc.out->put(1);
  z.write(enc.out, false);
  state=BLOCK1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x48e37(%rip), %rcx     # 0x56cb8
movq %rsp, %rax
movq %rcx, (%rax)
movq %rsi, 0x8(%rax)
movq %rax, %rsi
callq 0x9904
leaq 0x1b1d8(%rbx), %rax
movq %rax, 0xc8(%rbx)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x7a, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x50, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x51, %esi
callq *(%rax)
movq 0x10(%rbx), %rax
xorl %esi, %esi
cmpb $0x1, 0x6(%rax)
movq 0x180(%rbx), %rdi
adcl $0x1, %esi
movq (%rdi), %rax
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *(%rax)
movq 0x180(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x985a
movl $0x1, 0x1b25c(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compressor::startBlock(char const*, int*, libzpaq::Writer*)
void Compressor::startBlock(const char* config, int* args, Writer* pcomp_cmd) {
  assert(state==INIT);
  Compiler(config, args, z, pz, pcomp_cmd);
  pz.sha1=&sha1;
  assert(z.header.isize()>6);
  enc.out->put('z');
  enc.out->put('P');
  enc.out->put('Q');
  enc.out->put(1+(z.header[6]==0));  // level 1 or 2
  enc.out->put(1);
  z.write(enc.out, false);
  state=BLOCK1;
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rcx, %r9
movq %rdi, %rbx
leaq 0xc0(%rdi), %r8
movq %rsp, %rdi
movq %rbx, %rcx
callq 0xd97e
leaq 0x50(%rsp), %rdi
callq 0x4a99c
leaq 0x30(%rsp), %rdi
callq 0x4a99c
leaq 0x1b1d8(%rbx), %rax
movq %rax, 0xc8(%rbx)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x7a, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x50, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x51, %esi
callq *(%rax)
movq 0x10(%rbx), %rax
xorl %esi, %esi
cmpb $0x1, 0x6(%rax)
movq 0x180(%rbx), %rdi
adcl $0x1, %esi
movq (%rdi), %rax
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *(%rax)
movq 0x180(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x985a
movl $0x1, 0x1b25c(%rbx)
addq $0x70, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compressor::startSegment(char const*, char const*)
void Compressor::startSegment(const char* filename, const char* comment) {
  assert(state==BLOCK1 || state==BLOCK2);
  enc.out->put(1);
  while (filename && *filename)
    enc.out->put(*filename++);
  enc.out->put(0);
  while (comment && *comment)
    enc.out->put(*comment++);
  enc.out->put(0);
  enc.out->put(0);
  if (state==BLOCK1) state=SEG1;
  if (state==BLOCK2) state=SEG2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x180(%rdi), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *(%rax)
testq %r15, %r15
je 0xe025
movb (%r15), %al
testb %al, %al
je 0xe025
incq %r15
movq 0x180(%rbx), %rdi
movsbl %al, %esi
movq (%rdi), %rax
callq *(%rax)
movb (%r15), %al
incq %r15
testb %al, %al
jne 0xe00c
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
testq %r14, %r14
je 0xe05b
movb (%r14), %al
testb %al, %al
je 0xe05b
incq %r14
movq 0x180(%rbx), %rdi
movsbl %al, %esi
movq (%rdi), %rax
callq *(%rax)
movb (%r14), %al
incq %r14
testb %al, %al
jne 0xe042
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
cmpl $0x1, 0x1b25c(%rbx)
jne 0xe08a
movl $0x2, 0x1b25c(%rbx)
cmpl $0x3, 0x1b25c(%rbx)
jne 0xe09d
movl $0x4, 0x1b25c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compressor::postProcess(char const*, int)
void Compressor::postProcess(const char* pcomp, int len) {
  if (state==SEG2) return;
  assert(state==SEG1);
  enc.init();
  if (!pcomp) {
    len=pz.hend-pz.hbegin;
    if (len>0) {
      assert(pz.header.isize()>pz.hend);
      assert(pz.hbegin>=0);
      pcomp=(const char*)&pz.header[pz.hbegin];
    }
    assert(len>=0);
  }
  else if (len==0) {
    len=toU16(pcomp);
    pcomp+=2;
  }
  if (len>0) {
    enc.compress(1);
    enc.compress(len&255);
    enc.compress((len>>8)&255);
    for (int i=0; i<len; ++i)
      enc.compress(pcomp[i]&255);
    if (verify)
      pz.initp();
  }
  else
    enc.compress(0);
  state=SEG2;
}

// Assembly:
cmpl $0x4, 0x1b25c(%rdi)
je 0xe19b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x180(%rdi), %r15
movq %r15, %rdi
callq 0xce1c
testq %r14, %r14
je 0xe0e6
testl %ebp, %ebp
jne 0xe104
movzwl (%r14), %ebp
addq $0x2, %r14
jmp 0xe104
movl 0xf0(%rbx), %ebp
movslq 0xec(%rbx), %r14
subl %r14d, %ebp
jle 0xe101
addq 0xd0(%rbx), %r14
jmp 0xe104
xorl %r14d, %r14d
testl %ebp, %ebp
jle 0xe179
movq %r15, %rdi
movl $0x1, %esi
callq 0xced2
movl $0xff, %r12d
movl %ebp, %esi
andl %r12d, %esi
movq %r15, %rdi
callq 0xced2
movl %ebp, %esi
shrl $0x8, %esi
andl %r12d, %esi
movq %r15, %rdi
callq 0xced2
movl %ebp, %r12d
xorl %r13d, %r13d
movzbl (%r14,%r13), %esi
movq %r15, %rdi
callq 0xced2
incq %r13
cmpq %r13, %r12
jne 0xe13e
cmpb $0x0, 0x1b260(%rbx)
je 0xe183
leaq 0xc0(%rbx), %rdi
movq 0xd0(%rbx), %rax
movzbl 0x4(%rax), %esi
movzbl 0x5(%rax), %edx
callq 0x9dc8
jmp 0xe183
movq %r15, %rdi
xorl %esi, %esi
callq 0xced2
movl $0x4, 0x1b25c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compressor::compress(int)
bool Compressor::compress(int n) {
  if (state==SEG1)
    postProcess();
  assert(state==SEG2);

  const int BUFSIZE=1<<14;
  char buf[BUFSIZE];  // input buffer
  while (n) {
    int nbuf=BUFSIZE;  // bytes read into buf
    if (n>=0 && n<nbuf) nbuf=n;
    int nr=in->read(buf, nbuf);
    if (nr<0 || nr>BUFSIZE || nr>nbuf) error("invalid read size");
    if (nr<=0) return false;
    if (n>=0) n-=nr;
    for (int i=0; i<nr; ++i) {
      int ch=U8(buf[i]);
      enc.compress(ch);
      if (verify) {
        if (pz.hend) pz.run(ch);
        else sha1.put(ch);
      }
    }
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4028, %rsp           # imm = 0x4028
movl %esi, %r13d
movq %rdi, %rbx
cmpl $0x2, 0x1b25c(%rdi)
jne 0xe1c8
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe0a4
leaq 0x180(%rbx), %r14
leaq 0xc0(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x1b1d8(%rbx), %rax
movq %rax, 0x10(%rsp)
movl %r13d, %r12d
testl %r13d, %r13d
je 0xe2b6
movl $0x4000, %eax           # imm = 0x4000
cmpl %eax, %r12d
movl $0x4000, %r13d          # imm = 0x4000
cmovbl %r12d, %r13d
movq 0x1b1d0(%rbx), %rdi
movq (%rdi), %rax
leaq 0x20(%rsp), %rsi
movl %r13d, %edx
callq *0x8(%rax)
movl %eax, %ebp
cmpl $0x4001, %eax           # imm = 0x4001
setb %al
cmpl %r13d, %ebp
setle %cl
testb %cl, %al
jne 0xe23a
leaq 0x41407(%rip), %rdi     # 0x4f63c
callq 0x455c
movl %r12d, %r13d
testl %ebp, %ebp
jle 0xe2ae
testl %r12d, %r12d
movl %ebp, %ecx
movl $0x0, %eax
cmovsl %eax, %ecx
movl %ecx, 0x8(%rsp)
movl %ebp, 0xc(%rsp)
movl %ebp, %r15d
xorl %ebp, %ebp
movzbl 0x20(%rsp,%rbp), %r13d
movq %r14, %rdi
movl %r13d, %esi
callq 0xced2
cmpb $0x1, 0x1b260(%rbx)
jne 0xe29a
cmpl $0x0, 0xf0(%rbx)
je 0xe28d
movq 0x18(%rsp), %rdi
movl %r13d, %esi
callq 0xc1f6
jmp 0xe29a
movq 0x10(%rsp), %rdi
movl %r13d, %esi
callq 0x49fd2
incq %rbp
cmpq %rbp, %r15
jne 0xe25b
movl %r12d, %r13d
subl 0x8(%rsp), %r13d
movl 0xc(%rsp), %ebp
testl %ebp, %ebp
jg 0xe1e7
testl %r12d, %r12d
sete %al
addq $0x4028, %rsp           # imm = 0x4028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe2f1
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe0a4
leaq 0x180(%rbx), %r15
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xced2
cmpb $0x1, 0x1b260(%rbx)
jne 0xe333
cmpl $0x0, 0xf0(%rbx)
je 0xe333
leaq 0xc0(%rbx), %r12
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xc1f6
movq %r12, %rdi
callq 0x9e54
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 0xe38b
movl $0xfd, %esi
callq *%rax
xorl %r12d, %r12d
movq (%r15), %rdi
movsbl (%r14,%r12), %esi
movq (%rdi), %rax
callq *(%rax)
incq %r12
cmpq $0x14, %r12
jne 0xe373
jmp 0xe392
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_O1/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 %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, 0x1b25c(%rdi)
jne 0xe3cc
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe0a4
leaq 0x180(%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xced2
cmpb $0x1, 0x1b260(%rbx)
jne 0xe40b
cmpl $0x0, 0xf0(%rbx)
je 0xe40b
leaq 0xc0(%rbx), %r15
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xc1f6
movq %r15, %rdi
callq 0x9e54
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)
cmpb $0x1, 0x1b260(%rbx)
jne 0xe47e
testq %r14, %r14
je 0xe45f
movq 0x1b1d8(%rbx), %rax
shrq $0x3, %rax
movq %rax, (%r14)
leaq 0x1b1d8(%rbx), %rdi
callq 0x5010
movups (%rax), %xmm0
movups %xmm0, 0x1b248(%rbx)
movl 0x10(%rax), %eax
movl %eax, 0x1b258(%rbx)
andb 0x1b260(%rbx), %bpl
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movq (%rax), %rax
cmpb $0x1, %bpl
jne 0xe4c2
movl $0xfd, %esi
callq *%rax
xorl %r14d, %r14d
movq 0x180(%rbx), %rdi
movsbl 0x1b248(%rbx,%r14), %esi
movq (%rdi), %rax
callq *(%rax)
incq %r14
cmpq $0x14, %r14
jne 0xe4a2
jmp 0xe4c9
movl $0xfe, %esi
callq *%rax
movl $0x3, 0x1b25c(%rbx)
xorl %eax, %eax
cmpb $0x0, 0x1b260(%rbx)
leaq 0x1b248(%rbx), %rcx
cmovneq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, 0x50(%rsp)
movq %rdi, %r15
movl $0x4, %ecx
testq %rdx, %rdx
je 0xe56c
cmpb $0x0, (%rbx)
je 0xe56c
movb 0x1(%rbx), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0xe56c
movzbl %al, %eax
movsbl 0x2(%rbx), %ecx
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
leal (%rax,%rax,4), %edx
leal -0x30(%rcx,%rdx,2), %edx
cmovael %eax, %edx
cmpl $0xb, %edx
movl $0xb, %ecx
cmovll %edx, %ecx
movl $0x100000, %eax         # imm = 0x100000
shll %cl, %eax
leal -0x1000(%rax), %ebp
leaq 0x48780(%rip), %rcx     # 0x56d00
movq %rcx, 0x10(%rsp)
leaq 0x487b4(%rip), %rcx     # 0x56d40
movq %rcx, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x30(%rsp)
movq $-0x1, 0x40(%rsp)
movslq %ebp, %rcx
movq %rcx, 0x48(%rsp)
cmpl $0x1001, %eax           # imm = 0x1001
jl 0xe5d5
movl %r9d, 0xc(%rsp)
movl %ebp, %r14d
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x4ab3e
addq %r14, 0x30(%rsp)
movl 0xc(%rsp), %r9d
testq %r15, %r15
je 0xe64b
movzbl %r9b, %r14d
movq 0x20(%rsp), %rsi
movq (%r15), %rax
movq %r15, %rdi
movl %ebp, %edx
callq *0x8(%rax)
testl %eax, %eax
jle 0xe64b
movl %eax, %eax
movq %rax, 0x30(%rsp)
cmpq %rax, 0x38(%rsp)
jbe 0xe605
movq %rax, 0x38(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
movq %r12, %r8
movl %r14d, %r9d
callq 0xe6b5
movq $0x0, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0xe63a
movq $0x0, 0x38(%rsp)
movl $0x0, %r13d
movl $0x0, %r12d
testq %r15, %r15
jne 0xe5de
leaq 0x486ae(%rip), %rax     # 0x56d00
movq %rax, 0x10(%rsp)
leaq 0x486e2(%rip), %rax     # 0x56d40
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xe672
callq 0x4200
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe683
movq %rax, %rbx
leaq 0x48673(%rip), %rax     # 0x56d00
movq %rax, 0x10(%rsp)
leaq 0x486a7(%rip), %rax     # 0x56d40
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xe6ad
callq 0x4200
movq %rbx, %rdi
callq 0x4310
// File: /workspace/github_cpp_makefile_star2_O1/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, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testq %rsi, %rsi
sete %al
testl %edx, %edx
setle %cl
testb %cl, %al
jne 0x3f855
movl %edx, %r14d
movq %rsi, %r15
leaq 0x38(%rsp), %r13
leaq 0x8(%rsp), %r12
movq %r15, %rax
movabsq $0x6666666666666667, %rcx # imm = 0x6666666666666667
imulq %rcx
movq %rdx, %rbp
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rbp
addq %rax, %rbp
leal (,%rbp,2), %eax
leal (%rax,%rax,4), %eax
movl %r15d, %ecx
subl %eax, %ecx
addb $0x30, %cl
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movsbl %cl, %edx
movl $0x1, %esi
movq %r12, %rdi
callq 0x41d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r12, %rdi
callq 0x4080
movq %r13, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3f7d1
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x3f7d9
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
callq 0x4220
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x3f815
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4180
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3f831
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4180
addq $-0xa, %r15
cmpq $-0x13, %r15
setb %al
cmpl $0x2, %r14d
leal -0x1(%r14), %ecx
setge %dl
orb %al, %dl
movl %ecx, %r14d
movq %rbp, %r15
jne 0x3f752
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3f88b
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3f88b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4180
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x3f8a3
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4180
movq %r14, %rdi
callq 0x4310
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x5, %esi
jl 0x3f8fe
addl $-0x5, %esi
movb (%rdi,%rsi), %al
andb $-0x2, %al
cmpb $-0x18, %al
jne 0x3f8f2
movb 0x4(%rdi,%rsi), %al
incb %al
cmpb $0x1, %al
ja 0x3f8f2
movzbl 0x1(%rdi,%rsi), %ecx
movzbl 0x2(%rdi,%rsi), %edx
shll $0x8, %edx
movzbl 0x3(%rdi,%rsi), %eax
shll $0x10, %eax
orl %edx, %eax
orl %ecx, %eax
addl %esi, %eax
addl %esi, %ecx
movb %cl, 0x1(%rdi,%rsi)
movb %ah, 0x2(%rdi,%rsi)
shrl $0x10, %eax
movb %al, 0x3(%rdi,%rsi)
leaq -0x1(%rsi), %rax
testq %rsi, %rsi
movq %rax, %rsi
jg 0x3f8b3
retq
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::lg(unsigned int)
int lg(unsigned x) {
  unsigned r=0;
  if (x>=65536) r=16, x>>=16;
  if (x>=256) r+=8, x>>=8;
  if (x>=16) r+=4, x>>=4;
  assert(x>=0 && x<16);
  return
    "\x00\x01\x02\x02\x03\x03\x03\x03\x04\x04\x04\x04\x04\x04\x04\x04"[x]+r;
}

// Assembly:
movl %edi, %eax
shrl $0x10, %eax
xorl %ecx, %ecx
cmpl $0x10000, %edi          # imm = 0x10000
setae %cl
cmovbl %edi, %eax
shll $0x4, %ecx
leal 0x8(%rcx), %edx
movl %eax, %esi
shrl $0x8, %esi
cmpl $0x100, %eax            # imm = 0x100
cmovbl %eax, %esi
cmovbl %ecx, %edx
leal 0x4(%rdx), %ecx
movl %esi, %eax
shrl $0x4, %eax
cmpl $0x10, %esi
cmovbl %esi, %eax
cmovbl %edx, %ecx
leaq 0xebfb(%rip), %rdx      # 0x4e53b
movsbl (%rax,%rdx), %eax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl 0x78(%rdi), %eax
jne 0x3f980
movq %rbx, %rdi
callq 0x3f9cc
movl 0x74(%rbx), %eax
movl 0x78(%rbx), %ebp
subl %eax, %ebp
cmpl %r15d, %ebp
cmovgel %r15d, %ebp
testl %ebp, %ebp
je 0x3f9a9
leaq (%rbx,%rax), %rsi
addq $0x90, %rsi
movslq %ebp, %rdx
movq %r14, %rdi
callq 0x4140
movl 0x74(%rbx), %eax
addl %ebp, %eax
movl %eax, 0x74(%rbx)
cmpl 0x78(%rbx), %eax
jne 0x3f9be
movq $0x0, 0x74(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
cmpl $0x1, 0x2c(%rdi)
movl (%rdx), %eax
jne 0x40892
testl %eax, %eax
je 0x40906
movl %eax, %ecx
shrl $0x10, %ecx
xorl %edx, %edx
cmpl $0x10000, %eax          # imm = 0x10000
setae %dl
cmovbl %eax, %ecx
shll $0x4, %edx
movl %ecx, %eax
shrl $0x8, %eax
cmpl $0x100, %ecx            # imm = 0x100
cmovbl %ecx, %eax
leal 0x8(%rdx), %ecx
cmovbl %edx, %ecx
movl %eax, %edx
shrl $0x4, %edx
cmpl $0x10, %eax
cmovbl %eax, %edx
leal 0x4(%rcx), %r12d
cmovbl %ecx, %r12d
leaq 0xdd8d(%rip), %rax      # 0x4e53b
movsbl (%rdx,%rax), %eax
movl 0x70(%r15), %ecx
addl $0x2, %ecx
cmpl $0x8, %ecx
jb 0x407e5
movl 0x6c(%r15), %edx
movl 0x78(%r15), %esi
movl %esi, %edi
incl %esi
movb %dl, 0x90(%r15,%rdi)
shrl $0x8, %edx
addl $-0x8, %ecx
cmpl $0x7, %ecx
ja 0x407c6
movl %esi, 0x78(%r15)
movl %edx, 0x6c(%r15)
movl %ecx, 0x70(%r15)
leal (%r12,%rax), %ecx
decl %ecx
testl %ecx, %ecx
jle 0x40831
addl %eax, %r12d
movq %r15, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x4a6ba
movl (%rbx), %eax
leal -0x2(%r12), %ecx
movzbl %cl, %ecx
xorl %esi, %esi
btl %ecx, %eax
setb %sil
movq %r15, %rdi
movl $0x1, %edx
callq 0x4a6ba
decl %r12d
cmpl $0x1, %r12d
jg 0x407f6
movl 0x70(%r15), %eax
incl %eax
cmpl $0x8, %eax
jb 0x40863
movl 0x6c(%r15), %ecx
movl 0x78(%r15), %edx
movl %edx, %esi
incl %edx
movb %cl, 0x90(%r15,%rsi)
shrl $0x8, %ecx
addl $-0x8, %eax
cmpl $0x7, %eax
ja 0x40844
movl %edx, 0x78(%r15)
movl %ecx, 0x6c(%r15)
movl %eax, 0x70(%r15)
movl (%rbx), %eax
testl %eax, %eax
je 0x40906
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 $0x8, %edx
callq 0x4a6ba
jmp 0x40867
testl %eax, %eax
je 0x40906
movq 0x20(%r15), %rcx
movl $0x40, %edx
cmpl $0x40, %eax
cmovael %edx, %eax
leal -0x1(%rax), %esi
movl 0x78(%r15), %edi
leal 0x1(%rdi), %r8d
movl %r8d, 0x78(%r15)
movb %sil, 0x90(%r15,%rdi)
movl (%rbx), %edi
movl %r14d, %r8d
subl %edi, %r8d
leal (%rax,%r14), %esi
movl %esi, %r9d
subl %edi, %r9d
cmpl %r9d, %r8d
jae 0x408fe
movl %r8d, %r8d
movb (%rcx,%r8), %dil
movl 0x78(%r15), %r9d
leal 0x1(%r9), %r10d
movl %r10d, 0x78(%r15)
movb %dil, 0x90(%r15,%r9)
incq %r8
movl (%rbx), %edi
movl %esi, %r9d
subl %edi, %r9d
cmpq %r9, %r8
jb 0x408d6
subl %eax, %edi
movl %edi, (%rbx)
movl %edi, %eax
jne 0x4089f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
testl $0x1ff, %eax            # imm = 0x1FF
je 0x51c4
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
jne 0x4a027
incl 0x4(%rdi)
testl $0x1ff, %eax            # imm = 0x1FF
je 0x645a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
jle 0x4a07b
movl %edx, %ebp
incl %ebp
leaq 0x7d65(%rip), %r15      # 0x51dc9
testq %r14, %r14
jns 0x4a071
movq %r15, %rdi
callq 0x455c
addq %r14, %r14
decl %ebp
cmpl $0x1, %ebp
jg 0x4a064
cmpq $0x0, 0x8(%rbx)
je 0x4a091
movq (%rbx), %rdi
movslq 0x10(%rbx), %rax
subq %rax, %rdi
callq 0x4200
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
testq %r14, %r14
je 0x4a11b
movq %r14, 0x8(%rbx)
leaq 0x80(,%r14,4), %r15
cmpq $0x81, %r15
setae %al
shrq $0x3e, %r14
sete %cl
testb %cl, %al
jne 0x4a0da
movq $0x0, 0x8(%rbx)
leaq 0x7cf4(%rip), %rdi      # 0x51dc9
callq 0x455c
movl $0x1, %esi
movq %r15, %rdi
callq 0x4100
movq %rax, (%rbx)
testq %rax, %rax
jne 0x4a103
movq $0x0, 0x8(%rbx)
leaq 0x55af(%rip), %rdi      # 0x4f6ad
callq 0x455c
movq (%rbx), %rax
movl %eax, %ecx
andl $0x3f, %ecx
movl $0x40, %edx
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
// File: /workspace/github_cpp_makefile_star2_O1/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), %eax
cmpl 0x20(%rdi), %eax
jne 0x4a509
movl $0x0, 0x1c(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4a504
movq 0x1b050(%rbx), %rsi
movq (%rdi), %rax
movl $0x10000, %edx          # imm = 0x10000
callq *0x8(%rax)
jmp 0x4a506
xorl %eax, %eax
movl %eax, 0x20(%rbx)
movl 0x1c(%rbx), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x20(%rbx), %ecx
jae 0x4a527
leal 0x1(%rcx), %eax
movl %eax, 0x1c(%rbx)
movq 0x1b050(%rbx), %rax
movzbl (%rax,%rcx), %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a627
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %r15d
movq %r15, %rsi
callq 0x4ab3e
testq %r14, %r14
je 0x4a61e
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_O1/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:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %edx, %ecx
shll %cl, %eax
notl %eax
andl %esi, %eax
movl 0x70(%rdi), %ecx
shll %cl, %eax
orl %eax, 0x6c(%rdi)
addl %edx, %ecx
cmpl $0x8, %ecx
jb 0x4a6f8
movl 0x6c(%rdi), %eax
movl 0x78(%rdi), %edx
movl %edx, %esi
incl %edx
movb %al, 0x90(%rdi,%rsi)
shrl $0x8, %eax
addl $-0x8, %ecx
cmpl $0x7, %ecx
ja 0x4a6dc
movl %edx, 0x78(%rdi)
movl %eax, 0x6c(%rdi)
movl %ecx, 0x70(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %eax
cmpl 0x78(%rdi), %eax
jne 0x4a8f0
movq %rbx, %rdi
callq 0x3f9cc
movl 0x74(%rbx), %edx
movl 0x78(%rbx), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %edx
jae 0x4a90d
leal 0x1(%rdx), %eax
movl %eax, 0x74(%rbx)
movzbl 0x90(%rbx,%rdx), %eax
cmpl %ecx, 0x74(%rbx)
jne 0x4a91a
movq $0x0, 0x74(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %rax
movslq %edx, %r14
leaq (%rax,%r14), %rdx
movl %ecx, %edi
subl %eax, %edi
cmpq %rcx, %rdx
cmoval %edi, %r14d
testq %rsi, %rsi
je 0x4aa27
testl %r14d, %r14d
jle 0x4aa27
addq 0x10(%rbx), %rax
movl %r14d, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4140
movslq %r14d, %rax
addq %rax, 0x28(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
addq %rsi, %rax
setae %cl
cmpq 0x30(%rdi), %rax
setbe %al
testb %cl, %al
jne 0x4ab69
leaq 0x724f(%rip), %rdi      # 0x51db3
callq 0x455c
addq 0x20(%rbx), %r14
movq 0x18(%rbx), %rsi
cmpq %rsi, %r14
jbe 0x4ab92
movq 0x38(%rbx), %rax
leaq (%rax,%rsi,2), %rsi
cmpq %rsi, %r14
jae 0x4ab7a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4ab9a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4abe7
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x4abbe
movq %rbx, %rsi
callq 0x42e0
jmp 0x4abc6
movq %rbx, %rdi
callq 0x4230
movq %rax, %r15
testq %rax, %rax
jne 0x4abda
leaq 0x4ad8(%rip), %rdi      # 0x4f6ad
callq 0x455c
movq %r15, 0x10(%r14)
movq %rbx, 0x18(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x30, %rsp
cmpl $0x1, %edi
jle 0x144a
movq 0x8(%rsi), %rdi
leaq 0x1c7f(%rip), %rsi      # 0x300e
callq 0x1110
testq %rax, %rax
je 0x1452
movq %rax, %rbx
xorps %xmm0, %xmm0
leaq -0x48(%rbp), %r15
movups %xmm0, 0x10(%r15)
movq $0x0, 0x20(%r15)
leaq 0x3d55(%rip), %r14      # 0x5110
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
xorl %esi, %esi
callq 0x1090
movl $0xff, %r12d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1480
testb %al, %al
je 0x13f5
cmpb $0x1, -0x44(%rbp)
jne 0x13d0
movl -0x48(%rbp), %eax
cmpl %r12d, %eax
cmovael %r12d, %eax
incq (%r14,%rax,8)
jmp 0x13d0
leaq 0x1c1f(%rip), %rdi      # 0x301b
callq 0x1150
leaq 0x1c09(%rip), %r15      # 0x3011
xorl %r12d, %r12d
movq (%r14), %rdx
testq %rdx, %rdx
je 0x1420
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1040
incq %r12
addq $0x8, %r14
cmpq $0x100, %r12            # imm = 0x100
jne 0x140b
movq %rbx, %rdi
callq 0x10e0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1446
callq 0x10d0
xorl %eax, %eax
jmp 0x1457
movq %rsi, %rdi
callq 0x11d0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1475
callq 0x10d0
movq %rbx, %rdi
callq 0x1180
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/danomatika[P]miditester/src/main.cpp
// Function: realtimeMessages(std::vector<TestSet, std::allocator<TestSet>>&, int)
void realtimeMessages(TestQueue &queue, int channel) {
    TestSet set;
    set.name = "realtime";
    set.messages = {
        {MIDI_CLOCK},
        {MIDI_START},
        {MIDI_CONTINUE},
        {MIDI_STOP},
        {MIDI_ACTIVESENSING},
        {MIDI_SYSTEMRESET}
    };
    queue.push_back(set);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r15
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
xorl %eax, %eax
movq %rax, -0x8(%rbp)
movb $0x0, (%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbp)
movq %rax, 0x20(%rbp)
leaq 0x2f71(%rip), %rcx      # 0x826a
leaq 0x10(%rsp), %rdi
movl $0x8, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3210
leaq 0xf(%rsp), %rsi
movb $-0x8, (%rsi)
leaq 0x48(%rsp), %r14
leaq 0xe(%rsp), %rcx
movl $0x1, %edx
movq %r14, %rdi
callq 0x5e6e
leaq 0x60(%rsp), %rbx
leaq 0xd(%rsp), %rsi
movb $-0x6, (%rsi)
leaq 0xc(%rsp), %rcx
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5e6e
leaq 0x78(%rsp), %rbx
leaq 0xb(%rsp), %rsi
movb $-0x5, (%rsi)
leaq 0xa(%rsp), %rcx
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5e6e
leaq 0x90(%rsp), %rbx
leaq 0x9(%rsp), %rsi
movb $-0x4, (%rsi)
leaq 0x8(%rsp), %rcx
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5e6e
leaq 0xa8(%rsp), %rbx
leaq 0x7(%rsp), %rsi
movb $-0x2, (%rsi)
leaq 0x6(%rsp), %rcx
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5e6e
leaq 0xc0(%rsp), %rbx
leaq 0x5(%rsp), %rsi
movb $-0x1, (%rsi)
leaq 0x4(%rsp), %rcx
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5e6e
leaq 0x30(%rsp), %r12
leaq 0xd8(%rsp), %r13
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x60c8
movl $0x90, %ebx
movq 0x30(%rsp,%rbx), %rdi
testq %rdi, %rdi
je 0x5409
movq 0x40(%rsp,%rbx), %rsi
subq %rdi, %rsi
callq 0x31a0
addq $-0x18, %rbx
jne 0x53f2
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x5eb2
movq %r12, %rdi
callq 0x5f0e
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x543b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x31a0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x48(%rsp), %rsi
movq %r13, %rdi
callq 0x3330
movb $0x1, %al
jmp 0x546e
jmp 0x5469
jmp 0x5469
jmp 0x5469
jmp 0x5469
movq %rax, %r15
xorl %eax, %eax
cmpq %rbx, %r14
je 0x54a9
testb %al, %al
jne 0x54a9
leaq 0x48(%rsp), %r14
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5491
movq -0x8(%rbx), %rsi
subq %rdi, %rsi
callq 0x31a0
addq $-0x18, %rbx
cmpq %r14, %rbx
jne 0x547c
jmp 0x54a9
movq %rax, %r15
xorl %eax, %eax
movq %r14, %rbx
jmp 0x546e
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x5edc
movq %r15, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/danomatika[P]miditester/src/main.cpp
// Function: sysex(std::vector<TestSet, std::allocator<TestSet>>&, int)
void sysex(TestQueue &queue, int channel) {
    TestSet set;
    set.name = "sysex";
    set.messages = {

        // test realtime messages within sysex
        {MIDI_SYSEX, 1, 2, MIDI_STOP, 3, 4, MIDI_CLOCK, 5, 6, MIDI_SYSEXEND},

        // test sysex without sysex end byte
        // not all of these bytes may go through as MIDI
        // backends handle this in different ways
        //{MIDI_SYSEX, 7, 8, 9, 10, 11, 12, 13, 14},

        // next status message should work fine
        {(unsigned char)(MIDI_NOTEON + channel), 64, 64}
    };
    queue.push_back(set);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
leaq 0x2a37(%rip), %rcx      # 0x827b
leaq 0x40(%rsp), %rdi
movl $0x5, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3210
movabsq $0x5f80403fc0201f0, %rax # imm = 0x5F80403FC0201F0
leaq 0x7e(%rsp), %rsi
movq %rax, (%rsi)
movw $0xf706, 0x8(%rsi)      # imm = 0xF706
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %rcx
movl $0xa, %edx
movq %r14, %rdi
callq 0x5e6e
leaq 0x28(%rsp), %r14
addb $-0x70, %bpl
leaq 0xd(%rsp), %rsi
movb %bpl, (%rsi)
movw $0x4040, 0x1(%rsi)      # imm = 0x4040
leaq 0xb(%rsp), %rcx
movl $0x3, %edx
movq %r14, %rdi
callq 0x5e6e
leaq 0x60(%rsp), %r12
leaq 0x40(%rsp), %r13
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x60c8
movl $0x30, %r14d
movq -0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x58e7
movq 0x8(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
addq $-0x18, %r14
jne 0x58d0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x5eb2
movq %r12, %rdi
callq 0x5f0e
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x5919
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x31a0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movq %r13, %rdi
callq 0x3390
movb $0x1, %al
jmp 0x5946
jmp 0x5941
movq %rax, %rbx
xorl %eax, %eax
leaq 0x10(%rsp), %rcx
cmpq %r14, %rcx
sete %cl
orb %al, %cl
jne 0x597d
leaq 0x10(%rsp), %r15
movq -0x18(%r14), %rdi
testq %rdi, %rdi
je 0x596f
movq -0x8(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
addq $-0x18, %r14
cmpq %r15, %r14
jne 0x595a
jmp 0x597d
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5edc
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x6a43
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%r14)
cmpl $0x5, %ebx
jne 0x6aa0
movl $0xb8, %edi
callq 0x3190
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x6722
movq %rsp, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x7776
movq %rbx, 0x8(%r14)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6aa0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6acb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31a0
jmp 0x6acb
movq %rax, %r14
movl $0xb8, %esi
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3280