LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::ZPAQL::memory()
double ZPAQL::memory() {
  double mem=pow2(header[2]+2)+pow2(header[3])  // hh hm
            +pow2(header[4]+2)+pow2(header[5])  // ph pm
            +header.size();
  int cp=7;  // start of comp list
  for (int i=0; i<header[6]; ++i) {  // n
    assert(cp<cend);
    double size=pow2(header[cp+1]); // sizebits
    switch(header[cp]) {
      case CM: mem+=4*size; break;
      case ICM: mem+=64*size+1024; break;
      case MATCH: mem+=4*size+pow2(header[cp+2]); break; // bufbits
      case MIX2: mem+=2*size; break;
      case MIX: mem+=4*size*header[cp+3]; break; // m
      case ISSE: mem+=64*size+2048; break;
      case SSE: mem+=128*size; break;
    }
    cp+=compsize[header[cp]];
  }
  return mem;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movzbl 0x2(%r14), %edi
addl $0x2, %edi
callq 0x9b03
movsd %xmm0, (%rsp)
movzbl 0x3(%r14), %edi
callq 0x9b03
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movzbl 0x4(%r14), %edi
addl $0x2, %edi
callq 0x9b03
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movzbl 0x5(%r14), %edi
callq 0x9b03
movsd 0x18(%rbx), %xmm1
unpcklps 0x148c8(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
addsd (%rsp), %xmm0
subpd 0x148cb(%rip), %xmm1    # 0x1e2c0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
addsd %xmm0, %xmm2
movapd %xmm2, (%rsp)
movzbl 0x6(%r14), %ebx
pushq $0x7
popq %rbp
leaq 0x14957(%rip), %r12     # 0x1e370
subl $0x1, %ebx
jb 0x9af0
movslq %ebp, %r15
movzbl 0x1(%r14,%r15), %edi
callq 0x9b03
movzbl (%r14,%r15), %r13d
leal -0x2(%r13), %eax
cmpl $0x7, %eax
ja 0x9aba
movapd %xmm0, %xmm1
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
mulsd 0x148e5(%rip), %xmm1    # 0x1e338
jmp 0x9aac
mulsd 0x148cb(%rip), %xmm1    # 0x1e328
addsd 0x148cb(%rip), %xmm1    # 0x1e330
jmp 0x9aac
mulsd 0x148b9(%rip), %xmm1    # 0x1e328
addsd 0x148c9(%rip), %xmm1    # 0x1e340
jmp 0x9aac
mulsd 0x1489f(%rip), %xmm1    # 0x1e320
jmp 0x9aac
movzbl 0x2(%r14,%r15), %edi
movsd %xmm1, 0x10(%rsp)
callq 0x9b03
movsd 0x10(%rsp), %xmm1
mulsd 0x14896(%rip), %xmm1    # 0x1e338
addsd %xmm0, %xmm1
jmp 0x9aac
addsd %xmm1, %xmm1
movapd (%rsp), %xmm0
addsd %xmm1, %xmm0
movapd %xmm0, (%rsp)
leaq 0x1502f(%rip), %rax     # 0x1eaf0
addl (%rax,%r13,4), %ebp
jmp 0x9a19
mulsd 0x14866(%rip), %xmm1    # 0x1e338
movzbl 0x3(%r14,%r15), %eax
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
movapd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
jmp 0x9aba
movaps (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::ZPAQL::run0(unsigned int)
void ZPAQL::run0(U32 input) {
  assert(cend>6);
  assert(hbegin>=cend+128);
  assert(hend>=hbegin);
  assert(hend<header.isize()-130);
  assert(m.size()>0);
  assert(h.size()>0);
  assert(header[0]+256*header[1]==cend+hend-hbegin-2);
  pc=hbegin;
  a=input;
  while (execute()) ;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x2c(%rdi), %eax
movl %eax, 0xb0(%rdi)
movl %esi, 0x9c(%rdi)
movq %rbx, %rdi
callq 0x9b3a
testl %eax, %eax
jne 0x9b2b
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Predictor::Predictor(libzpaq::ZPAQL&)
Predictor::Predictor(ZPAQL& zr):
    c8(1), hmap4(1), z(zr) {
  assert(sizeof(U8)==1);
  assert(sizeof(U16)==2);
  assert(sizeof(U32)==4);
  assert(sizeof(U64)==8);
  assert(sizeof(short)==2);
  assert(sizeof(int)==4);
  pcode=0;
  pcode_size=0;
  initTables=false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%rdi)
movq %rsi, 0x808(%rdi)
leaq 0x810(%rdi), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x1c76c
addq $0x70, %r15
cmpq $0x7000, %r15           # imm = 0x7000
jne 0xaba2
leaq 0x1ac14(%rbx), %rdi
leaq 0x1432a(%rip), %rsi     # 0x1eef0
movl $0x400, %edx            # imm = 0x400
callq 0x4140
andq $0x0, 0x1b018(%rbx)
andl $0x0, 0x1b020(%rbx)
movb $0x0, 0x7810(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
testq %r15, %r15
je 0xac0a
addq $0x7a0, %rbx            # imm = 0x7A0
leaq (%rbx,%r15), %rdi
callq 0x1c7e8
addq $-0x70, %r15
jne 0xabfb
movq %r14, %rdi
callq 0x4320
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Predictor::find(libzpaq::Array<unsigned char>&, int, unsigned int)
size_t Predictor::find(Array<U8>& ht, int sizebits, U32 cxt) {
  assert(initTables);
  assert(ht.size()==size_t(16)<<sizebits);
  int chk=cxt>>sizebits&255;
  size_t h0=(cxt*16)&(ht.size()-16);
  if (ht[h0]==chk) return h0;
  size_t h1=h0^16;
  if (ht[h1]==chk) return h1;
  size_t h2=h0^32;
  if (ht[h2]==chk) return h2;
  if (ht[h0+1]<=ht[h1+1] && ht[h0+1]<=ht[h2+1])
    return memset(&ht[h0], 0, 16), ht[h0]=chk, h0;
  else if (ht[h1+1]<ht[h2+1])
    return memset(&ht[h1], 0, 16), ht[h1]=chk, h1;
  else
    return memset(&ht[h2], 0, 16), ht[h2]=chk, h2;
}

// Assembly:
movl %ecx, %edi
movl %edx, %ecx
movl %edi, %edx
shrl %cl, %edx
shll $0x4, %edi
movl 0x8(%rsi), %eax
addl $-0x10, %eax
andl %edi, %eax
movq (%rsi), %rcx
cmpb %dl, (%rcx,%rax)
jne 0xb64e
retq
movq %rax, %rdi
xorq $0x10, %rdi
cmpb %dl, (%rcx,%rdi)
jne 0xb65e
movq %rdi, %rax
retq
movq %rax, %r8
xorq $0x20, %r8
cmpb %dl, (%rcx,%r8)
jne 0xb66f
movq %r8, %rax
retq
movb 0x1(%rcx,%rax), %r9b
movb 0x1(%rcx,%rdi), %r10b
movq %r8, %r11
orq $0x1, %r11
cmpb %r10b, %r9b
ja 0xb68b
cmpb (%rcx,%r11), %r9b
jbe 0xb6a4
leaq (%rcx,%rdi), %rax
leaq (%rcx,%r8), %r9
cmpb (%rcx,%r11), %r10b
cmovbq %rax, %r9
cmovbq %rdi, %r8
movq %r8, %rax
jmp 0xb6aa
addq %rax, %rcx
movq %rcx, %r9
xorps %xmm0, %xmm0
movups %xmm0, (%r9)
movq (%rsi), %rcx
movb %dl, (%rcx,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::ZPAQL::run(unsigned int)
void ZPAQL::run(U32 input) {
#ifdef NOJIT
  run0(input);
#else
  if (!rcode) {
    allocx(rcode, rcode_size, (hend*10+4096)&-4096);
    int n=assemble();
    if (n>rcode_size) {
      allocx(rcode, rcode_size, n);
      n=assemble();
    }
    if (!rcode || n<10 || rcode_size<10)
      error("run JIT failed");
  }
  a=input;
  const U32 rc=((int(*)())(&rcode[0]))();
  if (rc==0) return;
  else if (rc==1) libzpaq::error("Bad ZPAQL opcode");
  else if (rc==2) libzpaq::error("Out of memory");
  else if (rc==3) libzpaq::error("Write error");
  else libzpaq::error("ZPAQL execution error");
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0xb8(%rdi), %rax
testq %rax, %rax
jne 0xbb9b
leaq 0xb8(%r14), %r15
leaq 0xb4(%r14), %r12
imull $0xa, 0x30(%r14), %edx
andl $0xfffff000, %edx       # imm = 0xFFFFF000
addl $0x1000, %edx           # imm = 0x1000
movq %r15, %rdi
movq %r12, %rsi
callq 0x4c24
movq %r14, %rdi
callq 0xeeba
movl 0xb4(%r14), %ecx
cmpl %ecx, %eax
jle 0xbb7a
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x4c24
movq %r14, %rdi
callq 0xeeba
movl 0xb4(%r14), %ecx
cmpl $0xa, %eax
jl 0xbb8c
movq (%r15), %rax
testq %rax, %rax
je 0xbb8c
cmpl $0x9, %ecx
jg 0xbb9b
leaq 0x16b2a(%rip), %rdi     # 0x226bd
callq 0x44dc
movq (%r15), %rax
movl %ebx, 0x9c(%r14)
callq *%rax
cmpl $0x3, %eax
ja 0xbbe2
movl %eax, %eax
leaq 0x12c46(%rip), %rcx     # 0x1e7f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x16b0f(%rip), %rdi     # 0x226dd
jmp 0xbbe9
leaq 0x16b14(%rip), %rdi     # 0x226eb
jmp 0xbbe9
leaq 0x16aec(%rip), %rdi     # 0x226cc
jmp 0xbbe9
leaq 0x16294(%rip), %rdi     # 0x21e7d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x44dc
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decoder::decode(int)
int Decoder::decode(int p) {
  assert(pr.isModeled());
  assert(p>=0 && p<65536);
  assert(high>low && low>0);
  if (curr<low || curr>high) error("archive corrupted");
  assert(curr>=low && curr<=high);
  U32 mid=low+U32(((high-low)*U64(U32(p)))>>16);  // split range
  assert(high>mid && mid>=low);
  int y;
  if (curr<=mid) y=1, high=mid;  // pick half
  else y=0, low=mid+1;
  while ((high^low)<0x1000000) { // shift out identical leading bytes
    high=high<<8|255;
    low=low<<8;
    low+=(low==0);
    int c=get();
    if (c<0) error("unexpected end of file");
    curr=curr<<8|c;
  }
  return y;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x18(%rdi), %esi
movl 0x10(%rdi), %eax
movl 0x14(%rdi), %edx
cmpl %eax, %esi
setb %cl
cmpl %edx, %esi
seta %dil
orb %cl, %dil
cmpb $0x1, %dil
jne 0xbcce
leaq 0x16320(%rip), %rdi     # 0x21fe0
callq 0x44dc
movl 0x10(%rbx), %eax
movl 0x14(%rbx), %edx
movl 0x18(%rbx), %esi
movl %edx, %edi
subl %eax, %edi
movl %ebp, %ecx
imulq %rdi, %rcx
shrq $0x10, %rcx
addl %eax, %ecx
cmpl %ecx, %esi
jbe 0xbcef
incl %ecx
movl %ecx, 0x10(%rbx)
xorl %ebp, %ebp
movl %ecx, %eax
movl %edx, %ecx
jmp 0xbcf5
movl %ecx, 0x14(%rbx)
pushq $0x1
popq %rbp
leaq 0x160f8(%rip), %r14     # 0x21df4
movl %eax, %edx
xorl %ecx, %edx
cmpl $0xffffff, %edx         # imm = 0xFFFFFF
ja 0xbd4c
shll $0x8, %ecx
orl $0xff, %ecx
movl %ecx, 0x14(%rbx)
xorl %ecx, %ecx
shll $0x8, %eax
sete %cl
orl %eax, %ecx
movl %ecx, 0x10(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl %eax, %r15d
testl %eax, %eax
jns 0xbd38
movq %r14, %rdi
callq 0x44dc
movl 0x18(%rbx), %eax
shll $0x8, %eax
orl %r15d, %eax
movl %eax, 0x18(%rbx)
movl 0x10(%rbx), %eax
movl 0x14(%rbx), %ecx
jmp 0xbcfc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decoder::decompress()
int Decoder::decompress() {
  if (pr.isModeled()) {  // n>0 components?
    if (curr==0) {  // segment initialization
      for (int i=0; i<4; ++i)
        curr=curr<<8|get();
    }
    if (decode(0)) {
      if (curr!=0) error("decoding end of stream");
      return -1;
    }
    else {
      int c=1;
      while (c<256) {  // get 8 bits
        int p=pr.predict()*2+1;
        c+=c+decode(p);
        pr.update(c&1);
      }
      return c-256;
    }
  }
  else {
    if (curr==0) {
      for (int i=0; i<4; ++i) curr=curr<<8|get();
      if (curr==0) return -1;
    }
    --curr;
    return get();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x830(%rdi), %rax
movq 0x10(%rax), %rax
cmpb $0x0, 0x6(%rax)
movl 0x18(%rdi), %ebp
je 0xbda6
testl %ebp, %ebp
je 0xbe1d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xbc90
testl %eax, %eax
je 0xbdd0
pushq $-0x1
popq %r14
cmpl $0x0, 0x18(%rbx)
je 0xbe0f
leaq 0x16253(%rip), %rdi     # 0x21ff2
callq 0x44dc
jmp 0xbe0f
testl %ebp, %ebp
jne 0xbe43
xorl %ebp, %ebp
pushq $0x4
popq %r14
subl $0x1, %r14d
jb 0xbe3f
shll $0x8, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
orl %eax, %ebp
movl %ebp, 0x18(%rbx)
jmp 0xbdb4
leaq 0x28(%rbx), %r15
pushq $0x1
popq %r14
cmpl $0xff, %r14d
jg 0xbe08
movq %r15, %rdi
callq 0xbe60
leal 0x1(,%rax,2), %esi
movq %rbx, %rdi
callq 0xbc90
leal (%rax,%r14,2), %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0xbf00
jmp 0xbdd8
addl $0xffffff00, %r14d      # imm = 0xFFFFFF00
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
pushq $0x4
popq %r14
subl $0x1, %r14d
jb 0xbd80
shll $0x8, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
orl %eax, %ebp
movl %ebp, 0x18(%rbx)
jmp 0xbe23
testl %ebp, %ebp
je 0xbe5a
decl %ebp
movl %ebp, 0x18(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
pushq $-0x1
popq %r14
jmp 0xbe0f
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Predictor::predict()
int Predictor::predict() {
#ifdef NOJIT
  return predict0();
#else
  if (!pcode) {
    allocx(pcode, pcode_size, (z.cend*100+4096)&-4096);
    int n=assemble_p();
    if (n>pcode_size) {
      allocx(pcode, pcode_size, n);
      n=assemble_p();
    }
    if (!pcode || n<15 || pcode_size<15)
      error("run JIT failed");
  }
  assert(pcode && pcode[0]);
  return ((int(*)(Predictor*))&pcode[10])(this);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1b018(%rdi), %rax
testq %rax, %rax
jne 0xbef2
leaq 0x1b018(%rbx), %r14
leaq 0x1b020(%rbx), %r15
movq 0x808(%rbx), %rax
imull $0x64, 0x28(%rax), %edx
andl $0xfffff000, %edx       # imm = 0xFFFFF000
addl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c24
movq %rbx, %rdi
callq 0x11218
movl 0x1b020(%rbx), %ecx
cmpl %ecx, %eax
jle 0xbed1
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x4c24
movq %rbx, %rdi
callq 0x11218
movl 0x1b020(%rbx), %ecx
cmpl $0xf, %eax
jl 0xbee3
movq (%r14), %rax
testq %rax, %rax
je 0xbee3
cmpl $0xe, %ecx
jg 0xbef2
leaq 0x167d3(%rip), %rdi     # 0x226bd
callq 0x44dc
movq (%r14), %rax
addq $0xa, %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Predictor::update(int)
void Predictor::update(int y) {
#ifdef NOJIT
  update0(y);
#else
  assert(pcode && pcode[5]);
  ((void(*)(Predictor*, int))&pcode[5])(this, y);

  // Save bit y in c8, hmap4 (not implemented in JIT)
  c8+=c8+y;
  if (c8>=256) {
    z.run(c8-256);
    hmap4=1;
    c8=1;
    for (int i=0; i<z.header[6]; ++i) h[i]=z.H(i);
  }
  else if (c8>=16 && c8<32)
    hmap4=(hmap4&0xf)<<5|y<<4|1;
  else
    hmap4=(hmap4&0x1f0)|(((hmap4&0xf)*2+y)&0xf);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x1b018(%rdi), %rax
addq $0x5, %rax
callq *%rax
movl (%rbx), %eax
leal (%r14,%rax,2), %esi
movl %esi, (%rbx)
cmpl $0x100, %esi            # imm = 0x100
jl 0xbf7f
movq 0x808(%rbx), %rdi
addl $0xffffff00, %esi       # imm = 0xFFFFFF00
callq 0xbb08
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%rbx)
movq 0x808(%rbx), %rax
movq 0x10(%rax), %rcx
xorl %edx, %edx
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movzbl 0x6(%rcx), %edi
cmpq %rdi, %rdx
jae 0xbfb3
movq 0x50(%rax), %rdi
movq 0x58(%rax), %r8
addq %rsi, %r8
andq %rdx, %r8
movl (%rdi,%r8,4), %edi
movl %edi, 0x408(%rbx,%rdx,4)
incq %rdx
jmp 0xbf58
andl $-0x10, %esi
movl 0x4(%rbx), %eax
cmpl $0x10, %esi
jne 0xbf9c
andl $0xf, %eax
shll $0x5, %eax
shll $0x4, %r14d
orl %eax, %r14d
incl %r14d
jmp 0xbfaf
movl %eax, %ecx
andl $0x1f0, %ecx            # imm = 0x1F0
leal (%r14,%rax,2), %r14d
andl $0xf, %r14d
orl %ecx, %r14d
movl %r14d, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decoder::skip()
int Decoder::skip() {
  int c=-1;
  if (pr.isModeled()) {
    while (curr==0)  // at start?
      curr=get();
    while (curr && (c=get())>=0)  // find 4 zeros
      curr=curr<<8|c;
    while ((c=get())==0) ;  // might be more than 4
    return c;
  }
  else {
    if (curr==0)  // at start?
      for (int i=0; i<4 && (c=get())>=0; ++i) curr=curr<<8|c;
    while (curr>0) {
      while (curr>0) {
        --curr;
        if (get()<0) return error("skipped to EOF"), -1;
      }
      for (int i=0; i<4 && (c=get())>=0; ++i) curr=curr<<8|c;
    }
    if (c>=0) c=get();
    return c;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x830(%rdi), %rax
movq 0x10(%rax), %rax
cmpb $0x0, 0x6(%rax)
movl 0x18(%rdi), %eax
jne 0xc03d
pushq $-0x1
popq %rbp
testl %eax, %eax
je 0xc08d
pushq $0x4
popq %r14
movl 0x18(%rbx), %eax
testl %eax, %eax
je 0xc0ba
testl %eax, %eax
je 0xc00e
decl %eax
movl %eax, 0x18(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testl %eax, %eax
js 0xc071
movl 0x18(%rbx), %eax
jmp 0xbff4
movl %r14d, %r15d
subl $0x1, %r15d
jb 0xbfe9
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl %eax, %ebp
testl %eax, %eax
js 0xbfe9
movl 0x18(%rbx), %eax
shll $0x8, %eax
orl %ebp, %eax
movl %eax, 0x18(%rbx)
jmp 0xc011
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl %eax, 0x18(%rbx)
testl %eax, %eax
je 0xc032
pushq $0x1
popq %rcx
testl %ecx, %ecx
je 0xc061
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testl %eax, %eax
js 0xc061
movl 0x18(%rbx), %ecx
shll $0x8, %ecx
orl %eax, %ecx
movl %ecx, 0x18(%rbx)
jmp 0xc044
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testl %eax, %eax
je 0xc061
movl %eax, %ebp
jmp 0xc080
leaq 0x15f91(%rip), %rdi     # 0x22009
callq 0x44dc
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %r14
subl $0x1, %r14d
jb 0xbfe5
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl %eax, %ebp
testl %eax, %eax
js 0xbfe5
movl 0x18(%rbx), %eax
shll $0x8, %eax
orl %ebp, %eax
movl %eax, 0x18(%rbx)
jmp 0xc091
testl %ebp, %ebp
js 0xc080
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::PostProcessor::init(int, int)
void PostProcessor::init(int h, int m) {
  state=hsize=0;
  ph=h;
  pm=m;
  z.clear();
}

// Assembly:
andq $0x0, (%rdi)
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
addq $0x10, %rdi
jmp 0x96e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decompresser::findBlock(double*)
bool Decompresser::findBlock(double* memptr) {
  assert(state==BLOCK);

  // Find start of block
  U32 h1=0x3D49B113, h2=0x29EB7F93, h3=0x2614BE13, h4=0x3828EB13;
  // Rolling hashes initialized to hash of first 13 bytes
  int c;
  while ((c=dec.get())!=-1) {
    h1=h1*12+c;
    h2=h2*20+c;
    h3=h3*28+c;
    h4=h4*44+c;
    if (h1==0xB16B88F1 && h2==0xFF5376F1 && h3==0x72AC5BF1 && h4==0x2F909AF1)
      break;  // hash of 16 byte string
  }
  if (c==-1) return false;

  // Read header
  if ((c=dec.get())!=1 && c!=2) error("unsupported ZPAQ level");
  if (dec.get()!=1) error("unsupported ZPAQL type");
  z.read(&dec);
  if (c==1 && z.header.isize()>6 && z.header[6]==0)
    error("ZPAQ level 1 requires at least 1 component");
  if (memptr) *memptr=z.memory();
  state=FILENAME;
  decode_state=FIRSTSEG;
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc0(%rdi), %r15
movdqa 0x1203d(%rip), %xmm2    # 0x1e2e0
pshufd $0xf5, 0x12044(%rip), %xmm0 # xmm0 = mem[1,1,3,3]
movdqa %xmm0, (%rsp)
movdqa %xmm2, 0x10(%rsp)
movq %r15, %rdi
callq 0x1c87a
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xc395
movdqa 0x10(%rsp), %xmm1
pshufd $0xf5, %xmm1, %xmm0     # xmm0 = xmm1[1,1,3,3]
pmuludq 0x12013(%rip), %xmm1    # 0x1e2f0
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
pmuludq (%rsp), %xmm0
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movd %ebp, %xmm0
pshufd $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0]
paddd %xmm1, %xmm2
movdqa %xmm2, %xmm0
pcmpeqd 0x11ff7(%rip), %xmm0    # 0x1e300
movmskps %xmm0, %eax
xorl $0xf, %eax
jne 0xc2b1
movq %r15, %rdi
callq 0x1c87a
movl %eax, %r12d
leal -0x3(%r12), %eax
cmpl $-0x3, %eax
ja 0xc332
leaq 0x15d23(%rip), %rdi     # 0x22050
callq 0x44dc
movq %r15, %rdi
callq 0x1c87a
cmpl $0x1, %eax
je 0xc34b
leaq 0x15d21(%rip), %rdi     # 0x22067
callq 0x44dc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x94dc
cmpl $0x1, %r12d
jne 0xc378
cmpl $0x7, 0x18(%rbx)
jl 0xc378
movq 0x10(%rbx), %rax
cmpb $0x0, 0x6(%rax)
jne 0xc378
leaq 0x15d0b(%rip), %rdi     # 0x2207e
callq 0x44dc
testq %r14, %r14
je 0xc38a
movq %rbx, %rdi
callq 0x9980
movq %xmm0, (%r14)
movq $0x1, 0x1b1f8(%rbx)
cmpl $-0x1, %ebp
setne %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decompresser::findFilename(libzpaq::Writer*)
bool Decompresser::findFilename(Writer* filename) {
  assert(state==FILENAME);
  int c=dec.get();
  if (c==1) {  // segment found
    while (true) {
      c=dec.get();
      if (c==-1) error("unexpected EOF");
      if (c==0) {
        state=COMMENT;
        return true;
      }
      if (filename) filename->put(c);
    }
  }
  else if (c==255) {  // end of block found
    state=BLOCK;
    return false;
  }
  else
    error("missing segment or end of block");
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0xc0(%rdi), %r12
movq %r12, %rdi
callq 0x1c87a
movl %eax, %ebx
cmpl $0x1, %eax
jne 0xc411
leaq 0x15cd3(%rip), %r13     # 0x220a9
movq %r12, %rdi
callq 0x1c87a
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xc3eb
testl %ebp, %ebp
jne 0xc3f3
jmp 0xc404
movq %r13, %rdi
callq 0x44dc
testq %r15, %r15
je 0xc3d6
movq (%r15), %rax
movq %r15, %rdi
movl %ebp, %esi
callq *(%rax)
jmp 0xc3d6
movl $0x2, 0x1b1f8(%r14)
jmp 0xc42f
cmpl $0xff, %ebx
jne 0xc423
andl $0x0, 0x1b1f8(%r14)
jmp 0xc42f
leaq 0x15c8e(%rip), %rdi     # 0x220b8
callq 0x44dc
cmpl $0x1, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decompresser::readComment(libzpaq::Writer*)
void Decompresser::readComment(Writer* comment) {
  assert(state==COMMENT);
  state=DATA;
  while (true) {
    int c=dec.get();
    if (c==-1) error("unexpected EOF");
    if (c==0) break;
    if (comment) comment->put(c);
  }
  if (dec.get()!=0) error("missing reserved byte");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3, 0x1b1f8(%rdi)
addq $0xc0, %rbx
leaq 0x15c40(%rip), %r15     # 0x220a9
movq %rbx, %rdi
callq 0x1c87a
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xc47e
testl %ebp, %ebp
jne 0xc486
jmp 0xc497
movq %r15, %rdi
callq 0x44dc
testq %r14, %r14
je 0xc469
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
callq *(%rax)
jmp 0xc469
movq %rbx, %rdi
callq 0x1c87a
testl %eax, %eax
je 0xc4b9
leaq 0x15c2e(%rip), %rdi     # 0x220d8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x44dc
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::Decompresser::decompress(int)
bool Decompresser::decompress(int n) {
  assert(state==DATA);
  if (decode_state==SKIP) error("decompression after skipped segment");
  assert(decode_state!=SKIP);

  // Initialize models to start decompressing block
  if (decode_state==FIRSTSEG) {
    dec.init();
    assert(z.header.size()>5);
    pp.init(z.header[4], z.header[5]);
    decode_state=SEG;
  }

  // Decompress and load PCOMP into postprocessor
  while ((pp.getState()&3)!=1)
    pp.write(dec.decompress());

  // Decompress n bytes, or all if n < 0
  while (n) {
    int c=dec.decompress();
    pp.write(c);
    if (c==-1) {
      state=SEGEND;
      return false;
    }
    if (n>0) --n;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x1b1fc(%rdi), %eax
cmpl $0x2, %eax
jne 0xc4ef
leaq 0x15c0b(%rip), %rdi     # 0x220ee
callq 0x44dc
movl 0x1b1fc(%r14), %eax
testl %eax, %eax
jne 0xc522
leaq 0xc0(%r14), %rdi
callq 0xbc5e
leaq 0x1b128(%r14), %rdi
movq 0x10(%r14), %rax
movzbl 0x4(%rax), %esi
movzbl 0x5(%rax), %edx
callq 0xc0d0
movl $0x1, 0x1b1fc(%r14)
leaq 0x1b128(%r14), %r15
leaq 0xc0(%r14), %r12
movl (%r15), %eax
andl $0x3, %eax
cmpl $0x1, %eax
je 0xc571
movq %r12, %rdi
callq 0xbd5a
movq %r15, %rdi
movl %eax, %esi
callq 0xc0e4
jmp 0xc530
movq %r12, %rdi
callq 0xbd5a
movl %eax, %ebp
movq %r15, %rdi
movl %eax, %esi
callq 0xc0e4
cmpl $-0x1, %ebp
je 0xc577
xorl %eax, %eax
testl %ebx, %ebx
setg %al
subl %eax, %ebx
testl %ebx, %ebx
jne 0xc54f
jmp 0xc582
movl $0x4, 0x1b1f8(%r14)
testl %ebx, %ebx
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decompresser::readSegmentEnd(char*)
void Decompresser::readSegmentEnd(char* sha1string) {
  assert(state==DATA || state==SEGEND);

  // Skip remaining data if any and get next byte
  int c=0;
  if (state==DATA) {
    c=dec.skip();
    decode_state=SKIP;
  }
  else if (state==SEGEND)
    c=dec.get();
  state=FILENAME;

  // Read checksum
  if (c==254) {
    if (sha1string) sha1string[0]=0;  // no checksum
  }
  else if (c==253) {
    if (sha1string) sha1string[0]=1;
    for (int i=1; i<=20; ++i) {
      c=dec.get();
      if (sha1string) sha1string[i]=c;
    }
  }
  else
    error("missing end of segment marker");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x1b1f8(%rdi), %eax
cmpl $0x3, %eax
je 0xc5b9
cmpl $0x4, %eax
jne 0xc5f7
leaq 0xc0(%r14), %rdi
callq 0x1c87a
jmp 0xc5d0
leaq 0xc0(%r14), %rdi
callq 0xbfbc
movl $0x2, 0x1b1fc(%r14)
movl $0x1, 0x1b1f8(%r14)
cmpl $0xfd, %eax
je 0xc613
cmpl $0xfe, %eax
jne 0xc602
testq %rbx, %rbx
je 0xc5f1
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, 0x1b1f8(%r14)
leaq 0x15b09(%rip), %rdi     # 0x22112
popq %rbx
popq %r14
popq %r15
jmp 0x44dc
testq %rbx, %rbx
je 0xc61b
movb $0x1, (%rbx)
addq $0xc0, %r14
pushq $0x1
popq %r15
cmpq $0x15, %r15
je 0xc5f1
movq %r14, %rdi
callq 0x1c87a
testq %rbx, %rbx
je 0xc63d
movb %al, (%rbx,%r15)
incq %r15
jmp 0xc626
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::decompress(libzpaq::Reader*, libzpaq::Writer*)
void decompress(Reader* in, Writer* out) {
  Decompresser d;
  d.setInput(in);
  d.setOutput(out);
  while (d.findBlock()) {       // don't calculate memory
    while (d.findFilename()) {  // discard filename
      d.readComment();          // discard comment
      d.decompress();           // to end of segment
      d.readSegmentEnd();       // discard sha1string
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b208, %rsp          # imm = 0x1B208
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1c8d2
movq %r15, 0xc8(%rbx)
movq %r14, 0x1b138(%rbx)
pushq $-0x1
popq %rbp
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc282
testb %al, %al
je 0xc6af
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc3a8
testb %al, %al
je 0xc673
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc444
movq %rbx, %rdi
movl %ebp, %esi
callq 0xc4c4
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc590
jmp 0xc681
leaq 0x8(%rsp), %rdi
callq 0x1c92c
addq $0x1b208, %rsp          # imm = 0x1B208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc6c9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1c92c
movq %rbx, %rdi
callq 0x4320
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Encoder::init()
void Encoder::init() {
  low=1;
  high=0xFFFFFFFF;
  pr.init();
  if (!pr.isModeled()) low=0, buf.resize(1<<16);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movabsq $-0xffffffff, %rax      # imm = 0xFFFFFFFF00000001
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
callq 0xac5a
movq 0x818(%rbx), %rax
movq 0x10(%rax), %rax
cmpb $0x0, 0x6(%rax)
je 0xc70c
popq %rbx
retq
andl $0x0, 0x8(%rbx)
addq $0x1b038, %rbx          # imm = 0x1B038
movl $0x10000, %esi          # imm = 0x10000
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
jmp 0x1c610
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Encoder::encode(int, int)
void Encoder::encode(int y, int p) {
  assert(out);
  assert(p>=0 && p<65536);
  assert(y==0 || y==1);
  assert(high>low && low>0);
  U32 mid=low+U32(((high-low)*U64(U32(p)))>>16);  // split range
  assert(high>mid && mid>=low);
  if (y) high=mid; else low=mid+1; // pick half
  while ((high^low)<0x1000000) { // write identical leading bytes
    out->put(high>>24);  // same as low>>24
    high=high<<8|255;
    low=low<<8;
    low+=(low==0); // so we don't code 4 0 bytes in a row
  }
}

// Assembly:
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edi
movl %edi, %r8d
subl %ecx, %r8d
movl %edx, %esi
imulq %r8, %rsi
shrq $0x10, %rsi
addl %ecx, %esi
testl %eax, %eax
je 0xc74f
movl %esi, 0xc(%rbx)
jmp 0xc784
incl %esi
movl %esi, 0x8(%rbx)
movl %esi, %ecx
movl %edi, %esi
jmp 0xc784
movq (%rbx), %rdi
shrl $0x18, %esi
movq (%rdi), %rax
callq *(%rax)
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %esi
shll $0x8, %esi
orl $0xff, %esi
movl %esi, 0xc(%rbx)
xorl %ecx, %ecx
shll $0x8, %eax
sete %cl
orl %eax, %ecx
movl %ecx, 0x8(%rbx)
xorl %esi, %ecx
cmpl $0xffffff, %ecx         # imm = 0xFFFFFF
jbe 0xc75a
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Encoder::compress(int)
void Encoder::compress(int c) {
  assert(out);
  if (pr.isModeled()) {
    if (c==-1)
      encode(1, 0);
    else {
      assert(c>=0 && c<=255);
      encode(0, 0);
      for (int i=7; i>=0; --i) {
        int p=pr.predict()*2+1;
        assert(p>0 && p<65536);
        int y=c>>i&1;
        encode(y, p);
        pr.update(y);
      }
    }
  }
  else {
    if (low && (c<0 || low==buf.size())) {
      out->put((low>>24)&255);
      out->put((low>>16)&255);
      out->put((low>>8)&255);
      out->put(low&255);
      out->write(&buf[0], low);
      low=0;
    }
    if (c>=0) buf[low++]=c;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq 0x10(%rax), %rax
cmpb $0x0, 0x6(%rax)
je 0xc809
cmpl $-0x1, %ebp
je 0xc886
leaq 0x10(%rbx), %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc728
pushq $0x7
popq %r12
testl %r12d, %r12d
js 0xc87d
movq %r14, %rdi
callq 0xbe60
leal 0x1(,%rax,2), %edx
xorl %r15d, %r15d
btl %r12d, %ebp
setb %r15b
movq %rbx, %rdi
movl %r15d, %esi
callq 0xc728
movq %r14, %rdi
movl %r15d, %esi
callq 0xbf00
decl %r12d
jmp 0xc7cb
movl 0x8(%rbx), %esi
testq %rsi, %rsi
je 0xc864
testl %ebp, %ebp
js 0xc81e
cmpq %rsi, 0x1b040(%rbx)
jne 0xc86a
movq (%rbx), %rdi
shrl $0x18, %esi
movq (%rdi), %rax
callq *(%rax)
movq (%rbx), %rdi
movzbl 0xa(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
movq (%rbx), %rdi
movzbl 0x9(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
movq (%rbx), %rdi
movzbl 0x8(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
movq (%rbx), %rdi
movq 0x1b038(%rbx), %rsi
movl 0x8(%rbx), %edx
movq (%rdi), %rax
callq *0x8(%rax)
andl $0x0, 0x8(%rbx)
xorl %esi, %esi
testl %ebp, %ebp
js 0xc87d
leal 0x1(%rsi), %eax
movl %eax, 0x8(%rbx)
movl %esi, %eax
movq 0x1b038(%rbx), %rcx
movb %bpl, (%rcx,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc728
nop
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compiler::next()
void Compiler::next() {
  assert(in);
  for (; *in; ++in) {
    if (*in=='\n') ++line;
    if (*in=='(') state+=1+(state<0);
    else if (state>0 && *in==')') --state;
    else if (state<0 && *in<=' ') state=0;
    else if (state==0 && *in>' ') {state=-1; break;}
  }
  if (!*in) error("unexpected end of config");
}

// Assembly:
movq (%rdi), %rax
movl 0x28(%rdi), %ecx
movl 0x2c(%rdi), %edx
incq %rax
movzbl -0x1(%rax), %esi
cmpl $0xa, %esi
je 0xc8b7
testl %esi, %esi
jne 0xc8c0
jmp 0xc915
incl %ecx
movl %ecx, 0x28(%rdi)
movb -0x1(%rax), %sil
cmpb $0x28, %sil
jne 0xc8d4
movl %edx, %esi
shrl $0x1f, %esi
leal (%rdx,%rsi), %r8d
incl %r8d
jmp 0xc8e3
cmpb $0x29, %sil
jne 0xc8ef
testl %edx, %edx
jle 0xc8ef
decl %edx
movl %edx, %r8d
movl %r8d, 0x2c(%rdi)
movl %r8d, %edx
movq %rax, (%rdi)
jmp 0xc8a5
testl %edx, %edx
js 0xc8ff
cmpb $0x21, %sil
jl 0xc8ea
testl %edx, %edx
jne 0xc8ea
jmp 0xc90a
xorl %r8d, %r8d
cmpb $0x21, %sil
jl 0xc8e3
jmp 0xc8ea
orl $-0x1, 0x2c(%rdi)
cmpb $0x0, -0x1(%rax)
je 0xc915
retq
leaq 0x15bf5(%rip), %rdi     # 0x22511
jmp 0x44dc
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
xorl %ecx, %ecx
movsbl (%rax,%rcx), %edx
cmpl $0x28, %edx
sete %r8b
movsbl (%rsi,%rcx), %edi
cmpl $0x21, %edx
jl 0xc979
cmpb $0x28, %dl
je 0xc979
testb %dil, %dil
je 0xc981
leal -0x41(%rdx), %r8d
leal 0x20(%rdx), %r9d
cmpl $0x1a, %r8d
cmovael %edx, %r9d
leal -0x41(%rdi), %edx
leal 0x20(%rdi), %r8d
cmpl $0x1a, %edx
cmovael %edi, %r8d
cmpl %r8d, %r9d
jne 0xc97e
incq %rcx
jmp 0xc933
testb %dil, %dil
je 0xc984
xorl %eax, %eax
retq
xorl %r8d, %r8d
cmpb $0x21, %dl
setl %al
orb %r8b, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsp, %r14
movl $0x80, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1c380
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
pushq $0xa
popq %rdi
testl %esi, %esi
je 0xca17
movl 0x28(%r12), %eax
cltd
idivl %esi
testl %eax, %eax
je 0xca0e
cltd
idivl %edi
addb $0x30, %dl
movslq %ecx, %rax
incl %ecx
movb %dl, (%r14,%rax)
movl %esi, %eax
cltd
idivl %edi
movl %eax, %esi
jmp 0xc9ef
movq %r14, %rdi
callq 0x40b0
movl $0x20746120, (%r14,%rax) # imm = 0x20746120
movb $0x0, 0x4(%r14,%rax)
movq %r14, %rdi
callq 0x40b0
cltq
cmpq $0x27, %rax
jg 0xca59
movq (%r12), %rcx
cmpb $0x20, (%rcx)
jle 0xca59
leaq 0x1(%rcx), %rdx
movq %rdx, (%r12)
movb (%rcx), %cl
movb %cl, (%r14,%rax)
incq %rax
jmp 0xca37
movq %r14, %rdi
callq 0x40b0
movw $0x203a, (%r14,%rax)    # imm = 0x203A
movb $0x0, 0x2(%r14,%rax)
pushq $0x28
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4110
testq %rbx, %rbx
je 0xcab4
movq %r14, %rdi
callq 0x40b0
movabsq $0x746365707865202c, %rcx # imm = 0x746365707865202C
movq %rcx, (%r14,%rax)
movabsq $0x203a6465746365, %rcx # imm = 0x203A6465746365
movq %rcx, 0x5(%r14,%rax)
pushq $0x14
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4110
movq %r14, %rdi
callq 0x44dc
movq %rsp, %rdi
callq 0x1c390
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1c390
movq %rbx, %rdi
callq 0x4320
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0xc89c
xorl %r14d, %r14d
movq (%r15,%r14,8), %rsi
testq %rsi, %rsi
je 0xcb11
movq %rbx, %rdi
callq 0xc92e
testb %al, %al
jne 0xcb26
incq %r14
jmp 0xcaf7
leaq 0x15a31(%rip), %rsi     # 0x22549
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc98e
pushq $-0x1
popq %r14
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc89c
movq (%rbx), %rdi
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0xcbd1
cmpl $0x24, %eax
jne 0xcbcb
movzbl 0x1(%rdi), %r12d
leal -0x31(%r12), %eax
cmpb $0x8, %al
ja 0xcbdb
xorl %r15d, %r15d
cmpb $0x2b, 0x2(%rdi)
jne 0xcbb8
addq $0x3, %rdi
callq 0x42b0
movl %eax, %r15d
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xcbef
addl -0xc4(%rax,%r12,4), %r15d
jmp 0xcbef
addb $-0x30, %al
cmpb $0x9, %al
ja 0xcbdb
callq 0x42b0
movl %eax, %r15d
jmp 0xcbef
leaq 0x15972(%rip), %rsi     # 0x22554
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc98e
cmpl %r14d, %r15d
jge 0xcc05
leaq 0x1596b(%rip), %rsi     # 0x22566
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc98e
cmpl %ebp, %r15d
jle 0xcc1b
leaq 0x15964(%rip), %rsi     # 0x22575
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc98e
movl %r15d, %eax
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::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
pushq $0x37
popq %rsi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
pushq $0x6b
popq %rsi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
pushq $0x53
popq %rsi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
pushq $0x74
popq %rsi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
movl $0xa0, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
pushq $0x31
popq %rsi
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
pushq $0x28
popq %rsi
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_O2/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 0x1d7a9(%rip), %rcx     # 0x2acb8
movq %rsp, %rax
movq %rcx, (%rax)
movq %rsi, 0x8(%rax)
movq %rax, %rsi
callq 0x94dc
leaq 0x1b1d8(%rbx), %rax
movq %rax, 0xc8(%rbx)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
pushq $0x7a
popq %rsi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
pushq $0x50
popq %rsi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
pushq $0x51
popq %rsi
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
pushq $0x1
popq %rsi
callq *(%rax)
movq 0x180(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9442
movl $0x1, 0x1b25c(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r9
movq %rdi, %rbx
leaq 0xc0(%rdi), %r8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
callq 0xd052
movq %r14, %rdi
callq 0x1c9d8
leaq 0x1b1d8(%rbx), %rax
movq %rax, 0xc8(%rbx)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
pushq $0x7a
popq %rsi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
pushq $0x50
popq %rsi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
pushq $0x51
popq %rsi
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
pushq $0x1
popq %rsi
callq *(%rax)
movq 0x180(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9442
movl $0x1, 0x1b25c(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq *(%rax)
testq %r15, %r15
je 0xd691
movsbl (%r15), %esi
testl %esi, %esi
je 0xd691
movq 0x180(%rbx), %rdi
incq %r15
movq (%rdi), %rax
jmp 0xd673
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
testq %r14, %r14
je 0xd6bb
movsbl (%r14), %esi
testl %esi, %esi
je 0xd6bb
movq 0x180(%rbx), %rdi
incq %r14
movq (%rdi), %rax
jmp 0xd69d
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq 0x180(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movl 0x1b25c(%rbx), %eax
cmpl $0x1, %eax
je 0xd6eb
cmpl $0x3, %eax
jne 0xd6f4
pushq $0x4
jmp 0xd6ed
pushq $0x2
popq %rax
movl %eax, 0x1b25c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd7dd
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 0xc6de
testq %r14, %r14
je 0xd740
testl %ebp, %ebp
jne 0xd73a
movzwl (%r14), %ebp
addq $0x2, %r14
testl %ebp, %ebp
jg 0xd759
jmp 0xd7bb
movl 0xf0(%rbx), %ebp
movslq 0xec(%rbx), %r14
subl %r14d, %ebp
jle 0xd7bb
addq 0xd0(%rbx), %r14
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0xc790
movl $0xff, %r12d
movl %ebp, %esi
andl %r12d, %esi
movq %r15, %rdi
callq 0xc790
movl %ebp, %esi
shrl $0x8, %esi
andl %r12d, %esi
movq %r15, %rdi
callq 0xc790
movl %ebp, %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0xd7a4
movzbl (%r14,%r13), %esi
movq %r15, %rdi
callq 0xc790
incq %r13
jmp 0xd78d
cmpb $0x0, 0x1b260(%rbx)
je 0xd7c5
leaq 0xc0(%rbx), %rdi
callq 0x992a
jmp 0xd7c5
movq %r15, %rdi
xorl %esi, %esi
callq 0xc790
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_O2/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, %r12d
movq %rdi, %r14
cmpl $0x2, 0x1b25c(%rdi)
jne 0xd80a
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd6fa
leaq 0x180(%r14), %r15
leaq 0xc0(%r14), %rax
movq %rax, 0x18(%rsp)
leaq 0x1b1d8(%r14), %rax
movq %rax, 0x10(%rsp)
testl %r12d, %r12d
je 0xd8e5
movl $0x4000, %eax           # imm = 0x4000
cmpl %eax, %r12d
movl $0x4000, %ebx           # imm = 0x4000
cmovbl %r12d, %ebx
movq 0x1b1d0(%r14), %rdi
movq (%rdi), %rax
leaq 0x20(%rsp), %rsi
movl %ebx, %edx
callq *0x8(%rax)
movl %eax, %ebp
cmpl $0x4001, %eax           # imm = 0x4001
setb %al
cmpl %ebx, %ebp
setle %cl
testb %cl, %al
jne 0xd876
leaq 0x14dfb(%rip), %rdi     # 0x2266c
callq 0x44dc
testl %ebp, %ebp
jle 0xd8e5
movl %r12d, 0xc(%rsp)
testl %r12d, %r12d
movl %ebp, %r13d
movl $0x0, %eax
cmovsl %eax, %ebp
xorl %r12d, %r12d
cmpq %r12, %r13
je 0xd8d8
movzbl 0x20(%rsp,%r12), %ebx
movq %r15, %rdi
movl %ebx, %esi
callq 0xc790
cmpb $0x1, 0x1b260(%r14)
jne 0xd8d3
cmpl $0x0, 0xf0(%r14)
je 0xd8c7
movq 0x18(%rsp), %rdi
movl %ebx, %esi
callq 0xbb08
jmp 0xd8d3
movq 0x10(%rsp), %rdi
movl %ebx, %esi
callq 0x1c31c
incq %r12
jmp 0xd890
movl 0xc(%rsp), %r12d
subl %ebp, %r12d
jmp 0xd829
testl %r12d, %r12d
sete %al
addq $0x4028, %rsp           # imm = 0x4028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop