LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::ZPAQL::init(int, int)
void ZPAQL::init(int hbits, int mbits) {
  assert(header.isize()>0);
  assert(cend>=7);
  assert(hbegin>=cend+128);
  assert(hend>=hbegin);
  assert(hend<header.isize()-130);
  assert(header[0]+256*header[1]==cend-2+hend-hbegin);
  assert(bufptr==0);
  assert(outbuf.isize()>0);
  if (hbits>32) error("H too big");
  if (mbits>32) error("M too big");
  h.resize(1, hbits);
  m.resize(1, mbits);
  r.resize(256);
  a=b=c=d=pc=f=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x20, -0xc(%rbp)
jle 0xee7c
leaq 0x290f2(%rip), %rdi     # 0x37f69
callq 0x5720
cmpl $0x20, -0x10(%rbp)
jle 0xee8e
leaq 0x290ea(%rip), %rdi     # 0x37f73
callq 0x5720
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
movl -0xc(%rbp), %edx
movl $0x1, %esi
callq 0x30220
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movl -0x10(%rbp), %edx
movl $0x1, %esi
callq 0x30370
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x30220
movq -0x18(%rbp), %rax
movl $0x0, 0xac(%rax)
movl $0x0, 0xb0(%rax)
movl $0x0, 0xa8(%rax)
movl $0x0, 0xa4(%rax)
movl $0x0, 0xa0(%rax)
movl $0x0, 0x9c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x2c(%rax), %ecx
movl %ecx, 0xb0(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x9c(%rax)
movq -0x18(%rbp), %rdi
callq 0xf3a0
cmpl $0x0, %eax
je 0xf399
jmp 0xf389
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x1, (%rax)
movl $0x1, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x808(%rax)
addq $0x810, %rax            # imm = 0x810
movq %rax, -0x38(%rbp)
movq %rax, %rcx
addq $0x7000, %rcx           # imm = 0x7000
movq %rcx, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x30ac0
jmp 0x1186b
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %rax
addq $0x70, %rax
cmpq %rcx, %rax
movq %rax, -0x28(%rbp)
jne 0x1185c
movq -0x40(%rbp), %rdi
addq $0x1ac14, %rdi          # imm = 0x1AC14
callq 0xe6b0
jmp 0x11892
movq -0x40(%rbp), %rax
movq $0x0, 0x1b018(%rax)
movl $0x0, 0x1b020(%rax)
movb $0x0, 0x7810(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rcx
movq %rax, %rsi
movq -0x48(%rbp), %rax
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq %rax, %rcx
movq %rax, -0x50(%rbp)
je 0x118f5
movq -0x50(%rbp), %rdi
addq $-0x70, %rdi
movq %rdi, -0x58(%rbp)
callq 0x30b80
movq -0x38(%rbp), %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x118d3
jmp 0x11936
movq %rdx, %rcx
movq %rax, %rdx
movq -0x38(%rbp), %rax
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
addq $0x7000, %rax           # imm = 0x7000
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
addq $-0x70, %rdi
movq %rdi, -0x68(%rbp)
callq 0x30b80
movq -0x38(%rbp), %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x60(%rbp)
jne 0x11912
jmp 0x11936
movq -0x18(%rbp), %rdi
callq 0x5490
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0xb8(%rax)
jne 0x13385
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0xb8, %rdi
movq %rax, %rsi
addq $0xb4, %rsi
imull $0xa, 0x30(%rax), %edx
addl $0x1000, %edx           # imm = 0x1000
andl $0xfffff000, %edx       # imm = 0xFFFFF000
callq 0x65c0
movq -0x20(%rbp), %rdi
callq 0x186f0
movq -0x20(%rbp), %rcx
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0xb4(%rcx), %eax
jle 0x13356
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0xb8, %rdi
addq $0xb4, %rsi
movl -0x10(%rbp), %edx
callq 0x65c0
movq -0x20(%rbp), %rdi
callq 0x186f0
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
je 0x13377
cmpl $0xa, -0x10(%rbp)
jl 0x13377
movq -0x20(%rbp), %rax
cmpl $0xa, 0xb4(%rax)
jge 0x13383
leaq 0x25468(%rip), %rdi     # 0x387e6
callq 0x5720
jmp 0x13385
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x9c(%rax)
movq 0xb8(%rax), %rax
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x133a6
jmp 0x133f4
cmpl $0x1, -0x14(%rbp)
jne 0x133ba
leaq 0x25442(%rip), %rdi     # 0x387f5
callq 0x5720
jmp 0x133f2
cmpl $0x2, -0x14(%rbp)
jne 0x133ce
leaq 0x2543f(%rip), %rdi     # 0x38806
callq 0x5720
jmp 0x133f0
cmpl $0x3, -0x14(%rbp)
jne 0x133e2
leaq 0x25439(%rip), %rdi     # 0x38814
callq 0x5720
jmp 0x133ee
leaq 0x24b94(%rip), %rdi     # 0x37f7d
callq 0x5720
jmp 0x133f0
jmp 0x133f2
jmp 0x133f4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x18(%rcx), %eax
cmpl 0x10(%rcx), %eax
jb 0x1355b
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
cmpl 0x14(%rcx), %eax
jbe 0x13567
leaq 0x24b7e(%rip), %rdi     # 0x380e0
callq 0x5720
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
movl 0x14(%rax), %edx
subl 0x10(%rax), %edx
movl %edx, %edx
movl -0xc(%rbp), %esi
imulq %rsi, %rdx
shrq $0x10, %rdx
addl %edx, %ecx
movl %ecx, -0x10(%rbp)
movl 0x18(%rax), %eax
cmpl -0x10(%rbp), %eax
ja 0x135a1
movq -0x20(%rbp), %rax
movl $0x1, -0x14(%rbp)
movl -0x10(%rbp), %ecx
movl %ecx, 0x14(%rax)
jmp 0x135b5
movq -0x20(%rbp), %rax
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x135b7
movq -0x20(%rbp), %rcx
movl 0x14(%rcx), %eax
xorl 0x10(%rcx), %eax
cmpl $0x1000000, %eax        # imm = 0x1000000
jae 0x13621
movq -0x20(%rbp), %rdi
movl 0x14(%rdi), %eax
shll $0x8, %eax
orl $0xff, %eax
movl %eax, 0x14(%rdi)
movl 0x10(%rdi), %eax
shll $0x8, %eax
movl %eax, 0x10(%rdi)
cmpl $0x0, 0x10(%rdi)
sete %al
andb $0x1, %al
movzbl %al, %eax
addl 0x10(%rdi), %eax
movl %eax, 0x10(%rdi)
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x1360f
leaq 0x248ea(%rip), %rdi     # 0x37ef4
callq 0x5720
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
shll $0x8, %ecx
orl -0x18(%rbp), %ecx
movl %ecx, 0x18(%rax)
jmp 0x135b7
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x28, %rdi
callq 0x30bc0
testb $0x1, %al
jne 0x13656
jmp 0x13732
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x1369a
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x13698
movq -0x28(%rbp), %rdi
movl 0x18(%rdi), %eax
shll $0x8, %eax
movl %eax, -0x2c(%rbp)
movq (%rdi), %rax
callq *(%rax)
movl -0x2c(%rbp), %ecx
movl %eax, %edx
movq -0x28(%rbp), %rax
orl %edx, %ecx
movl %ecx, 0x18(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13667
jmp 0x1369a
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x13530
cmpl $0x0, %eax
je 0x136cc
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x136c0
leaq 0x24a37(%rip), %rdi     # 0x380f2
callq 0x5720
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1379e
movl $0x1, -0x18(%rbp)
cmpl $0x100, -0x18(%rbp)     # imm = 0x100
jge 0x13725
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x137b0
movq -0x28(%rbp), %rdi
shll %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %esi
callq 0x13530
movq -0x28(%rbp), %rdi
movl %eax, %ecx
movl -0x30(%rbp), %eax
addl %ecx, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
addq $0x28, %rdi
movl -0x18(%rbp), %esi
andl $0x1, %esi
callq 0x13890
jmp 0x136d3
movl -0x18(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
movl %eax, -0x4(%rbp)
jmp 0x1379e
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x13789
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x13774
movq -0x28(%rbp), %rdi
movl 0x18(%rdi), %eax
shll $0x8, %eax
movl %eax, -0x34(%rbp)
movq (%rdi), %rax
callq *(%rax)
movl -0x34(%rbp), %ecx
movl %eax, %edx
movq -0x28(%rbp), %rax
orl %edx, %ecx
movl %ecx, 0x18(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x13743
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x13787
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1379e
jmp 0x13789
movq -0x28(%rbp), %rdi
movl 0x18(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x18(%rdi)
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x1b018(%rax)
jne 0x13879
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x1b018, %rdi          # imm = 0x1B018
movq %rax, %rsi
addq $0x1b020, %rsi          # imm = 0x1B020
movq 0x808(%rax), %rax
imull $0x64, 0x28(%rax), %edx
addl $0x1000, %edx           # imm = 0x1000
andl $0xfffff000, %edx       # imm = 0xFFFFF000
callq 0x65c0
movq -0x18(%rbp), %rdi
callq 0x1cb50
movq -0x18(%rbp), %rcx
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x1b020(%rcx), %eax
jle 0x1384a
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x1b018, %rdi          # imm = 0x1B018
addq $0x1b020, %rsi          # imm = 0x1B020
movl -0xc(%rbp), %edx
callq 0x65c0
movq -0x18(%rbp), %rdi
callq 0x1cb50
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x1b018(%rax)
je 0x1386b
cmpl $0xf, -0xc(%rbp)
jl 0x1386b
movq -0x18(%rbp), %rax
cmpl $0xf, 0x1b020(%rax)
jge 0x13877
leaq 0x24f74(%rip), %rdi     # 0x387e6
callq 0x5720
jmp 0x13879
movq -0x18(%rbp), %rdi
movq 0x1b018(%rdi), %rax
addq $0xa, %rax
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq 0x1b018(%rdi), %rax
addq $0x5, %rax
movl -0xc(%rbp), %esi
callq *%rax
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl -0xc(%rbp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
cmpl $0x100, (%rax)          # imm = 0x100
jl 0x1395d
movq -0x18(%rbp), %rax
movq 0x808(%rax), %rdi
movl (%rax), %esi
subl $0x100, %esi            # imm = 0x100
callq 0x132c0
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
movl $0x1, (%rax)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x808(%rax), %rdi
addq $0x10, %rdi
movl $0x6, %esi
callq 0x30630
movq %rax, %rcx
movl -0x1c(%rbp), %eax
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x1395b
movq -0x18(%rbp), %rax
movq 0x808(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x30e60
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, 0x408(%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13900
jmp 0x139ae
movq -0x18(%rbp), %rax
cmpl $0x10, (%rax)
jl 0x1398c
movq -0x18(%rbp), %rax
cmpl $0x20, (%rax)
jge 0x1398c
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0xf, %ecx
shll $0x5, %ecx
movl -0xc(%rbp), %edx
shll $0x4, %edx
orl %edx, %ecx
orl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x139ac
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0x1f0, %ecx            # imm = 0x1F0
movl 0x4(%rax), %edx
andl $0xf, %edx
shll %edx
addl -0xc(%rbp), %edx
andl $0xf, %edx
orl %edx, %ecx
movl %ecx, 0x4(%rax)
jmp 0x139ae
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x0, 0x4(%rdi)
movl $0x0, (%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x8(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0xc(%rdi)
addq $0x10, %rdi
callq 0xeb50
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x3d49b113, -0x1c(%rbp) # imm = 0x3D49B113
movl $0x29eb7f93, -0x20(%rbp) # imm = 0x29EB7F93
movl $0x2614be13, -0x24(%rbp) # imm = 0x2614BE13
movl $0x3828eb13, -0x28(%rbp) # imm = 0x3828EB13
movq -0x38(%rbp), %rdi
addq $0xc0, %rdi
callq 0x30eb0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, %eax
je 0x13ecc
imull $0xc, -0x1c(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
imull $0x14, -0x20(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x20(%rbp)
imull $0x1c, -0x24(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
imull $0x2c, -0x28(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0xb16b88f1, -0x1c(%rbp) # imm = 0xB16B88F1
jne 0x13eca
cmpl $0xff5376f1, -0x20(%rbp) # imm = 0xFF5376F1
jne 0x13eca
cmpl $0x72ac5bf1, -0x24(%rbp) # imm = 0x72AC5BF1
jne 0x13eca
cmpl $0x2f909af1, -0x28(%rbp) # imm = 0x2F909AF1
jne 0x13eca
jmp 0x13ecc
jmp 0x13e64
cmpl $-0x1, -0x2c(%rbp)
jne 0x13edb
movb $0x0, -0x1(%rbp)
jmp 0x13fab
movq -0x38(%rbp), %rdi
addq $0xc0, %rdi
callq 0x30eb0
movl %eax, -0x2c(%rbp)
cmpl $0x1, %eax
je 0x13f05
cmpl $0x2, -0x2c(%rbp)
je 0x13f05
leaq 0x24250(%rip), %rdi     # 0x38150
callq 0x5720
movq -0x38(%rbp), %rdi
addq $0xc0, %rdi
callq 0x30eb0
cmpl $0x1, %eax
je 0x13f26
leaq 0x24246(%rip), %rdi     # 0x38167
callq 0x5720
movq -0x38(%rbp), %rdi
movq %rdi, %rsi
addq $0xc0, %rsi
callq 0xe7f0
cmpl $0x1, -0x2c(%rbp)
jne 0x13f77
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x30f70
cmpl $0x6, %eax
jle 0x13f77
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movl $0x6, %esi
callq 0x30630
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x13f77
leaq 0x2420c(%rip), %rdi     # 0x3817e
callq 0x5720
cmpq $0x0, -0x18(%rbp)
je 0x13f8f
movq -0x38(%rbp), %rdi
callq 0xf010
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
movl $0x1, 0x1b1f8(%rax)
movl $0x0, 0x1b1fc(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0xc0, %rdi
callq 0x30eb0
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x14043
jmp 0x13fef
movq -0x28(%rbp), %rdi
addq $0xc0, %rdi
callq 0x30eb0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x14014
leaq 0x2419a(%rip), %rdi     # 0x381a9
callq 0x5720
cmpl $0x0, -0x1c(%rbp)
jne 0x1402e
movq -0x28(%rbp), %rax
movl $0x2, 0x1b1f8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x14072
cmpq $0x0, -0x18(%rbp)
je 0x14041
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *(%rax)
jmp 0x13fef
cmpl $0xff, -0x1c(%rbp)
jne 0x14060
movq -0x28(%rbp), %rax
movl $0x0, 0x1b1f8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x14072
leaq 0x24151(%rip), %rdi     # 0x381b8
callq 0x5720
jmp 0x1406e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x3, 0x1b1f8(%rax)
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
callq 0x30eb0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x140c7
leaq 0x240e7(%rip), %rdi     # 0x381a9
callq 0x5720
cmpl $0x0, -0x14(%rbp)
jne 0x140cf
jmp 0x140e4
cmpq $0x0, -0x10(%rbp)
je 0x140e2
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *(%rax)
jmp 0x140a2
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
callq 0x30eb0
cmpl $0x0, %eax
je 0x14105
leaq 0x240d8(%rip), %rdi     # 0x381d8
callq 0x5720
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x2, 0x1b1fc(%rax)
jne 0x1413c
leaq 0x240b7(%rip), %rdi     # 0x381ee
callq 0x5720
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1b1fc(%rax)
jne 0x141ad
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
callq 0x134c0
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x1b128, %rax          # imm = 0x1B128
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
movl $0x4, %esi
callq 0x30630
movq -0x20(%rbp), %rdi
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
addq $0x10, %rdi
movl $0x5, %esi
callq 0x30630
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movzbl (%rax), %edx
callq 0x13b80
movq -0x20(%rbp), %rax
movl $0x1, 0x1b1fc(%rax)
jmp 0x141af
movq -0x20(%rbp), %rdi
addq $0x1b128, %rdi          # imm = 0x1B128
callq 0x30f90
andl $0x3, %eax
cmpl $0x1, %eax
je 0x141f1
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x1b128, %rax          # imm = 0x1B128
movq %rax, -0x38(%rbp)
addq $0xc0, %rdi
callq 0x13630
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x13bc0
jmp 0x141af
jmp 0x141f3
cmpl $0x0, -0x14(%rbp)
je 0x1424a
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
callq 0x13630
movq -0x20(%rbp), %rdi
movl %eax, -0x18(%rbp)
addq $0x1b128, %rdi          # imm = 0x1B128
movl -0x18(%rbp), %esi
callq 0x13bc0
cmpl $-0x1, -0x18(%rbp)
jne 0x14239
movq -0x20(%rbp), %rax
movl $0x4, 0x1b1f8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x1424e
cmpl $0x0, -0x14(%rbp)
jle 0x14248
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x141f3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3, 0x1b1f8(%rax)
jne 0x142ad
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
callq 0x139c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
movl $0x2, 0x1b1fc(%rax)
jmp 0x142cf
movq -0x20(%rbp), %rax
cmpl $0x4, 0x1b1f8(%rax)
jne 0x142cd
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
callq 0x30eb0
movl %eax, -0x14(%rbp)
jmp 0x142cf
movq -0x20(%rbp), %rax
movl $0x1, 0x1b1f8(%rax)
cmpl $0xfe, -0x14(%rbp)
jne 0x142f6
cmpq $0x0, -0x10(%rbp)
je 0x142f4
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x14361
cmpl $0xfd, -0x14(%rbp)
jne 0x14353
cmpq $0x0, -0x10(%rbp)
je 0x1430d
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movl $0x1, -0x18(%rbp)
cmpl $0x14, -0x18(%rbp)
jg 0x14351
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
callq 0x30eb0
movl %eax, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x14344
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x14346
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x14314
jmp 0x1435f
leaq 0x23eb8(%rip), %rdi     # 0x38212
callq 0x5720
jmp 0x14361
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x1b230, %rsp          # imm = 0x1B230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1b210(%rbp), %rdi
movq %rdi, -0x1b228(%rbp)
callq 0x30fa0
movq -0x1b228(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x31040
jmp 0x143a8
movq -0x10(%rbp), %rsi
leaq -0x1b210(%rbp), %rdi
callq 0x31060
jmp 0x143ba
jmp 0x143bc
xorl %eax, %eax
movl %eax, %esi
leaq -0x1b210(%rbp), %rdi
callq 0x13e30
movb %al, -0x1b229(%rbp)
jmp 0x143d4
movb -0x1b229(%rbp), %al
testb $0x1, %al
jne 0x143e3
jmp 0x14467
jmp 0x143e5
xorl %eax, %eax
movl %eax, %esi
leaq -0x1b210(%rbp), %rdi
callq 0x13fc0
movb %al, -0x1b22a(%rbp)
jmp 0x143fd
movb -0x1b22a(%rbp), %al
testb $0x1, %al
jne 0x14409
jmp 0x14462
xorl %eax, %eax
movl %eax, %esi
leaq -0x1b210(%rbp), %rdi
callq 0x14080
jmp 0x1441b
leaq -0x1b210(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14110
jmp 0x1442e
xorl %eax, %eax
movl %eax, %esi
leaq -0x1b210(%rbp), %rdi
callq 0x14260
jmp 0x14440
jmp 0x143e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b218(%rbp)
movl %eax, -0x1b21c(%rbp)
leaq -0x1b210(%rbp), %rdi
callq 0x31090
jmp 0x1447c
jmp 0x143bc
leaq -0x1b210(%rbp), %rdi
callq 0x31090
addq $0x1b230, %rsp          # imm = 0x1B230
popq %rbp
retq
movq -0x1b218(%rbp), %rdi
callq 0x5490
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x1, 0x8(%rdi)
movl $0xffffffff, 0xc(%rdi)  # imm = 0xFFFFFFFF
addq $0x10, %rdi
callq 0x119c0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x30bc0
testb $0x1, %al
jne 0x144ea
movq -0x10(%rbp), %rdi
movl $0x0, 0x8(%rdi)
addq $0x1b038, %rdi          # imm = 0x1B038
movl $0x10000, %esi          # imm = 0x10000
xorl %edx, %edx
callq 0x306d0
addq $0x10, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x20(%rbp)
movl 0x8(%rdx), %eax
movl 0xc(%rdx), %ecx
subl 0x8(%rdx), %ecx
movl %ecx, %ecx
movl -0x10(%rbp), %edx
imulq %rdx, %rcx
shrq $0x10, %rcx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x14537
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xc(%rax)
jmp 0x14544
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x14546
movq -0x20(%rbp), %rcx
movl 0xc(%rcx), %eax
xorl 0x8(%rcx), %eax
cmpl $0x1000000, %eax        # imm = 0x1000000
jae 0x1459a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl 0xc(%rax), %esi
shrl $0x18, %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
shll $0x8, %ecx
orl $0xff, %ecx
movl %ecx, 0xc(%rax)
movl 0x8(%rax), %ecx
shll $0x8, %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0x14546
addq $0x20, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
callq 0x30bc0
testb $0x1, %al
jne 0x145c9
jmp 0x1464f
cmpl $-0x1, -0xc(%rbp)
jne 0x145e1
movq -0x20(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x144f0
jmp 0x1464a
movq -0x20(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x144f0
movl $0x7, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x14648
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x137b0
movq -0x20(%rbp), %rdi
shll %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x144f0
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movl -0x18(%rbp), %esi
callq 0x13890
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x145f5
jmp 0x1464a
jmp 0x14756
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x14721
cmpl $0x0, -0xc(%rbp)
jl 0x1468a
movq -0x20(%rbp), %rdi
movl 0x8(%rdi), %eax
movq %rax, -0x28(%rbp)
addq $0x1b038, %rdi          # imm = 0x1B038
callq 0x310d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x14721
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl 0x8(%rax), %esi
shrl $0x18, %esi
andl $0xff, %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl 0x8(%rax), %esi
shrl $0x10, %esi
andl $0xff, %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl 0x8(%rax), %esi
shrl $0x8, %esi
andl $0xff, %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl 0x8(%rax), %esi
andl $0xff, %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x1b038, %rdi          # imm = 0x1B038
xorl %eax, %eax
movl %eax, %esi
callq 0x301d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
cmpl $0x0, -0xc(%rbp)
jl 0x14754
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movb %al, -0x31(%rbp)
movq %rcx, %rdi
addq $0x1b038, %rdi          # imm = 0x1B038
movl 0x8(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x8(%rcx)
movl %eax, %eax
movl %eax, %esi
callq 0x301d0
movb -0x31(%rbp), %cl
movb %cl, (%rax)
jmp 0x14756
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x1485a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x147a0
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x147cb
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl $0x1, %ecx
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
jmp 0x14845
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jle 0x147f3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0x147f3
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c(%rax)
jmp 0x14843
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jge 0x14819
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jg 0x14819
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
jmp 0x14841
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x1483f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jle 0x1483f
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
jmp 0x1485a
jmp 0x14841
jmp 0x14843
jmp 0x14845
jmp 0x14847
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x14774
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
jne 0x14872
leaq 0x23da4(%rip), %rdi     # 0x38611
callq 0x5720
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0x21(%rbp)
jle 0x148fa
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x28, %ecx
movb %al, -0x21(%rbp)
je 0x148fa
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x14903
jmp 0x14949
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x14880
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x14880
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
je 0x1492d
movb $0x0, -0x1(%rbp)
jmp 0x14986
jmp 0x1492f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x148cb
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x29(%rbp)
jne 0x1497e
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x2a(%rbp)
jle 0x14978
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl $0x80, %esi
xorl %edx, %edx
movl %edx, -0x64(%rbp)
callq 0x30190
movl -0x64(%rbp), %eax
movq -0x60(%rbp), %rdi
movl %eax, %esi
callq 0x301d0
movq %rax, -0x58(%rbp)
jmp 0x149ea
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x23c2d(%rip), %rsi     # 0x3862a
callq 0x54b0
movq -0x38(%rbp), %rdi
callq 0x5130
movl %eax, -0x48(%rbp)
movl $0xf4240, -0x4c(%rbp)   # imm = 0xF4240
cmpl $0x0, -0x4c(%rbp)
je 0x14a84
movq -0x70(%rbp), %rax
movl 0x28(%rax), %eax
cltd
idivl -0x4c(%rbp)
cmpl $0x0, %eax
je 0x14a72
movq -0x70(%rbp), %rax
movl 0x28(%rax), %eax
cltd
idivl -0x4c(%rbp)
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movq -0x38(%rbp), %rax
movl -0x48(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x48(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x14a72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x301f0
jmp 0x14b58
jmp 0x14a74
movl -0x4c(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4c(%rbp)
jmp 0x14a15
movq -0x38(%rbp), %rdi
leaq 0x23ba8(%rip), %rsi     # 0x38637
callq 0x54b0
movq -0x38(%rbp), %rdi
callq 0x5130
movl %eax, -0x50(%rbp)
xorl %eax, %eax
cmpl $0x28, -0x50(%rbp)
movb %al, -0x71(%rbp)
jge 0x14abe
movq -0x70(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
setg %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x14ac7
jmp 0x14af0
movq -0x70(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %dl
movq -0x38(%rbp), %rax
movslq -0x50(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x14aa0
movq -0x38(%rbp), %rdi
leaq 0x23b4b(%rip), %rsi     # 0x38646
callq 0x54b0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x28, %edx
callq 0x51a0
cmpq $0x0, -0x18(%rbp)
je 0x14b3b
movq -0x38(%rbp), %rdi
leaq 0x23b18(%rip), %rsi     # 0x3863c
callq 0x54b0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x14, %edx
callq 0x51a0
movq -0x38(%rbp), %rdi
callq 0x5720
jmp 0x14b46
leaq -0x30(%rbp), %rdi
callq 0x301f0
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x14760
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x14bd3
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x148b0
testb $0x1, %al
jne 0x14bbe
jmp 0x14bc6
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14bee
jmp 0x14bc8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14b94
movq -0x28(%rbp), %rdi
leaq 0x23a6b(%rip), %rsi     # 0x38649
xorl %eax, %eax
movl %eax, %edx
callq 0x149a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x14760
movq -0x20(%rbp), %rax
movl $0x0, -0x14(%rbp)
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x24, %eax
jne 0x14cf3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x31, %eax
jl 0x14cf3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x39, %eax
jg 0x14cf3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %eax
cmpl $0x2b, %eax
jne 0x14cc8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x3, %rdi
callq 0x5400
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x14cf1
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
movsbl 0x1(%rcx), %ecx
subl $0x31, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x14d47
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x14d20
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x14d31
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x14d31
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x5400
movl %eax, -0x14(%rbp)
jmp 0x14d45
movq -0x20(%rbp), %rdi
leaq 0x23918(%rip), %rsi     # 0x38654
xorl %eax, %eax
movl %eax, %edx
callq 0x149a0
jmp 0x14d47
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x14d63
movq -0x20(%rbp), %rdi
leaq 0x2390c(%rip), %rsi     # 0x38666
xorl %eax, %eax
movl %eax, %edx
callq 0x149a0
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x14d7f
movq -0x20(%rbp), %rdi
leaq 0x238ff(%rip), %rsi     # 0x38675
xorl %eax, %eax
movl %eax, %edx
callq 0x149a0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0x37, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0x6b, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0x53, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0x74, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0xa0, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0x31, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0x83, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0xd3, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0x8c, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0xb2, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0x28, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0xb0, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
movq (%rdi), %rax
movl $0xd3, %esi
callq *(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Compressor::startBlock(int)
void Compressor::startBlock(int level) {

  // Model 1 - min.cfg
  static const char models[]={
  26,0,1,2,0,0,2,3,16,8,19,0,0,96,4,28,
  59,10,59,112,25,10,59,10,59,112,56,0,

  // Model 2 - mid.cfg
  69,0,3,3,0,0,8,3,5,8,13,0,8,17,1,8,
  18,2,8,18,3,8,19,4,4,22,24,7,16,0,7,24,
  (char)-1,0,17,104,74,4,95,1,59,112,10,25,59,112,10,25,
  59,112,10,25,59,112,10,25,59,112,10,25,59,10,59,112,
  25,69,(char)-49,8,112,56,0,

  // Model 3 - max.cfg
  (char)-60,0,5,9,0,0,22,1,(char)-96,3,5,8,13,1,8,16,
  2,8,18,3,8,19,4,8,19,5,8,20,6,4,22,24,
  3,17,8,19,9,3,13,3,13,3,13,3,14,7,16,0,
  15,24,(char)-1,7,8,0,16,10,(char)-1,6,0,15,16,24,0,9,
  8,17,32,(char)-1,6,8,17,18,16,(char)-1,9,16,19,32,(char)-1,6,
  0,19,20,16,0,0,17,104,74,4,95,2,59,112,10,25,
  59,112,10,25,59,112,10,25,59,112,10,25,59,112,10,25,
  59,10,59,112,10,25,59,112,10,25,69,(char)-73,32,(char)-17,64,47,
  14,(char)-25,91,47,10,25,60,26,48,(char)-122,(char)-105,20,112,63,9,70,
  (char)-33,0,39,3,25,112,26,52,25,25,74,10,4,59,112,25,
  10,4,59,112,25,10,4,59,112,25,65,(char)-113,(char)-44,72,4,59,
  112,8,(char)-113,(char)-40,8,68,(char)-81,60,60,25,69,(char)-49,9,112,25,25,
  25,25,25,112,56,0,

  0,0}; // 0,0 = end of list

  if (level<1) error("compression level must be at least 1");
  const char* p=models;
  int i;
  for (i=1; i<level && toU16(p); ++i)
    p+=toU16(p)+2;
  if (toU16(p)<1) error("compression level too high");
  startBlock(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x15dc9
leaq 0x22968(%rip), %rdi     # 0x3872c
callq 0x5720
leaq 0x21740(%rip), %rax     # 0x37510
movq %rax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x29(%rbp)
jge 0x15dfa
movq -0x18(%rbp), %rdi
callq 0x64c0
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x15e03
jmp 0x15e2a
movq -0x18(%rbp), %rdi
callq 0x64c0
movl %eax, %ecx
addl $0x2, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15ddb
movq -0x18(%rbp), %rdi
callq 0x64c0
cmpl $0x1, %eax
jge 0x15e44
leaq 0x22912(%rip), %rdi     # 0x38751
callq 0x5720
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15e60
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)