LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: initTables::initArrays()
void initArrays() {
        // int64_t l3var1z;
        int64_t l3var2z;
        FcstCnt = 0;
        FcstTotal = 0;
        for (idx = 3; idx <= 6; ++idx) {
            l3var2z = idx - 2;
            for (jdx=1; jdx <= l3var2z; ++jdx)
                frameRestore[idx][jdx] = 0;
        }
        for (idx=1; idx <= 99; ++idx)
            helperMap[idx] = 0;
    }

// Assembly:
xorl %eax, %eax
movq %rax, 0x4a08f(%rip)     # 0x64840
movq %rax, 0x4a188(%rip)     # 0x64940
movq $0x3, (%rdi)
movl $0x3, %ecx
leaq 0x4e595(%rip), %rax     # 0x68d60
movq $0x1, 0x8(%rdi)
cmpq $0x3, %rcx
jl 0x1a806
addq $-0x2, %rcx
movl $0x1, %edx
movq (%rdi), %rsi
leaq (%rsi,%rsi,4), %rsi
leaq (%rax,%rsi,8), %rsi
movq $0x0, (%rsi,%rdx,8)
movq 0x8(%rdi), %rsi
leaq 0x1(%rsi), %rdx
movq %rdx, 0x8(%rdi)
cmpq %rcx, %rsi
jl 0x1a7e2
movq (%rdi), %rdx
leaq 0x1(%rdx), %rcx
movq %rcx, (%rdi)
cmpq $0x6, %rdx
jl 0x1a7cb
movq $0x1, (%rdi)
movl $0x1, %ecx
leaq 0x501b7(%rip), %rax     # 0x6a9e0
movq $0x0, (%rax,%rcx,8)
movq (%rdi), %rdx
leaq 0x1(%rdx), %rcx
movq %rcx, (%rdi)
cmpq $0x63, %rdx
jl 0x1a829
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: initTables::regResWord(long)
void regResWord(int64_t l4arg1z) {
        KeyWord * kw;
        Word l4var2z;
        curVal.ii = l4arg1z;
        curVal.i = (curVal.m.val % 65535) % 128;
        l4var2z.ii = l4arg1z;
        kw = new KeyWord;
        kw->w = l4var2z;
        kw->sym = SY;
        kw->op = charClass;
        kw->next = KeyWordHashTabBase[curVal.i];
        KeyWordHashTabBase[curVal.i] = kw;
        if (charClass == NOOP) {
            succ(SY);
        } else {
            succ(charClass);
        }
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rsi, 0x49d2b(%rip)     # 0x64a40
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rax
movabsq $0x1000100010002, %rcx  # imm = 0x1000100010002
mulq %rcx
leaq 0x49d0a(%rip), %rdi     # 0x64a40
addl %edx, %esi
andl $0x7f, %esi
callq 0x3bf2
movl $0x18, %edi
callq 0x3d03
movq %rbx, (%rax)
leaq 0x49ad8(%rip), %rcx     # 0x6482c
movl 0x49ad2(%rip), %edx     # 0x6482c
movl %edx, 0x8(%rax)
leaq 0x49ac4(%rip), %rsi     # 0x64828
movl 0x49abe(%rip), %edi     # 0x64828
movl %edi, 0xc(%rax)
movq 0x49ccc(%rip), %r8      # 0x64a40
shlq $0x17, %r8
sarq $0x17, %r8
leaq 0x4ec5d(%rip), %r9      # 0x699e0
movq (%r9,%r8,8), %r10
movq %r10, 0x10(%rax)
movq %rax, (%r9,%r8,8)
cmpl $0x2e, %edi
cmovel %edx, %edi
cmoveq %rcx, %rsi
incl %edi
movl %edi, (%rsi)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Reader::read(char*, int)
int Reader::read(char* buf, int n) {
  int i=0, c;
  while (i<n && (c=get())>=0)
    buf[i++]=c;
  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0x4f00
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
xorl %ebx, %ebx
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
testl %eax, %eax
js 0x4f02
movb %al, (%r14,%rbx)
incq %rbx
cmpq %rbx, %r12
jne 0x4ee3
movl %r12d, %ebx
jmp 0x4f02
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::allocx(unsigned char*&, int&, int)
void allocx(U8* &p, int &n, int newsize) {
#ifdef NOJIT
  p=0;
  n=0;
#else
  if (p || n) {
    if (p)
#ifdef unix
      munmap(p, n);
#else // Windows
      VirtualFree(p, 0, MEM_RELEASE);
#endif
    p=0;
    n=0;
  }
  if (newsize>0) {
#ifdef unix
    p=(U8*)mmap(0, newsize, PROT_READ|PROT_WRITE|PROT_EXEC,
                MAP_PRIVATE|MAP_ANON, -1, 0);
    if ((void*)p==MAP_FAILED) p=0;
#else
    p=(U8*)VirtualAlloc(0, newsize, MEM_RESERVE|MEM_COMMIT,
                        PAGE_EXECUTE_READWRITE);
#endif
    if (p)
      n=newsize;
    else {
      n=0;
      error("allocx failed");
    }
  }
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
sete %cl
movl (%rsi), %eax
testl %eax, %eax
sete %dl
testb %dl, %cl
jne 0x4f86
testq %rdi, %rdi
je 0x4f79
movslq %eax, %rsi
callq 0x40f0
movq $0x0, (%r14)
movl $0x0, (%rbx)
testl %ebp, %ebp
jle 0x4fbb
movl %ebp, %esi
xorl %r15d, %r15d
xorl %edi, %edi
movl $0x7, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x4320
cmpq $-0x1, %rax
cmoveq %r15, %rax
movq %rax, (%r14)
testq %rax, %rax
je 0x4fc6
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, (%rbx)
leaq 0x49dbd(%rip), %rdi     # 0x4ed90
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x455c
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::SHA1::init()
void SHA1::init() {
  len=0;
  h[0]=0x67452301;
  h[1]=0xEFCDAB89;
  h[2]=0x98BADCFE;
  h[3]=0x10325476;
  h[4]=0xC3D2E1F0;
  memset(w, 0, sizeof(w));
}

// Assembly:
movq $0x0, (%rdi)
movaps 0x46290(%rip), %xmm0    # 0x4b280
movups %xmm0, 0x8(%rdi)
movl $0xc3d2e1f0, 0x18(%rdi) # imm = 0xC3D2E1F0
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rdi)
movups %xmm0, 0x2c(%rdi)
movups %xmm0, 0x3c(%rdi)
movups %xmm0, 0x4c(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::SHA1::result()
const char* SHA1::result() {

  // pad and append length
  const U64 s=len;
  put(0x80);
  while ((len&511)!=448)
    put(0);
  put(s>>56);
  put(s>>48);
  put(s>>40);
  put(s>>32);
  put(s>>24);
  put(s>>16);
  put(s>>8);
  put(s);

  // copy h to hbuf
  for (int i=0; i<5; ++i) {
    hbuf[4*i]=h[i]>>24;
    hbuf[4*i+1]=h[i]>>16;
    hbuf[4*i+2]=h[i]>>8;
    hbuf[4*i+3]=h[i];
  }

  // return hash prior to clearing state
  init();
  return hbuf;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movl $0x80, %esi
callq 0x49fd2
movl $0x1ff, %ebp            # imm = 0x1FF
movl (%rbx), %eax
andl %ebp, %eax
cmpl $0x1c0, %eax            # imm = 0x1C0
je 0x5040
movq %rbx, %rdi
xorl %esi, %esi
callq 0x49fd2
jmp 0x5029
movq %r14, %rsi
shrq $0x38, %rsi
movq %rbx, %rdi
callq 0x49fd2
movq %r14, %rsi
shrq $0x30, %rsi
movq %rbx, %rdi
callq 0x49fd2
movq %r14, %rsi
shrq $0x28, %rsi
movq %rbx, %rdi
callq 0x49fd2
movq %r14, %rsi
shrq $0x20, %rsi
movq %rbx, %rdi
callq 0x49fd2
movq %r14, %rsi
shrq $0x18, %rsi
movq %rbx, %rdi
callq 0x49fd2
movq %r14, %rsi
shrq $0x10, %rsi
movq %rbx, %rdi
callq 0x49fd2
movq %r14, %rsi
shrq $0x8, %rsi
movq %rbx, %rdi
callq 0x49fd2
movq %rbx, %rdi
movl %r14d, %esi
callq 0x49fd2
movl $0x5f, %eax
movl -0x57(%rbx,%rax), %ecx
bswapl %ecx
movl %ecx, -0x3(%rbx,%rax)
addq $0x4, %rax
cmpq $0x73, %rax
jne 0x50b9
movq $0x0, (%rbx)
movaps 0x461a5(%rip), %xmm0    # 0x4b280
movups %xmm0, 0x8(%rbx)
movl $0xc3d2e1f0, 0x18(%rbx) # imm = 0xC3D2E1F0
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rbx)
movups %xmm0, 0x2c(%rbx)
movups %xmm0, 0x3c(%rbx)
movups %xmm0, 0x4c(%rbx)
addq $0x5c, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::SHA1::write(char const*, long)
void SHA1::write(const char* buf, int64_t n) {
  const unsigned char* p=(const unsigned char*) buf;
  for (; n>0 && (U32(len)&511)!=0; --n) put(*p++);
  for (; n>=64; n-=64) {
    for (int i=0; i<16; ++i)
      w[i]=p[0]<<24|p[1]<<16|p[2]<<8|p[3], p+=4;
    len+=512;
    process();
  }
  for (; n>0; --n) put(*p++);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
jle 0x5148
movzwl (%rbx), %eax
testl $0x1ff, %eax            # imm = 0x1FF
je 0x5148
movzbl (%r14), %esi
incq %r14
movq %rbx, %rdi
callq 0x49fd2
leaq -0x1(%r15), %rax
cmpq $0x1, %r15
movq %rax, %r15
jg 0x511f
xorl %r15d, %r15d
cmpq $0x40, %r15
jl 0x5192
movq %r14, %r13
xorl %ebp, %ebp
movl (%r13,%rbp), %eax
bswapl %eax
movl %eax, 0x1c(%rbx,%rbp)
addq $0x4, %rbp
cmpq $0x40, %rbp
jne 0x5153
addq $0x200, (%rbx)          # imm = 0x200
movq %rbx, %rdi
callq 0x51c4
leaq -0x40(%r15), %r12
movq %r13, %r14
addq %rbp, %r14
cmpq $0x7f, %r15
movq %r12, %r15
jg 0x514e
addq %rbp, %r13
movq %r13, %r14
jmp 0x5195
movq %r15, %r12
testq %r12, %r12
jle 0x51b5
incq %r12
movzbl (%r14), %esi
incq %r14
movq %rbx, %rdi
callq 0x49fd2
decq %r12
cmpq $0x1, %r12
jg 0x519d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::SHA256::init()
void SHA256::init() {
  len0=len1=0;
  s[0]=0x6a09e667;
  s[1]=0xbb67ae85;
  s[2]=0x3c6ef372;
  s[3]=0xa54ff53a;
  s[4]=0x510e527f;
  s[5]=0x9b05688c;
  s[6]=0x1f83d9ab;
  s[7]=0x5be0cd19;
  memset(w, 0, sizeof(w));
}

// Assembly:
movaps 0x44e67(%rip), %xmm0    # 0x4b290
movups %xmm0, (%rdi)
movaps 0x44e6d(%rip), %xmm0    # 0x4b2a0
movups %xmm0, 0x10(%rdi)
movabsq $0x5be0cd191f83d9ab, %rax # imm = 0x5BE0CD191F83D9AB
movq %rax, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::SHA256::result()
const char* SHA256::result() {

  // pad and append length
  const unsigned s1=len1, s0=len0;
  put(0x80);
  while ((len0&511)!=448) put(0);
  put(s1>>24);
  put(s1>>16);
  put(s1>>8);
  put(s1);
  put(s0>>24);
  put(s0>>16);
  put(s0>>8);
  put(s0);

  // copy s to hbuf
  for (int i=0; i<8; ++i) {
    hbuf[4*i]=s[i]>>24;
    hbuf[4*i+1]=s[i]>>16;
    hbuf[4*i+2]=s[i]>>8;
    hbuf[4*i+3]=s[i];
  }

  // return hash prior to clearing state
  init();
  return hbuf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
movl 0x4(%rdi), %r14d
movl $0x80, %esi
callq 0x4a002
movl $0x1ff, %r15d           # imm = 0x1FF
movl (%rbx), %eax
andl %r15d, %eax
cmpl $0x1c0, %eax            # imm = 0x1C0
je 0x88ba
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4a002
jmp 0x88a2
movl %r14d, %esi
shrl $0x18, %esi
movq %rbx, %rdi
callq 0x4a002
movl %r14d, %esi
shrl $0x10, %esi
movq %rbx, %rdi
callq 0x4a002
movl %r14d, %esi
shrl $0x8, %esi
movq %rbx, %rdi
callq 0x4a002
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4a002
movl %ebp, %esi
shrl $0x18, %esi
movq %rbx, %rdi
callq 0x4a002
movl %ebp, %esi
shrl $0x10, %esi
movq %rbx, %rdi
callq 0x4a002
movl %ebp, %esi
shrl $0x8, %esi
movq %rbx, %rdi
callq 0x4a002
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4a002
movl $0x6b, %eax
movl -0x63(%rbx,%rax), %ecx
bswapl %ecx
movl %ecx, -0x3(%rbx,%rax)
addq $0x4, %rax
cmpq $0x8b, %rax
jne 0x8925
movaps 0x4294e(%rip), %xmm0    # 0x4b290
movups %xmm0, (%rbx)
movaps 0x42954(%rip), %xmm0    # 0x4b2a0
movups %xmm0, 0x10(%rbx)
movabsq $0x5be0cd191f83d9ab, %rax # imm = 0x5BE0CD191F83D9AB
movq %rax, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
addq $0x68, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::AES_CTR::encrypt(char*, int, unsigned long)
void AES_CTR::encrypt(char* buf, int n, U64 offset) {
  for (U64 i=offset/16; i<=(offset+n)/16; ++i) {
    unsigned char ct[16];
    encrypt(iv0, iv1, i>>32, i, ct);
    for (int j=0; j<16; ++j) {
      const int k=i*16-offset+j;
      if (k>=0 && k<n)
        buf[k]^=ct[j];
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
shrq $0x4, %r13
movslq %edx, %rbp
addq %rcx, %rbp
shrq $0x4, %rbp
cmpq %rbp, %r13
ja 0x9219
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %r13d, %r12d
shll $0x4, %r12d
subl %ecx, %r12d
movl 0x14f4(%r15), %esi
movl 0x14f8(%r15), %edx
movq %r13, %rcx
shrq $0x20, %rcx
movq %r15, %rdi
movl %r13d, %r8d
movq %rsp, %r9
callq 0x8df8
xorl %eax, %eax
leaq (%r12,%rax), %rcx
testl %ecx, %ecx
sets %dl
cmpl %ebx, %ecx
setge %sil
orb %dl, %sil
jne 0x9200
movb (%rsp,%rax), %dl
movl %ecx, %ecx
xorb %dl, (%r14,%rcx)
incq %rax
cmpq $0x10, %rax
jne 0x91e3
leaq 0x1(%r13), %rax
addq $0x10, %r12
cmpq %rbp, %r13
movq %rax, %r13
jne 0x91be
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::random(char*, int)
void random(char* buf, int n) {
#ifdef unix
  FILE* in=fopen("/dev/urandom", "rb");
  if (in && int(fread(buf, 1, n, in))==n)
    fclose(in);
  else {
    error("key generation failed");
  }
#else
  HCRYPTPROV h;
  if (CryptAcquireContext(&h, NULL, NULL, PROV_RSA_FULL,
      CRYPT_VERIFYCONTEXT) && CryptGenRandom(h, n, (BYTE*)buf))
    CryptReleaseContext(h, 0);
  else {
    fprintf(stderr, "CryptGenRandom: error %d\n", int(GetLastError()));
    error("key generation failed");
  }
#endif
  if (n>=1 && (buf[0]=='z' || buf[0]=='7'))
    buf[0]^=0x80;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x455fd(%rip), %rdi     # 0x4ed9e
leaq 0x45603(%rip), %rsi     # 0x4edab
callq 0x41f0
testq %rax, %rax
je 0x97da
movq %rax, %r14
movslq %ebp, %r15
movl $0x1, %esi
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x4270
cmpl %r15d, %eax
jne 0x97da
movq %r14, %rdi
callq 0x4160
jmp 0x97e6
leaq 0x455cd(%rip), %rdi     # 0x4edae
callq 0x455c
testl %ebp, %ebp
jle 0x97fb
movzbl (%rbx), %eax
cmpl $0x7a, %eax
je 0x97f7
cmpl $0x37, %eax
jne 0x97fb
addb $-0x80, %al
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Component::init()
void Component::init() {
  limit=cxt=a=b=c=0;
  cm.resize(0);
  ht.resize(0);
  a16.resize(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x28, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x20(%rbx)
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a048
leaq 0x40(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a126
addq $0x58, %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
jmp 0x4a1f4
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::ZPAQL::clear()
void ZPAQL::clear() {
  cend=hbegin=hend=0;  // COMP and HCOMP locations
  a=b=c=d=f=pc=0;      // machine state
  header.resize(0);
  h.resize(0);
  m.resize(0);
  r.resize(0);
  allocx(rcode, rcode_size, 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x30(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
addq $0x10, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x9c(%rbx)
movq %rax, 0xac(%rbx)
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a126
leaq 0x50(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a048
leaq 0x38(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a126
leaq 0x68(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a048
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
sete %cl
movl 0xb4(%rbx), %eax
testl %eax, %eax
sete %dl
testb %dl, %cl
jne 0x9be8
testq %rdi, %rdi
je 0x9bd3
movslq %eax, %rsi
callq 0x40f0
movq $0x0, 0xb8(%rbx)
movl $0x0, 0xb4(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::ZPAQL::ZPAQL()
ZPAQL::ZPAQL() {
  output=0;
  sha1=0;
  rcode=0;
  rcode_size=0;
  clear();
  outbuf.resize(1<<14);
  bufptr=0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x10(%rdi), %rbx
xorl %r15d, %r15d
movl %r15d, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a126
leaq 0x38(%r12), %r14
movl %r15d, 0x48(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r12)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a126
leaq 0x50(%r12), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r12)
movl $0x0, 0x60(%r12)
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a048
leaq 0x68(%r12), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r12)
movl $0x0, 0x78(%r12)
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a048
leaq 0x80(%r12), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%r12)
movl $0x0, 0x90(%r12)
movq %rbp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a2d2
movq $0x0, 0xb8(%r12)
movl $0x0, 0xb4(%r12)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq %r12, %rdi
callq 0x9b54
movl $0x4000, %esi           # imm = 0x4000
movq %rbp, %rdi
xorl %edx, %edx
callq 0x4a2d2
movl $0x0, 0x98(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x9d18
movq %rax, %r12
jmp 0x9d20
movq %rax, %r12
jmp 0x9d28
movq %rax, %r12
jmp 0x9d30
movq %rax, %r12
movq %rbp, %rdi
callq 0x4a034
movq %r13, %rdi
callq 0x4a3a0
movq %r15, %rdi
callq 0x4a3a0
movq %r14, %rdi
callq 0x4a3b4
movq %rbx, %rdi
callq 0x4a3b4
movq %r12, %rdi
callq 0x4310
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x21, %esi
jl 0x9de5
leaq 0x45059(%rip), %rdi     # 0x4ee39
callq 0x455c
cmpl $0x21, %ebp
jl 0x9df6
leaq 0x45052(%rip), %rdi     # 0x4ee43
callq 0x455c
leaq 0x50(%rbx), %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x4a048
leaq 0x38(%rbx), %rdi
movl $0x1, %esi
movl %ebp, %edx
callq 0x4a126
leaq 0x68(%rbx), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x4a048
xorps %xmm0, %xmm0
movups %xmm0, 0x9c(%rbx)
movq $0x0, 0xac(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa088
testl %eax, %eax
jne 0xa079
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a40a
addq $0x70, %r15
cmpq $0x7000, %r15           # imm = 0x7000
jne 0xb142
leaq 0x1ac14(%rbx), %rdi
leaq 0x40d5a(%rip), %rsi     # 0x4bec0
movl $0x400, %edx            # imm = 0x400
callq 0x4140
movq $0x0, 0x1b018(%rbx)
movl $0x0, 0x1b020(%rbx)
movb $0x0, 0x7810(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
testq %r15, %r15
je 0xb1b0
addq $0x7a0, %rbx            # imm = 0x7A0
leaq (%rbx,%r15), %rdi
callq 0x4a4b0
addq $-0x70, %r15
jne 0xb1a1
movq %r14, %rdi
callq 0x4310
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbc92
retq
movq %rax, %rdi
xorq $0x10, %rdi
cmpb %dl, (%rcx,%rdi)
jne 0xbca2
movq %rdi, %rax
retq
movq %rax, %r8
xorq $0x20, %r8
cmpb %dl, (%rcx,%r8)
jne 0xbcb3
movq %r8, %rax
retq
movb 0x1(%rcx,%rax), %r9b
movb 0x1(%rcx,%rdi), %r10b
cmpb %r10b, %r9b
ja 0xbcc9
cmpb 0x1(%rcx,%r8), %r9b
jbe 0xbce3
leaq (%rcx,%rdi), %rax
leaq (%rcx,%r8), %r9
cmpb 0x1(%rcx,%r8), %r10b
cmovbq %rax, %r9
cmovbq %rdi, %r8
movq %r8, %rax
jmp 0xbce9
addq %rax, %rcx
movq %rcx, %r9
xorps %xmm0, %xmm0
movups %xmm0, (%r9)
movq (%rsi), %rcx
movb %dl, (%rcx,%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0xb8(%rdi)
jne 0xc27b
leaq 0xb8(%rbx), %r15
leaq 0xb4(%rbx), %r14
movl 0x30(%rbx), %eax
addl %eax, %eax
leal (%rax,%rax,4), %edx
andl $0xfffff000, %edx       # imm = 0xFFFFF000
addl $0x1000, %edx           # imm = 0x1000
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f49
movq %rbx, %rdi
callq 0x10940
cmpl 0xb4(%rbx), %eax
jle 0xc25e
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x4f49
movq %rbx, %rdi
callq 0x10940
cmpl $0xa, %eax
jl 0xc26f
cmpq $0x0, (%r15)
je 0xc26f
cmpl $0x9, (%r14)
jg 0xc27b
leaq 0x43417(%rip), %rdi     # 0x4f68d
callq 0x455c
movl %ebp, 0x9c(%rbx)
callq *0xb8(%rbx)
cmpl $0x3, %eax
ja 0xc2c4
movl %eax, %eax
leaq 0x3f533(%rip), %rcx     # 0x4b7c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x433fd(%rip), %rdi     # 0x4f6ad
jmp 0xc2cb
leaq 0x43402(%rip), %rdi     # 0x4f6bb
jmp 0xc2cb
leaq 0x433da(%rip), %rdi     # 0x4f69c
jmp 0xc2cb
leaq 0x42b82(%rip), %rdi     # 0x4ee4d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x455c
// File: /workspace/github_cpp_makefile_star2_O1/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), %eax
cmpl 0x10(%rdi), %eax
jb 0xc3a3
cmpl 0x14(%rbx), %eax
jbe 0xc3af
leaq 0x42c06(%rip), %rdi     # 0x4efb0
callq 0x455c
movl 0x10(%rbx), %ecx
movl 0x14(%rbx), %edx
subl %ecx, %edx
movl %ebp, %eax
imulq %rdx, %rax
shrq $0x10, %rax
addl %ecx, %eax
cmpl %eax, 0x18(%rbx)
jbe 0xc3d1
incl %eax
movl %eax, 0x10(%rbx)
xorl %ebp, %ebp
jmp 0xc3d9
movl %eax, 0x14(%rbx)
movl $0x1, %ebp
movl 0x10(%rbx), %eax
movl 0x14(%rbx), %ecx
movl %eax, %edx
xorl %ecx, %edx
cmpl $0xffffff, %edx         # imm = 0xFFFFFF
ja 0xc440
leaq 0x429d2(%rip), %r14     # 0x4edc4
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 0xc422
movq %r14, %rdi
callq 0x455c
movl 0x18(%rbx), %eax
shll $0x8, %eax
orl %r15d, %eax
movl %eax, 0x18(%rbx)
movl 0x10(%rbx), %eax
movl 0x14(%rbx), %ecx
movl %eax, %edx
xorl %ecx, %edx
cmpl $0x1000000, %edx        # imm = 0x1000000
jb 0xc3f2
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::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), %eax
je 0xc4bb
testl %eax, %eax
jne 0xc48f
movl $0x4, %ebp
movl 0x18(%rbx), %r14d
shll $0x8, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
orl %r14d, %eax
movl %eax, 0x18(%rbx)
decl %ebp
jne 0xc475
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc38a
testl %eax, %eax
je 0xc4f9
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $0x0, 0x18(%rbx)
je 0xc538
leaq 0x42b0e(%rip), %rdi     # 0x4efc2
callq 0x455c
jmp 0xc538
testl %eax, %eax
jne 0xc4e4
movl $0x4, %ebp
movl 0x18(%rbx), %r14d
shll $0x8, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
orl %r14d, %eax
movl %eax, 0x18(%rbx)
decl %ebp
jne 0xc4c4
cmpl $0x0, 0x18(%rbx)
je 0xc546
decl 0x18(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
leaq 0x28(%rbx), %r15
movl $0x1, %r14d
movq %r15, %rdi
callq 0xc54e
leal 0x1(,%rax,2), %esi
movq %rbx, %rdi
callq 0xc38a
leal (%rax,%r14,2), %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0xc5e8
cmpl $0x100, %r14d           # imm = 0x100
jl 0xc503
addl $0xffffff00, %r14d      # imm = 0xFFFFFF00
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0xc538
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x1b018(%rdi)
jne 0xc5d2
leaq 0x1b018(%rbx), %r15
leaq 0x1b020(%rbx), %r14
movq 0x808(%rbx), %rax
imull $0x64, 0x28(%rax), %edx
andl $0xfffff000, %edx       # imm = 0xFFFFF000
addl $0x1000, %edx           # imm = 0x1000
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f49
movq %rbx, %rdi
callq 0x14688
cmpl 0x1b020(%rbx), %eax
jle 0xc5b5
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x4f49
movq %rbx, %rdi
callq 0x14688
cmpl $0xf, %eax
jl 0xc5c6
cmpq $0x0, (%r15)
je 0xc5c6
cmpl $0xe, (%r14)
jg 0xc5d2
leaq 0x430c0(%rip), %rdi     # 0x4f68d
callq 0x455c
movq 0x1b018(%rbx), %rax
addq $0xa, %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc66c
movq 0x808(%rbx), %rdi
addl $0xffffff00, %esi       # imm = 0xFFFFFF00
callq 0xc1f6
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%rbx)
movq 0x808(%rbx), %rsi
movq 0x10(%rsi), %rax
cmpb $0x0, 0x6(%rax)
je 0xc6a0
movq 0x50(%rsi), %rcx
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
addq 0x58(%rsi), %rdx
xorl %esi, %esi
movq %rdx, %rdi
andq %rsi, %rdi
movl (%rcx,%rdi,4), %edi
movl %edi, 0x408(%rbx,%rsi,4)
incq %rsi
movzbl 0x6(%rax), %edi
cmpq %rdi, %rsi
jb 0xc64e
jmp 0xc6a0
andl $-0x10, %esi
movl 0x4(%rbx), %eax
cmpl $0x10, %esi
jne 0xc689
andl $0xf, %eax
shll $0x5, %eax
shll $0x4, %r14d
orl %eax, %r14d
incl %r14d
jmp 0xc69c
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
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x830(%rdi), %rax
movq 0x10(%rax), %rax
cmpb $0x0, 0x6(%rax)
movl 0x18(%rdi), %ecx
je 0xc707
testl %ecx, %ecx
jne 0xc6d5
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl %eax, 0x18(%rbx)
testl %eax, %eax
je 0xc6c6
cmpl $0x0, 0x18(%rbx)
je 0xc6f4
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testl %eax, %eax
js 0xc6f4
movl 0x18(%rbx), %ecx
shll $0x8, %ecx
orl %eax, %ecx
movl %ecx, 0x18(%rbx)
jne 0xc6db
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testl %eax, %eax
je 0xc6f4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0xc730
movl $0x4, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testl %eax, %eax
js 0xc730
movl 0x18(%rbx), %ecx
shll $0x8, %ecx
orl %eax, %ecx
movl %ecx, 0x18(%rbx)
decl %ebp
jne 0xc715
cmpl $0x0, 0x18(%rbx)
je 0xc772
movl 0x18(%rbx), %eax
testl %eax, %eax
je 0xc750
decl %eax
movl %eax, 0x18(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testl %eax, %eax
jns 0xc736
jmp 0xc784
movl $0x4, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testl %eax, %eax
js 0xc730
movl 0x18(%rbx), %ecx
shll $0x8, %ecx
orl %eax, %ecx
movl %ecx, 0x18(%rbx)
decl %ebp
jne 0xc755
jmp 0xc730
testl %eax, %eax
js 0xc700
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *(%rax)
leaq 0x4284e(%rip), %rdi     # 0x4efd9
callq 0x455c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xc700
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq $0x0, (%rdi)
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
addq $0x10, %rdi
jmp 0x9b54
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0xc0(%rdi), %r12
movl $0x3828eb13, %ebp       # imm = 0x3828EB13
movl $0x2614be13, %r13d      # imm = 0x2614BE13
movl $0x29eb7f93, %r14d      # imm = 0x29EB7F93
movl $0x3d49b113, %ebx       # imm = 0x3D49B113
movq %r12, %rdi
callq 0x4a4d4
movl %eax, %r15d
cmpl $-0x1, %eax
je 0xc9ce
leal (%rbx,%rbx,2), %eax
leal (%r15,%rax,4), %ebx
leal (%r14,%r14,4), %eax
leal (%r15,%rax,4), %r14d
leal (%r13,%r13,8), %eax
leal (%rax,%rax,2), %eax
addl %r15d, %r13d
addl %eax, %r13d
imull $0x2c, %ebp, %ebp
addl %r15d, %ebp
cmpl $0xb16b88f1, %ebx       # imm = 0xB16B88F1
jne 0xc979
cmpl $0xff5376f1, %r14d      # imm = 0xFF5376F1
jne 0xc979
cmpl $0x72ac5bf1, %r13d      # imm = 0x72AC5BF1
jne 0xc979
cmpl $0x2f909af1, %ebp       # imm = 0x2F909AF1
jne 0xc979
cmpl $-0x1, %r15d
je 0xca65
movq %r12, %rdi
callq 0x4a4d4
movl %eax, %r13d
leal -0x3(%r13), %eax
cmpl $-0x3, %eax
ja 0xc9f8
leaq 0x4262d(%rip), %rdi     # 0x4f020
callq 0x455c
movq %r12, %rdi
callq 0x4a4d4
cmpl $0x1, %eax
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r14
je 0xca1b
leaq 0x42621(%rip), %rdi     # 0x4f037
callq 0x455c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9904
cmpl $0x1, %r13d
jne 0xca48
cmpl $0x7, 0x18(%rbx)
jl 0xca48
movq 0x10(%rbx), %rax
cmpb $0x0, 0x6(%rax)
jne 0xca48
leaq 0x4260b(%rip), %rdi     # 0x4f04e
callq 0x455c
testq %r14, %r14
je 0xca5a
movq %rbx, %rdi
callq 0x9e9c
movsd %xmm0, (%r14)
movq $0x1, 0x1b1f8(%rbx)
cmpl $-0x1, %r15d
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a4d4
movl %eax, %ebx
cmpl $0x1, %eax
jne 0xcae5
leaq 0x425cf(%rip), %r13     # 0x4f079
movq %r12, %rdi
callq 0x4a4d4
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xcabf
testl %ebp, %ebp
jne 0xcac7
jmp 0xcad8
movq %r13, %rdi
callq 0x455c
testq %r15, %r15
je 0xcaaa
movq (%r15), %rax
movq %r15, %rdi
movl %ebp, %esi
callq *(%rax)
jmp 0xcaaa
movl $0x2, 0x1b1f8(%r14)
jmp 0xcb06
cmpl $0xff, %ebx
jne 0xcafa
movl $0x0, 0x1b1f8(%r14)
jmp 0xcb06
leaq 0x42587(%rip), %rdi     # 0x4f088
callq 0x455c
cmpl $0x1, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42538(%rip), %r15     # 0x4f079
movq %rbx, %rdi
callq 0x4a4d4
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xcb56
testl %ebp, %ebp
jne 0xcb5e
jmp 0xcb6f
movq %r15, %rdi
callq 0x455c
testq %r14, %r14
je 0xcb41
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
callq *(%rax)
jmp 0xcb41
movq %rbx, %rdi
callq 0x4a4d4
testl %eax, %eax
je 0xcb91
leaq 0x42526(%rip), %rdi     # 0x4f0a8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x455c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x2, 0x1b1fc(%rdi)
jne 0xcbc1
leaq 0x42502(%rip), %rdi     # 0x4f0be
callq 0x455c
cmpl $0x0, 0x1b1fc(%rbx)
jne 0xcc0f
leaq 0xc0(%rbx), %rdi
callq 0xc34e
movq 0x10(%rbx), %rax
movzbl 0x4(%rax), %ecx
movzbl 0x5(%rax), %eax
movq $0x0, 0x1b128(%rbx)
movl %ecx, 0x1b130(%rbx)
movl %eax, 0x1b134(%rbx)
leaq 0x1b138(%rbx), %rdi
callq 0x9b54
movl $0x1, 0x1b1fc(%rbx)
leaq 0x1b128(%rbx), %r14
movl 0x1b128(%rbx), %eax
andl $0x3, %eax
cmpl $0x1, %eax
je 0xcc48
leaq 0xc0(%rbx), %r15
movq %r15, %rdi
callq 0xc44e
movq %r14, %rdi
movl %eax, %esi
callq 0xc7b0
movl (%r14), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xcc2b
leaq 0xc0(%rbx), %r15
movl %ebp, %r13d
testl %ebp, %ebp
je 0xcc93
movq %r15, %rdi
callq 0xc44e
movl %eax, %r12d
movq %r14, %rdi
movl %eax, %esi
callq 0xc7b0
cmpl $-0x1, %r12d
je 0xcc80
xorl %eax, %eax
testl %r13d, %r13d
setg %al
movl %r13d, %ebp
subl %eax, %ebp
jmp 0xcc8d
movl $0x4, 0x1b1f8(%rbx)
movl %r13d, %ebp
cmpl $-0x1, %r12d
jne 0xcc4f
testl %r13d, %r13d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::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), %ecx
cmpl $0x4, %ecx
je 0xccde
xorl %eax, %eax
cmpl $0x3, %ecx
jne 0xccea
leaq 0xc0(%r14), %rdi
callq 0xc6a8
movl $0x2, 0x1b1fc(%r14)
jmp 0xccea
leaq 0xc0(%r14), %rdi
callq 0x4a4d4
movl $0x1, 0x1b1f8(%r14)
cmpl $0xfd, %eax
je 0xcd0d
cmpl $0xfe, %eax
jne 0xcd42
testq %rbx, %rbx
je 0xcd3c
movb $0x0, (%rbx)
jmp 0xcd3c
testq %rbx, %rbx
je 0xcd15
movb $0x1, (%rbx)
addq $0xc0, %r14
movl $0x1, %r15d
movq %r14, %rdi
callq 0x4a4d4
testq %rbx, %rbx
je 0xcd33
movb %al, (%rbx,%r15)
incq %r15
cmpq $0x15, %r15
jne 0xcd22
popq %rbx
popq %r14
popq %r15
retq
leaq 0x42399(%rip), %rdi     # 0x4f0e2
popq %rbx
popq %r14
popq %r15
jmp 0x455c
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x1b200, %rsp          # imm = 0x1B200
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4a52a
movq %r14, 0xc8(%rbx)
leaq 0x1b138(%rsp), %r14
movq %r15, (%r14)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc944
testb %al, %al
je 0xcdc1
movq %rbx, %rdi
xorl %esi, %esi
callq 0xca7c
testb %al, %al
je 0xcd82
movq %rbx, %rdi
xorl %esi, %esi
callq 0xcb1c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xcb9c
movq %rbx, %rdi
xorl %esi, %esi
callq 0xcca8
jmp 0xcd90
movq %r14, %rdi
callq 0x9d40
leaq 0x49dd8(%rip), %rax     # 0x56ba8
leaq 0x1b110(%rsp), %rdi
movq %rax, -0x1b050(%rdi)
callq 0x4a034
leaq 0xe8(%rsp), %rdi
callq 0xb1b8
movq %rsp, %rdi
callq 0x9d40
addq $0x1b200, %rsp          # imm = 0x1B200
popq %rbx
popq %r14
popq %r15
retq
jmp 0xce08
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4a5ac
movq %rbx, %rdi
callq 0x4310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb238
movq 0x818(%rbx), %rax
movq 0x10(%rax), %rax
cmpb $0x0, 0x6(%rax)
je 0xce4a
popq %rbx
retq
movl $0x0, 0x8(%rbx)
addq $0x1b038, %rbx          # imm = 0x1B038
movl $0x10000, %esi          # imm = 0x10000
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
jmp 0x4a2d2
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edi
subl %ecx, %edi
movl %edx, %eax
imulq %rdi, %rax
shrq $0x10, %rax
addl %ecx, %eax
testl %esi, %esi
je 0xce89
movl %eax, 0xc(%rbx)
jmp 0xce8e
incl %eax
movl %eax, 0x8(%rbx)
movl 0xc(%rbx), %esi
movl 0x8(%rbx), %eax
xorl %esi, %eax
cmpl $0xffffff, %eax         # imm = 0xFFFFFF
ja 0xced0
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, %eax
cmpl $0x1000000, %eax        # imm = 0x1000000
jb 0xce9d
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebx
movq %rdi, %r14
movq 0x818(%rdi), %rax
movq 0x10(%rax), %rax
cmpb $0x0, 0x6(%rax)
je 0xcf44
cmpl $-0x1, %ebx
je 0xcfca
leaq 0x10(%r14), %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xce68
movl $0x7, %r12d
movq %r15, %rdi
callq 0xc54e
leal 0x1(,%rax,2), %edx
xorl %ebp, %ebp
btl %r12d, %ebx
setb %bpl
movq %r14, %rdi
movl %ebp, %esi
callq 0xce68
movq %r15, %rdi
movl %ebp, %esi
callq 0xc5e8
addl $-0x1, %r12d
jb 0xcf0f
jmp 0xcfc1
movl 0x8(%r14), %esi
testq %rsi, %rsi
je 0xcfa8
testl %ebx, %ebx
js 0xcf5a
cmpq %rsi, 0x1b040(%r14)
jne 0xcfa8
movq (%r14), %rdi
shrl $0x18, %esi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rdi
movzbl 0xa(%r14), %esi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rdi
movzbl 0x9(%r14), %esi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rdi
movzbl 0x8(%r14), %esi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rdi
movq 0x1b038(%r14), %rsi
movl 0x8(%r14), %edx
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, 0x8(%r14)
testl %ebx, %ebx
js 0xcfc1
movl 0x8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%r14)
movq 0x1b038(%r14), %rcx
movb %bl, (%rcx,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xce68
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcffd
testl %esi, %esi
jne 0xd002
jmp 0xd051
incl %ecx
movl %ecx, 0x28(%rdi)
movb -0x1(%rax), %sil
cmpb $0x28, %sil
jne 0xd017
movl %edx, %esi
shrl $0x1f, %esi
addl %esi, %edx
incl %edx
jmp 0xd023
cmpb $0x29, %sil
jne 0xd02b
testl %edx, %edx
jle 0xd02b
decl %edx
movl %edx, 0x2c(%rdi)
movq %rax, (%rdi)
jmp 0xcfeb
cmpb $0x20, %sil
jg 0xd040
testl %edx, %edx
jns 0xd040
movl $0x0, 0x2c(%rdi)
xorl %edx, %edx
jmp 0xd026
cmpb $0x21, %sil
jl 0xd026
testl %edx, %edx
jne 0xd026
movl $0xffffffff, 0x2c(%rdi) # imm = 0xFFFFFFFF
cmpb $0x0, -0x1(%rax)
je 0xd058
retq
leaq 0x42482(%rip), %rdi     # 0x4f4e1
jmp 0x455c