LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/Lzma2Enc.c
// Function: Lzma2Enc_Create
CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig)
{
  CLzma2Enc *p = (CLzma2Enc *)ISzAlloc_Alloc(alloc, sizeof(CLzma2Enc));
  if (!p)
    return NULL;
  Lzma2EncProps_Init(&p->props);
  Lzma2EncProps_Normalize(&p->props);
  p->expectedDataSize = (UInt64)(Int64)-1;
  p->tempBufLzma = NULL;
  p->alloc = alloc;
  p->allocBig = allocBig;
  {
    unsigned i;
    for (i = 0; i < MTCODER_THREADS_MAX; i++)
      p->coders[i].enc = NULL;
  }
  
  #ifndef Z7_ST
  p->mtCoder_WasConstructed = False;
  {
    unsigned i;
    for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
      p->outBufs[i] = NULL;
    p->outBufSize = 0;
  }
  #endif

  return (CLzma2EncHandle)p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x36b0, %esi           # imm = 0x36B0
callq *(%rdi)
movq %rax, %rbx
testq %rax, %rax
je 0x32166
leaq 0x8(%rbx), %r12
movq %r12, %rdi
callq 0x32ccc
xorl %r13d, %r13d
movq %r13, 0x50(%rbx)
movq $-0x1, %rbp
movq %rbp, 0x58(%rbx)
movl $0xffffffff, 0x60(%rbx) # imm = 0xFFFFFFFF
movq %r12, %rdi
callq 0x31f12
movq %rbp, 0x68(%rbx)
movq %r13, 0x70(%rbx)
movq %r15, 0x78(%rbx)
movq %r14, 0x80(%rbx)
movl $0x88, %eax
movq $0x0, (%rbx,%rax)
addq $0x18, %rax
cmpq $0x688, %rax            # imm = 0x688
jne 0x32127
movl $0x0, 0x908(%rbx)
movq %rbx, %rdi
addq $0x3450, %rdi           # imm = 0x3450
movl $0x260, %edx            # imm = 0x260
xorl %esi, %esi
callq 0x41c0
movq $0x0, 0x6a0(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/Lzma2Enc.c
// Function: Lzma2Enc_Destroy
void Lzma2Enc_Destroy(CLzma2EncHandle p)
{
  // GET_CLzma2Enc_p
  unsigned i;
  for (i = 0; i < MTCODER_THREADS_MAX; i++)
  {
    CLzma2EncInt *t = &p->coders[i];
    if (t->enc)
    {
      LzmaEnc_Destroy(t->enc, p->alloc, p->allocBig);
      t->enc = NULL;
    }
  }


  #ifndef Z7_ST
  if (p->mtCoder_WasConstructed)
  {
    MtCoder_Destruct(&p->mtCoder);
    p->mtCoder_WasConstructed = False;
  }
  Lzma2Enc_FreeOutBufs(p);
  #endif

  ISzAlloc_Free(p->alloc, p->tempBufLzma);
  p->tempBufLzma = NULL;

  ISzAlloc_Free(p->alloc, p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x88, %r14d
movq (%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x321a6
movq 0x78(%rbx), %rsi
movq 0x80(%rbx), %rdx
callq 0x33340
movq $0x0, (%rbx,%r14)
addq $0x18, %r14
cmpq $0x688, %r14            # imm = 0x688
jne 0x32185
cmpl $0x0, 0x908(%rbx)
je 0x321d2
leaq 0x910(%rbx), %rdi
callq 0x3b691
movl $0x0, 0x908(%rbx)
movl $0x68a, %r14d           # imm = 0x68A
movq (%rbx,%r14,8), %rsi
testq %rsi, %rsi
je 0x321f0
movq 0x78(%rbx), %rdi
callq *0x8(%rdi)
movq $0x0, (%rbx,%r14,8)
incq %r14
cmpq $0x6d6, %r14            # imm = 0x6D6
jne 0x321d8
xorl %r14d, %r14d
movq %r14, 0x6a0(%rbx)
movq 0x70(%rbx), %rsi
movq 0x78(%rbx), %rdi
callq *0x8(%rdi)
movq %r14, 0x70(%rbx)
movq 0x78(%rbx), %rdi
movq 0x8(%rdi), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/Lzma2Enc.c
// Function: Lzma2Enc_SetProps
SRes Lzma2Enc_SetProps(CLzma2EncHandle p, const CLzma2EncProps *props)
{
  // GET_CLzma2Enc_p
  CLzmaEncProps lzmaProps = props->lzmaProps;
  LzmaEncProps_Normalize(&lzmaProps);
  if (lzmaProps.lc + lzmaProps.lp > LZMA2_LCLP_MAX)
    return SZ_ERROR_PARAM;
  p->props = *props;
  Lzma2EncProps_Normalize(&p->props);
  return SZ_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movl $0x9, %ecx
movq %r15, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r15, %rdi
callq 0x32d02
movl 0xc(%r15), %ecx
addl 0x8(%r15), %ecx
movl $0x5, %eax
cmpl $0x4, %ecx
jg 0x3227e
addq $0x8, %rbx
movl $0xc, %ecx
movq %rbx, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x31f12
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/Lzma2Enc.c
// Function: Lzma2Enc_WriteProperties
Byte Lzma2Enc_WriteProperties(CLzma2EncHandle p)
{
  // GET_CLzma2Enc_p
  unsigned i;
  UInt32 dicSize = LzmaEncProps_GetDictSize(&p->props.lzmaProps);
  for (i = 0; i < 40; i++)
    if (dicSize <= LZMA2_DIC_SIZE_FROM_PROP(i))
      break;
  return (Byte)i;
}

// Assembly:
pushq %rax
addq $0x8, %rdi
callq 0x32e0a
movl %eax, %edx
xorl %eax, %eax
movl %eax, %esi
andl $0x1, %esi
orl $0x2, %esi
movl %eax, %ecx
shrl %ecx
addb $0xb, %cl
shll %cl, %esi
cmpl %esi, %edx
jbe 0x322bc
incl %eax
cmpl $0x28, %eax
jne 0x3229b
movl $0x28, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/Lzma2Enc.c
// Function: Lzma2Enc_MtCallback_Code
static SRes Lzma2Enc_MtCallback_Code(void *p, unsigned coderIndex, unsigned outBufIndex,
    const Byte *src, size_t srcSize, int finished)
{
  CLzma2Enc *me = (CLzma2Enc *)p;
  size_t destSize = me->outBufSize;
  SRes res;
  CMtProgressThunk progressThunk;

  Byte *dest = me->outBufs[outBufIndex];

  me->outBufsDataSizes[outBufIndex] = 0;

  if (!dest)
  {
    dest = (Byte *)ISzAlloc_Alloc(me->alloc, me->outBufSize);
    if (!dest)
      return SZ_ERROR_MEM;
    me->outBufs[outBufIndex] = dest;
  }

  MtProgressThunk_CreateVTable(&progressThunk);
  progressThunk.mtProgress = &me->mtCoder.mtProgress;
  progressThunk.inSize = 0;
  progressThunk.outSize = 0;

  res = Lzma2Enc_EncodeMt1(me,
      &me->coders[coderIndex],
      NULL, dest, &destSize,
      NULL, src, srcSize,
      finished,
      &progressThunk.vt);

  me->outBufsDataSizes[outBufIndex] = destSize;

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %rbp
movq %rcx, %r12
movl %esi, %r14d
movq %rdi, %rbx
movq 0x6a0(%rdi), %rsi
movq %rsi, 0x10(%rsp)
movl %edx, %r15d
movq 0x3450(%rdi,%r15,8), %r13
movq $0x0, 0x6a8(%rdi,%r15,8)
testq %r13, %r13
jne 0x32525
movq 0x78(%rbx), %rdi
callq *(%rdi)
testq %rax, %rax
je 0x3259b
movq %rax, %r13
movq %rax, 0x3450(%rbx,%r15,8)
movq %r12, (%rsp)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x3b5c0
leaq 0xc78(%rbx), %rax
movq %rax, 0x8(%r12)
movl %r14d, %eax
leaq (%rax,%rax,2), %rax
leaq 0x88(%rbx,%rax,8), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
xorl %edx, %edx
movq %r13, %rcx
movq %r14, %r8
xorl %r9d, %r9d
pushq %r12
pushq 0x10(%rsp)
pushq %rbp
pushq 0x18(%rsp)
callq 0x3260e
addq $0x20, %rsp
movq (%r14), %rcx
movq %rcx, 0x6a8(%rbx,%r15,8)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %eax
jmp 0x3258c
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/Lzma2Enc.c
// Function: Lzma2Enc_MtCallback_Write
static SRes Lzma2Enc_MtCallback_Write(void *p, unsigned outBufIndex)
{
  CLzma2Enc *me = (CLzma2Enc *)p;
  size_t size = me->outBufsDataSizes[outBufIndex];
  const Byte *data = me->outBufs[outBufIndex];
  
  if (me->outStream)
    return ISeqOutStream_Write(me->outStream, data, size) == size ? SZ_OK : SZ_ERROR_WRITE;
  
  if (size > me->outBuf_Rem)
    return SZ_ERROR_OUTPUT_EOF;
  memcpy(me->outBuf, data, size);
  me->outBuf_Rem -= size;
  me->outBuf += size;
  return SZ_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl %esi, %eax
movq 0x6a8(%rdi,%rax,8), %rbx
movq 0x3450(%rdi,%rax,8), %rsi
movq 0x688(%rdi), %rdi
testq %rdi, %rdi
je 0x325d9
movq %rbx, %rdx
callq *(%rdi)
xorl %ecx, %ecx
cmpq %rbx, %rax
setne %cl
leal (%rcx,%rcx,8), %eax
jmp 0x32606
movl $0x7, %eax
cmpq 0x698(%r14), %rbx
ja 0x32606
movq 0x690(%r14), %rdi
movq %rbx, %rdx
callq 0x4290
subq %rbx, 0x698(%r14)
addq %rbx, 0x690(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/Lzma2Enc.c
// Function: LimitedSeqInStream_Read
static SRes LimitedSeqInStream_Read(ISeqInStreamPtr pp, void *data, size_t *size)
{
  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CLimitedSeqInStream)
  size_t size2 = *size;
  SRes res = SZ_OK;
  
  if (p->limit != (UInt64)(Int64)-1)
  {
    const UInt64 rem = p->limit - p->processed;
    if (size2 > rem)
      size2 = (size_t)rem;
  }
  if (size2 != 0)
  {
    res = ISeqInStream_Read(p->realStream, data, &size2);
    p->finished = (size2 == 0 ? 1 : 0);
    p->processed += size2;
  }
  *size = size2;
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdx), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rcx
cmpq $-0x1, %rcx
je 0x32c92
subq 0x18(%r14), %rcx
cmpq %rcx, %rax
jbe 0x32c92
movq %rcx, 0x8(%rsp)
movq %rcx, %rax
testq %rax, %rax
je 0x32cba
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq *(%rdi)
movq (%r15), %rcx
xorl %edx, %edx
testq %rcx, %rcx
sete %dl
movl %edx, 0x20(%r14)
addq %rcx, 0x18(%r14)
jmp 0x32cbe
xorl %ecx, %ecx
xorl %eax, %eax
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: LzmaEncProps_Normalize
void LzmaEncProps_Normalize(CLzmaEncProps *p)
{
  int level = p->level;
  if (level < 0) level = 5;
  p->level = level;
  
  if (p->dictSize == 0)
    p->dictSize = (unsigned)level <= 4 ?
        (UInt32)1 << (level * 2 + 16) :
        (unsigned)level <= sizeof(size_t) / 2 + 4 ?
          (UInt32)1 << (level + 20) :
          (UInt32)1 << (sizeof(size_t) / 2 + 24);

  if (p->dictSize > p->reduceSize)
  {
    UInt32 v = (UInt32)p->reduceSize;
    const UInt32 kReduceMin = ((UInt32)1 << 12);
    if (v < kReduceMin)
      v = kReduceMin;
    if (p->dictSize > v)
      p->dictSize = v;
  }

  if (p->lc < 0) p->lc = 3;
  if (p->lp < 0) p->lp = 0;
  if (p->pb < 0) p->pb = 2;

  if (p->algo < 0) p->algo = (unsigned)level < 5 ? 0 : 1;
  if (p->fb < 0) p->fb = (unsigned)level < 7 ? 32 : 64;
  if (p->btMode < 0) p->btMode = (p->algo == 0 ? 0 : 1);
  if (p->numHashBytes < 0) p->numHashBytes = (p->btMode ? 4 : 5);
  if (p->mc == 0) p->mc = (16 + ((unsigned)p->fb >> 1)) >> (p->btMode ? 0 : 1);
  
  if (p->numThreads < 0)
    p->numThreads =
      #ifndef Z7_ST
      ((p->btMode && p->algo) ? 2 : 1);
      #else
      1;
      #endif
}

// Assembly:
movl (%rdi), %ecx
movl 0x4(%rdi), %edx
testl %ecx, %ecx
movl $0x5, %eax
cmovnsl %ecx, %eax
movl %eax, (%rdi)
testl %edx, %edx
jne 0x32d40
cmpl $0x4, %eax
ja 0x32d28
leal (%rax,%rax), %ecx
movl $0x10000, %edx          # imm = 0x10000
shll %cl, %edx
jmp 0x32d3d
leal 0x14(%rax), %ecx
movl $0x1, %esi
shll %cl, %esi
cmpl $0x9, %eax
movl $0x10000000, %edx       # imm = 0x10000000
cmovbl %esi, %edx
movl %edx, 0x4(%rdi)
movl %edx, %esi
movq 0x38(%rdi), %rcx
cmpq %rsi, %rcx
jae 0x32d60
cmpl $0x1001, %ecx           # imm = 0x1001
movl $0x1000, %esi           # imm = 0x1000
cmovael %ecx, %esi
cmpl %esi, %edx
jbe 0x32d60
movl %esi, 0x4(%rdi)
cmpl $0x0, 0x8(%rdi)
jns 0x32d6d
movl $0x3, 0x8(%rdi)
cmpl $0x0, 0xc(%rdi)
jns 0x32d7a
movl $0x0, 0xc(%rdi)
cmpl $0x0, 0x10(%rdi)
jns 0x32d87
movl $0x2, 0x10(%rdi)
movl 0x14(%rdi), %edx
testl %edx, %edx
jns 0x32d99
xorl %edx, %edx
cmpl $0x5, %eax
setae %dl
movl %edx, 0x14(%rdi)
movl 0x18(%rdi), %esi
testl %esi, %esi
jns 0x32db2
xorl %esi, %esi
cmpl $0x7, %eax
setae %sil
shll $0x5, %esi
addl $0x20, %esi
movl %esi, 0x18(%rdi)
movl 0x1c(%rdi), %eax
testl %eax, %eax
jns 0x32dc3
xorl %eax, %eax
testl %edx, %edx
setne %al
movl %eax, 0x1c(%rdi)
cmpl $0x0, 0x20(%rdi)
jns 0x32dd4
xorl %ecx, %ecx
cmpl $0x1, %eax
adcl $0x4, %ecx
movl %ecx, 0x20(%rdi)
cmpl $0x0, 0x28(%rdi)
jne 0x32de9
shrl %esi
addl $0x10, %esi
testl %eax, %eax
sete %cl
shrl %cl, %esi
movl %esi, 0x28(%rdi)
cmpl $0x0, 0x30(%rdi)
js 0x32df0
retq
testl %eax, %eax
sete %al
testl %edx, %edx
sete %cl
orb %al, %cl
movzbl %cl, %eax
movl $0x2, %ecx
subl %eax, %ecx
movl %ecx, 0x30(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: LzmaEnc_Create
CLzmaEncHandle LzmaEnc_Create(ISzAllocPtr alloc)
{
  void *p;
  p = ISzAlloc_Alloc(alloc, sizeof(CLzmaEnc));
  if (p)
    LzmaEnc_Construct((CLzmaEnc *)p);
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl $0x207a8, %esi          # imm = 0x207A8
callq *(%rdi)
movq %rax, %rbx
testq %rax, %rax
je 0x33332
pxor %xmm0, %xmm0
movdqu %xmm0, 0x98(%rbx)
leaq 0x628(%rbx), %r14
movq %r14, %rdi
callq 0x37696
leaq 0x100(%rbx), %rdi
movq %r14, 0x620(%rbx)
callq 0x39c50
movq %rsp, %rsi
movq $0x5, (%rsi)
movq $-0x1, 0x38(%rsi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rsi)
movdqu %xmm0, 0x14(%rsi)
xorl %eax, %eax
movq %rax, 0x24(%rsi)
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movq %rcx, 0x2c(%rsi)
movq %rax, 0x40(%rsi)
movq %rbx, %rdi
callq 0x330d9
movw $0x100, 0x3080(%rbx)    # imm = 0x100
movq %rbx, %r14
addq $0x3082, %r14           # imm = 0x3082
movl $0x2, %ebp
movl %ebp, %ecx
shrl %ecx
decb %cl
movl $0x1, %r15d
shlq %cl, %r15
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x41c0
addq %r15, %r14
incl %ebp
cmpl $0x1c, %ebp
jne 0x332ae
xorl %eax, %eax
movl %eax, %esi
shll $0x4, %esi
orl $0x8, %esi
xorl %edx, %edx
xorl %ecx, %ecx
imull %esi, %esi
addl %ecx, %ecx
cmpl $0x10000, %esi          # imm = 0x10000
jb 0x33301
movl %esi, %edi
shrl %edi
incl %ecx
cmpl $0x1ffff, %esi          # imm = 0x1FFFF
movl %edi, %esi
ja 0x332f1
jmp 0x33303
movl %esi, %edi
incl %edx
movl %edi, %esi
cmpl $0x4, %edx
jne 0x332e2
movl $0xa1, %edx
subl %ecx, %edx
movl %edx, 0xb30(%rbx,%rax,4)
incq %rax
cmpq $0x80, %rax
jne 0x332d6
xorl %eax, %eax
movq %rax, 0x68(%rbx)
movq %rax, 0x1f888(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: LzmaEnc_CodeOneMemBlock
SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle p, BoolInt reInit,
    Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize)
{
  // GET_CLzmaEnc_p
  UInt64 nowPos64;
  SRes res;
  CLzmaEnc_SeqOutStreamBuf outStream;

  outStream.vt.Write = SeqOutStreamBuf_Write;
  outStream.data = dest;
  outStream.rem = *destLen;
  outStream.overflow = False;

  p->writeEndMark = False;
  p->finished = False;
  p->result = SZ_OK;

  if (reInit)
    LzmaEnc_Init(p);
  LzmaEnc_InitPrices(p);
  RangeEnc_Init(&p->rc);
  p->rc.outStream = &outStream.vt;
  nowPos64 = p->nowPos64;
  
  res = LzmaEnc_CodeOneBlock(p, desiredPackSize, *unpackSize);
  
  *unpackSize = (UInt32)(p->nowPos64 - nowPos64);
  *destLen -= outStream.rem;
  if (outStream.overflow)
    return SZ_ERROR_OUTPUT_EOF;

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movl %r8d, 0x4(%rsp)
movq %rcx, %rbx
movq %rdi, %r15
leaq 0xc7(%rip), %rax        # 0x33765
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq (%rcx), %rax
movq %rax, 0x18(%rsp)
xorl %r12d, %r12d
movl %r12d, 0x20(%rsp)
movq $0x0, 0xd0(%rdi)
movl %r12d, 0xf8(%rdi)
testl %esi, %esi
je 0x336d6
movq %r15, %rdi
callq 0x337a7
movq %r15, %rdi
callq 0x33c40
movl $0xffffffff, 0x70(%r15) # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
movups %xmm0, 0x74(%r15)
movl %r12d, 0x84(%r15)
movq 0x98(%r15), %rax
movq %rax, 0x88(%r15)
movq $0x0, 0xa8(%r15)
movl %r12d, 0xb0(%r15)
leaq 0x8(%rsp), %r13
movq %r13, 0xa0(%r15)
movl 0xe0(%r15), %ebp
movl (%r14), %edx
movq %r15, %rdi
movl 0x4(%rsp), %esi
callq 0x33cdd
movl 0xe0(%r15), %ecx
subl %ebp, %ecx
movl %ecx, (%r14)
movq 0x10(%r13), %rcx
subq %rcx, (%rbx)
cmpl %r12d, 0x18(%r13)
movl $0x7, %ecx
cmovnel %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: SeqOutStreamBuf_Write
static size_t SeqOutStreamBuf_Write(ISeqOutStreamPtr pp, const void *data, size_t size)
{
  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CLzmaEnc_SeqOutStreamBuf)
  if (p->rem < size)
  {
    size = p->rem;
    p->overflow = True;
  }
  if (size != 0)
  {
    memcpy(p->data, data, size);
    p->rem -= size;
    p->data += size;
  }
  return size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
cmpq %rdx, %rax
jae 0x33783
movl $0x1, 0x18(%r14)
movq %rax, %rbx
testq %rbx, %rbx
je 0x3379c
movq 0x8(%r14), %rdi
movq %rbx, %rdx
callq 0x4290
subq %rbx, 0x10(%r14)
addq %rbx, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: LzmaEnc_InitPrices
static void LzmaEnc_InitPrices(CLzmaEnc *p)
{
  if (!p->fastMode)
  {
    FillDistancesPrices(p);
    FillAlignPrices(p);
  }

  p->lenEnc.tableSize =
  p->repLenEnc.tableSize =
      p->numFastBytes + 1 - LZMA_MATCH_LEN_MIN;

  p->repLenEncCounter = REP_LEN_COUNT;

  LenPriceEnc_UpdateTables(&p->lenEnc, (unsigned)1 << p->pb, &p->lenProbs, p->ProbPrices);
  LenPriceEnc_UpdateTables(&p->repLenEnc, (unsigned)1 << p->pb, &p->repLenProbs, p->ProbPrices);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xcc(%rdi)
jne 0x33c63
movq %rbx, %rdi
callq 0x36505
movq %rbx, %rdi
callq 0x36827
movl 0x48(%rbx), %eax
decl %eax
leaq 0xb484(%rbx), %r14
movl %eax, 0xb484(%rbx)
movl %eax, 0x7080(%rbx)
movl $0x40, 0xec(%rbx)
movb 0xc4(%rbx), %cl
movl $0x1, %esi
shll %cl, %esi
leaq 0x7080(%rbx), %rdi
movl $0x1, %ebp
leaq 0x2880(%rbx), %rdx
leaq 0xb30(%rbx), %r15
movq %r15, %rcx
callq 0x36901
movb 0xc4(%rbx), %cl
shll %cl, %ebp
addq $0x2c80, %rbx           # imm = 0x2C80
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x36901
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: LzmaEnc_Encode2
Z7_NO_INLINE
static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgressPtr progress)
{
  SRes res = SZ_OK;

  #ifndef Z7_ST
  Byte allocaDummy[0x300];
  allocaDummy[0] = 0;
  allocaDummy[1] = allocaDummy[0];
  #endif

  for (;;)
  {
    res = LzmaEnc_CodeOneBlock(p, 0, 0);
    if (res != SZ_OK || p->finished)
      break;
    if (progress)
    {
      res = ICompressProgress_Progress(progress, p->nowPos64, RangeEnc_GetProcessed(&p->rc));
      if (res != SZ_OK)
      {
        res = SZ_ERROR_PROGRESS;
        break;
      }
    }
  }
  
  LzmaEnc_Finish((CLzmaEncHandle)(void *)p);

  /*
  if (res == SZ_OK && !Inline_MatchFinder_IsFinishedOK(&MFB))
    res = SZ_ERROR_FAIL;
  }
  */

  return res;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x33cdd
testl %eax, %eax
je 0x362b9
movl %eax, %ebp
cmpl $0x0, 0xfc(%rbx)
je 0x362b2
addq $0x100, %rbx            # imm = 0x100
movq %rbx, %rdi
callq 0x39ce8
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
cmpl $0x0, 0xd4(%rbx)
jne 0x3629a
testq %r14, %r14
je 0x362f6
movq 0xa8(%rbx), %rdx
movq 0xe0(%rbx), %rsi
addq 0x88(%rbx), %rdx
subq 0x98(%rbx), %rdx
addq 0x80(%rbx), %rdx
movq %r14, %rdi
callq *(%r14)
testl %eax, %eax
jne 0x36308
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33cdd
testl %eax, %eax
je 0x362bb
jmp 0x36298
movl $0xa, %ebp
jmp 0x3629a
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: LzmaEnc_MemEncode
SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
    int writeEndMark, ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)
{
  SRes res;
  // GET_CLzmaEnc_p

  CLzmaEnc_SeqOutStreamBuf outStream;

  outStream.vt.Write = SeqOutStreamBuf_Write;
  outStream.data = dest;
  outStream.rem = *destLen;
  outStream.overflow = False;

  p->writeEndMark = writeEndMark;
  p->rc.outStream = &outStream.vt;

  res = LzmaEnc_MemPrepare(p, src, srcLen, 0, alloc, allocBig);
  
  if (res == SZ_OK)
  {
    res = LzmaEnc_Encode2(p, progress);
    if (res == SZ_OK && p->nowPos64 != srcLen)
      res = SZ_ERROR_FAIL;
  }

  *destLen -= (SizeT)outStream.rem;
  if (outStream.overflow)
    return SZ_ERROR_OUTPUT_EOF;
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %r8, %r14
movq %rdx, %rbx
movq %rdi, %r15
movq 0x48(%rsp), %rdx
movq 0x50(%rsp), %rax
leaq -0x2c3f(%rip), %rdi     # 0x33765
movq %rsp, %r8
movq %rdi, (%r8)
movq %rsi, 0x8(%r8)
movq (%rbx), %rsi
movq %rsi, 0x10(%r8)
movl $0x0, 0x18(%r8)
movl %r9d, 0xd0(%r15)
movq %r8, 0xa0(%r15)
movq $0x0, 0x670(%r15)
movb $0x1, 0x64b(%r15)
movq %rcx, 0x628(%r15)
movq %r14, 0x688(%r15)
movq %r14, 0xaa8(%r15)
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rcx
callq 0x333d1
testl %eax, %eax
jne 0x36426
movq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x36281
testl %eax, %eax
jne 0x36426
xorl %ecx, %ecx
cmpq %r14, 0xe0(%r15)
movl $0xb, %eax
cmovel %ecx, %eax
movq 0x10(%rsp), %rcx
subq %rcx, (%rbx)
cmpl $0x0, 0x18(%rsp)
movl $0x7, %ecx
cmovel %eax, %ecx
movl %ecx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: LzmaEncode
SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
    const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
    ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)
{
  CLzmaEncHandle p = LzmaEnc_Create(alloc);
  SRes res;
  if (!p)
    return SZ_ERROR_MEM;

  res = LzmaEnc_SetProps(p, props);
  if (res == SZ_OK)
  {
    res = LzmaEnc_WriteProperties(p, propsEncoded, propsSize);
    if (res == SZ_OK)
      res = LzmaEnc_MemEncode(p, dest, destLen, src, srcLen,
          writeEndMark, progress, alloc, allocBig);
  }

  LzmaEnc_Destroy(p, alloc, allocBig);
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %rbx
movq %rcx, (%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
movq 0x58(%rsp), %rdi
callq 0x3320b
testq %rax, %rax
je 0x364b6
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x330d9
testl %eax, %eax
jne 0x3649a
movq 0x40(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x3630f
testl %eax, %eax
je 0x364cc
movl %eax, %ebx
movq 0x58(%rsp), %r15
movq 0x60(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x33340
jmp 0x364bb
movl $0x2, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x48(%rsp), %r9d
subq $0x8, %rsp
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq 0x8(%rsp), %r8
movq 0x68(%rsp), %r12
pushq %r12
movq 0x68(%rsp), %r15
pushq %r15
pushq 0x68(%rsp)
callq 0x36381
addq $0x20, %rsp
movl %eax, %ebx
jmp 0x364a6
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: SetPrices_3
static void SetPrices_3(const CLzmaProb *probs, UInt32 startPrice, UInt32 *prices, const CProbPrice *ProbPrices)
{
  unsigned i;
  for (i = 0; i < 8; i += 2)
  {
    UInt32 price = startPrice;
    UInt32 prob;
    price += GET_PRICEa(probs[1           ], (i >> 2));
    price += GET_PRICEa(probs[2 + (i >> 2)], (i >> 1) & 1);
    prob = probs[4 + (i >> 1)];
    prices[i    ] = price + GET_PRICEa_0(prob);
    prices[i + 1] = price + GET_PRICEa_1(prob);
  }
}

// Assembly:
pushq %rbx
movzwl 0x2(%rdi), %eax
xorl %r8d, %r8d
movl $0x7f0, %r9d            # imm = 0x7F0
movl %r8d, %r10d
shrl $0x2, %r10d
movzwl 0x4(%rdi,%r10,2), %r11d
negl %r10d
andl %r9d, %r10d
xorl %eax, %r10d
shrl $0x4, %r10d
movl (%rcx,%r10,4), %r10d
addl %esi, %r10d
movl %r8d, %ebx
shll $0x1e, %ebx
sarl $0x1f, %ebx
andl %r9d, %ebx
xorl %r11d, %ebx
shrl $0x4, %ebx
addl (%rcx,%rbx,4), %r10d
movzwl 0x8(%rdi,%r8), %r11d
shrl $0x2, %r11d
andl $-0x4, %r11d
movl (%rcx,%r11), %ebx
addl %r10d, %ebx
movl %ebx, (%rdx,%r8,4)
xorl $0x1fc, %r11d           # imm = 0x1FC
addl (%rcx,%r11), %r10d
movl %r10d, 0x4(%rdx,%r8,4)
leaq 0x2(%r8), %r10
cmpq $0x6, %r8
movq %r10, %r8
jb 0x36aab
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: CheckErrors
static SRes CheckErrors(CLzmaEnc *p)
{
  if (p->result != SZ_OK)
    return p->result;
  if (p->rc.res != SZ_OK)
    p->result = SZ_ERROR_WRITE;

  #ifndef Z7_ST
  if (
      // p->mf_Failure ||
        (p->mtMode &&
          ( // p->matchFinderMt.failure_LZ_LZ ||
            p->matchFinderMt.failure_LZ_BT))
     )
  {
    p->result = MY_HRES_ERROR_INTERNAL_ERROR;
    // printf("\nCheckErrors p->matchFinderMt.failureLZ\n");
  }
  #endif

  if (MFB.result != SZ_OK)
    p->result = SZ_ERROR_READ;
  
  if (p->result != SZ_OK)
    p->finished = True;
  return p->result;
}

// Assembly:
movl 0xf8(%rdi), %eax
testl %eax, %eax
je 0x36b25
retq
movl 0xb0(%rdi), %ecx
testl %ecx, %ecx
je 0x36b40
movl $0x9, 0xf8(%rdi)
movl $0x9, %eax
jmp 0x36b42
xorl %eax, %eax
cmpl $0x0, 0xfc(%rdi)
je 0x36b6e
cmpl $0x0, 0x148(%rdi)
je 0x36b6e
movl $0x8007054f, 0xf8(%rdi) # imm = 0x8007054F
cmpl $0x0, 0x69c(%rdi)
jne 0x36b77
movl $0x8007054f, %eax       # imm = 0x8007054F
jmp 0x36b86
cmpl $0x0, 0x69c(%rdi)
je 0x36b91
movl $0x8, 0xf8(%rdi)
movl $0x8, %eax
movl $0x1, 0xd4(%rdi)
retq
testl %ecx, %ecx
jne 0x36b86
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: Flush
Z7_NO_INLINE static SRes Flush(CLzmaEnc *p, UInt32 nowPos)
{
  /* ReleaseMFStream(); */
  p->finished = True;
  if (p->writeEndMark)
    WriteEndMarker(p, nowPos & p->pbMask);
  RangeEnc_FlushData(&p->rc);
  RangeEnc_FlushStream(&p->rc);
  return CheckErrors(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, 0xd4(%rdi)
cmpl $0x0, 0xd0(%rdi)
je 0x36d48
movl %esi, %r15d
andl 0x64(%rbx), %r15d
leaq 0x70(%rbx), %r14
movl 0x44(%rbx), %eax
movl 0x70(%rbx), %ebp
movq %rax, %rcx
shlq $0x5, %rcx
addq %rbx, %rcx
movzwl 0x2280(%rcx,%r15,2), %edx
movl %ebp, %esi
shrl $0xb, %esi
imull %edx, %esi
subl %esi, %ebp
addq %rsi, 0x78(%rbx)
movl %edx, %esi
shrl $0x5, %esi
subl %esi, %edx
movw %dx, 0x2280(%rcx,%r15,2)
cmpl $0xffffff, %ebp         # imm = 0xFFFFFF
ja 0x36c12
shll $0x8, %ebp
movq %r14, %rdi
callq 0x36eb1
movl 0x44(%rbx), %eax
movzwl 0x2220(%rbx,%rax,2), %ecx
shrl $0xb, %ebp
imull %ecx, %ebp
movl $0x800, %edx            # imm = 0x800
subl %ecx, %edx
shrl $0x5, %edx
addl %ecx, %edx
movw %dx, 0x2220(%rbx,%rax,2)
cmpl $0xffffff, %ebp         # imm = 0xFFFFFF
ja 0x36c4a
shll $0x8, %ebp
movq %r14, %rdi
callq 0x36eb1
movl 0x44(%rbx), %eax
leaq 0x28db3(%rip), %rcx     # 0x5fa04
movzbl (%rax,%rcx), %eax
movl %eax, 0x44(%rbx)
movl %ebp, 0x70(%rbx)
leaq 0x2880(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %r15d, %ecx
callq 0x36f3f
movl 0x70(%rbx), %r15d
movl $0x1, %r12d
movl %r12d, %eax
movzwl 0x2580(%rbx,%rax,2), %ecx
movl %r15d, %edx
shrl $0xb, %edx
imull %ecx, %edx
subl %edx, %r15d
addq %rdx, 0x78(%rbx)
movl %ecx, %edx
shrl $0x5, %edx
subl %edx, %ecx
movw %cx, 0x2580(%rbx,%rax,2)
cmpl $0xffffff, %r15d        # imm = 0xFFFFFF
ja 0x36cb8
shll $0x8, %r15d
movq %r14, %rdi
callq 0x36eb1
leal 0x1(,%r12,2), %eax
cmpl $0x20, %r12d
movl %eax, %r12d
jb 0x36c79
movl $0xffffffe6, %ebp       # imm = 0xFFFFFFE6
movl %r15d, %eax
shrl %r15d
addq %r15, 0x78(%rbx)
cmpl $0x1ffffff, %eax        # imm = 0x1FFFFFF
ja 0x36ceb
shll $0x8, %r15d
movq %r14, %rdi
callq 0x36eb1
incl %ebp
jne 0x36cce
movl $0x1, %r12d
movl %r12d, %eax
movzwl 0x2200(%rbx,%rax,2), %ecx
movl %r15d, %edx
shrl $0xb, %edx
imull %ecx, %edx
subl %edx, %r15d
addq %rdx, 0x78(%rbx)
movl %ecx, %edx
shrl $0x5, %edx
subl %edx, %ecx
movw %cx, 0x2200(%rbx,%rax,2)
cmpl $0xffffff, %r15d        # imm = 0xFFFFFF
ja 0x36d34
shll $0x8, %r15d
movq %r14, %rdi
callq 0x36eb1
leal 0x1(,%r12,2), %eax
cmpl $0x8, %r12d
movl %eax, %r12d
jb 0x36cf5
movl %r15d, (%r14)
leaq 0x70(%rbx), %r14
movl $0x5, %ebp
movq %r14, %rdi
callq 0x36eb1
decl %ebp
jne 0x36d51
movq %r14, %rdi
callq 0x37187
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x36b1a
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: ReadMatchDistances
static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
{
  unsigned numPairs;
  
  p->additionalOffset++;
  p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
  {
    const UInt32 *d = p->matchFinder.GetMatches(p->matchFinderObj, p->matches);
    // if (!d) { p->mf_Failure = True; *numPairsRes = 0;  return 0; }
    numPairs = (unsigned)(d - p->matches);
  }
  *numPairsRes = numPairs;
  
  #ifdef SHOW_STAT
  printf("\n i = %u numPairs = %u    ", g_STAT_OFFSET, numPairs / 2);
  g_STAT_OFFSET++;
  {
    unsigned i;
    for (i = 0; i < numPairs; i += 2)
      printf("%2u %6u   | ", p->matches[i], p->matches[i + 1]);
  }
  #endif
  
  if (numPairs == 0)
    return 0;
  {
    const unsigned len = p->matches[(size_t)numPairs - 2];
    if (len != p->numFastBytes)
      return len;
    {
      UInt32 numAvail = p->numAvail;
      if (numAvail > LZMA_MATCH_LEN_MAX)
        numAvail = LZMA_MATCH_LEN_MAX;
      {
        const Byte *p1 = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
        const Byte *p2 = p1 + len;
        const ptrdiff_t dif = (ptrdiff_t)-1 - (ptrdiff_t)p->matches[(size_t)numPairs - 1];
        const Byte *lim = p1 + numAvail;
        for (; p2 != lim && *p2 == p2[dif]; p2++)
        {}
        return (unsigned)(p2 - p1);
      }
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
incl 0x4c(%rdi)
movq (%rdi), %rdi
callq *0x10(%rbx)
movl %eax, 0x40(%rbx)
movq (%rbx), %rdi
leaq 0xd30(%rbx), %r15
movq %r15, %rsi
callq *0x20(%rbx)
subq %r15, %rax
shrq $0x2, %rax
movl %eax, (%r14)
testl %eax, %eax
je 0x36e14
movl %eax, %r12d
movl 0xd28(%rbx,%r12,4), %r14d
cmpl 0x48(%rbx), %r14d
jne 0x36e17
movl 0x40(%rbx), %eax
movl $0x111, %r15d           # imm = 0x111
cmpl %r15d, %eax
cmovbl %eax, %r15d
movq (%rbx), %rdi
callq *0x18(%rbx)
leaq -0x1(%rax), %rcx
leaq (%rax,%r14), %rdx
decq %rdx
cmpl %r15d, %r14d
je 0x36e0d
movl 0xd2c(%rbx,%r12,4), %esi
addq %r15, %rax
decq %rax
subq %r14, %r15
negq %rsi
movb (%rdx), %dil
cmpb -0x1(%rdx,%rsi), %dil
jne 0x36e0d
incq %rdx
decq %r15
jne 0x36df8
movq %rax, %rdx
subl %ecx, %edx
movl %edx, %r14d
jmp 0x36e17
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: RangeEnc_ShiftLow
Z7_FASTCALL RangeEnc_ShiftLow(CRangeEnc *p)
{
  UInt32 low = (UInt32)p->low;
  unsigned high = (unsigned)(p->low >> 32);
  p->low = (UInt32)(low << 8);
  if (low < (UInt32)0xFF000000 || high != 0)
  {
    {
      Byte *buf = p->buf;
      *buf++ = (Byte)(p->cache + high);
      p->cache = (unsigned)(low >> 24);
      p->buf = buf;
      if (buf == p->bufLim)
        RangeEnc_FlushStream(p);
      if (p->cacheSize == 0)
        return;
    }
    high += 0xFF;
    for (;;)
    {
      Byte *buf = p->buf;
      *buf++ = (Byte)(high);
      p->buf = buf;
      if (buf == p->bufLim)
        RangeEnc_FlushStream(p);
      if (--p->cacheSize == 0)
        return;
    }
  }
  p->cacheSize++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq %rax, %r14
shrq $0x20, %r14
movl %eax, %ecx
shll $0x8, %ecx
movq %rcx, 0x8(%rdi)
cmpl $0xff000000, %eax       # imm = 0xFF000000
setae %cl
testq %r14, %r14
sete %dl
testb %cl, %dl
jne 0x36f33
movq 0x18(%rbx), %rcx
movl 0x4(%rbx), %edx
addl %r14d, %edx
movb %dl, (%rcx)
incq %rcx
shrl $0x18, %eax
movl %eax, 0x4(%rbx)
movq %rcx, 0x18(%rbx)
cmpq 0x20(%rbx), %rcx
jne 0x36f05
movq %rbx, %rdi
callq 0x37187
cmpq $0x0, 0x10(%rbx)
je 0x36f37
decb %r14b
movq 0x18(%rbx), %rax
movb %r14b, (%rax)
incq %rax
movq %rax, 0x18(%rbx)
cmpq 0x20(%rbx), %rax
jne 0x36f2b
movq %rbx, %rdi
callq 0x37187
decq 0x10(%rbx)
jne 0x36f0f
jmp 0x36f37
incq 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: RangeEnc_FlushStream
Z7_NO_INLINE static void RangeEnc_FlushStream(CRangeEnc *p)
{
  const size_t num = (size_t)(p->buf - p->bufBase);
  if (p->res == SZ_OK)
  {
    if (num != ISeqOutStream_Write(p->outStream, p->bufBase, num))
      p->res = SZ_ERROR_WRITE;
  }
  p->processed += num;
  p->buf = p->bufBase;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq 0x28(%rdi), %rsi
subq %rsi, %r14
cmpl $0x0, 0x40(%rdi)
jne 0x371b4
movq 0x30(%rbx), %rdi
movq %r14, %rdx
callq *(%rdi)
cmpq %rax, %r14
je 0x371b4
movl $0x9, 0x40(%rbx)
addq %r14, 0x38(%rbx)
movq 0x28(%rbx), %rax
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/7zStream.c
// Function: SeqInStream_ReadMax
SRes SeqInStream_ReadMax(ISeqInStreamPtr stream, void *buf, size_t *processedSize)
{
  size_t size = *processedSize;
  *processedSize = 0;
  while (size != 0)
  {
    size_t cur = size;
    const SRes res = ISeqInStream_Read(stream, buf, &cur);
    *processedSize += cur;
    buf = (void *)((Byte *)buf + cur);
    size -= cur;
    if (res != SZ_OK)
      return res;
    if (cur == 0)
      return SZ_OK;
  }
  return SZ_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %r13
movq $0x0, (%rdx)
xorl %r12d, %r12d
testq %r13, %r13
je 0x3727c
movq %r13, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rsp, %rdx
callq *(%r15)
movq (%rsp), %rcx
addq %rcx, (%rbx)
testq %rcx, %rcx
cmovel %r12d, %ebp
testl %eax, %eax
cmovnel %eax, %ebp
jne 0x3727e
addq %rcx, %r14
subq %rcx, %r13
testq %rcx, %rcx
jne 0x37245
jmp 0x3727e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/7zStream.c
// Function: LookInStream_LookRead
SRes LookInStream_LookRead(ILookInStreamPtr stream, void *buf, size_t *size)
{
  const void *lookBuf;
  if (*size == 0)
    return SZ_OK;
  RINOK(ILookInStream_Look(stream, &lookBuf, size))
  memcpy(buf, lookBuf, *size);
  return ILookInStream_Skip(stream, *size);
}

// Assembly:
cmpq $0x0, (%rdx)
je 0x37315
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq *(%rdi)
testl %eax, %eax
jne 0x3730b
movq 0x8(%rsp), %rsi
movq (%r14), %rdx
movq %r15, %rdi
callq 0x4290
movq (%r14), %rsi
movq %rbx, %rdi
callq *0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/7zStream.c
// Function: LookInStream_Read2
SRes LookInStream_Read2(ILookInStreamPtr stream, void *buf, size_t size, SRes errorType)
{
  while (size != 0)
  {
    size_t processed = size;
    RINOK(ILookInStream_Read(stream, buf, &processed))
    if (processed == 0)
      return errorType;
    buf = (void *)((Byte *)buf + processed);
    size -= processed;
  }
  return SZ_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x37365
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r14, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *0x10(%r12)
testl %eax, %eax
jne 0x37361
movq (%rsp), %rax
testq %rax, %rax
je 0x37363
addq %rax, %r15
subq %rax, %r14
jne 0x37338
jmp 0x37365
movl %eax, %ebx
movl %ebx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/7zStream.c
// Function: LookToRead2_CreateVTable
void LookToRead2_CreateVTable(CLookToRead2 *p, int lookahead)
{
  p->vt.Look = lookahead ?
      LookToRead2_Look_Lookahead :
      LookToRead2_Look_Exact;
  p->vt.Skip = LookToRead2_Skip;
  p->vt.Read = LookToRead2_Read;
  p->vt.Seek = LookToRead2_Seek;
}

// Assembly:
testl %esi, %esi
leaq 0xa5(%rip), %rax        # 0x3748a
leaq 0x29(%rip), %rcx        # 0x37415
cmoveq %rax, %rcx
movq %rcx, (%rdi)
leaq 0xfb(%rip), %rax        # 0x374f5
movq %rax, 0x8(%rdi)
leaq 0xf7(%rip), %rax        # 0x374fc
movq %rax, 0x10(%rdi)
leaq 0x140(%rip), %rax       # 0x37550
movq %rax, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/7zStream.c
// Function: LookToRead2_Look_Lookahead
static SRes LookToRead2_Look_Lookahead(ILookInStreamPtr pp, const void **buf, size_t *size)
{
  SRes res = SZ_OK;
  GET_LookToRead2
  size_t size2 = p->size - p->pos;
  if (size2 == 0 && *size != 0)
  {
    p->pos = 0;
    p->size = 0;
    size2 = p->bufSize;
    res = ISeekInStream_Read(p->realStream, p->buf, &size2);
    p->size = size2;
  }
  if (*size > size2)
    *size = size2;
  *buf = p->buf + p->pos;
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rcx
xorl %eax, %eax
movq (%rdx), %rdx
subq 0x28(%rdi), %rcx
jne 0x37467
testq %rdx, %rdx
je 0x37471
leaq 0x28(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x40(%r14), %rax
movq %rsp, %r12
movq %rax, (%r12)
movq 0x20(%r14), %rdi
movq 0x38(%r14), %rsi
movq %r12, %rdx
callq *(%rdi)
movq (%r12), %rcx
movq %rcx, 0x30(%r14)
movq (%r15), %rdx
cmpq %rcx, %rdx
jbe 0x37473
movq %rcx, (%r15)
jmp 0x37473
xorl %eax, %eax
movq 0x38(%r14), %rcx
addq 0x28(%r14), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/7zStream.c
// Function: LookToRead2_Look_Exact
static SRes LookToRead2_Look_Exact(ILookInStreamPtr pp, const void **buf, size_t *size)
{
  SRes res = SZ_OK;
  GET_LookToRead2
  size_t size2 = p->size - p->pos;
  if (size2 == 0 && *size != 0)
  {
    p->pos = 0;
    p->size = 0;
    if (*size > p->bufSize)
      *size = p->bufSize;
    res = ISeekInStream_Read(p->realStream, p->buf, size);
    size2 = p->size = *size;
  }
  if (*size > size2)
    *size = size2;
  *buf = p->buf + p->pos;
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rcx
movq (%rdx), %rdx
subq 0x28(%rdi), %rcx
jne 0x374d6
testq %rdx, %rdx
je 0x374e2
leaq 0x28(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x40(%r14), %rax
cmpq %rax, (%r15)
jbe 0x374c0
movq %rax, (%r15)
movq 0x20(%r14), %rdi
movq 0x38(%r14), %rsi
movq %r15, %rdx
callq *(%rdi)
movq (%r15), %rcx
movq %rcx, 0x30(%r14)
jmp 0x374e4
xorl %eax, %eax
cmpq %rcx, %rdx
jbe 0x374e4
movq %rcx, (%r15)
jmp 0x374e4
xorl %eax, %eax
movq 0x38(%r14), %rcx
addq 0x28(%r14), %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: MatchFinder_Construct
void MatchFinder_Construct(CMatchFinder *p)
{
  unsigned i;
  p->buffer = NULL;
  p->bufBase = NULL;
  p->directInput = 0;
  p->stream = NULL;
  p->hash = NULL;
  p->expectedDataSize = (UInt64)(Int64)-1;
  MatchFinder_SetDefaultSettings(p);

  for (i = 0; i < 256; i++)
  {
    UInt32 r = (UInt32)i;
    unsigned j;
    for (j = 0; j < 8; j++)
      r = (r >> 1) ^ (kCrcPoly & ((UInt32)0 - (r & 1)));
    p->crc[i] = r;
  }
}

// Assembly:
xorl %eax, %eax
movq %rax, (%rdi)
movb $0x0, 0x23(%rdi)
movq %rax, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq $-0x1, 0x480(%rdi)
movl $0x20, 0x3c(%rdi)
movw $0x1, 0x21(%rdi)
movl $0x4, 0x5c(%rdi)
movw $0x2, 0x70(%rdi)
movl $0x8, %ecx
movl %eax, %edx
movl %edx, %esi
shrl %esi
andl $0x1, %edx
negl %edx
andl $0xedb88320, %edx       # imm = 0xEDB88320
xorl %esi, %edx
decl %ecx
jne 0x376d6
movl %edx, 0x78(%rdi,%rax,4)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x376cf
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: MatchFinder_GetHashMask2
static UInt32 MatchFinder_GetHashMask2(CMatchFinder *p, UInt32 hs)
{
  if (p->numHashBytes == 2)
    return (1 << 16) - 1;
  if (hs != 0)
    hs--;
  hs |= (hs >> 1);
  hs |= (hs >> 2);
  hs |= (hs >> 4);
  hs |= (hs >> 8);
  // we propagated 16 bits in (hs). Low 16 bits must be set later
  if (hs >= (1 << 24))
  {
    if (p->numHashBytes == 3)
      hs = (1 << 24) - 1;
    /* if (bigHash) mode, GetHeads4b() in LzFindMt.c needs (hs >= ((1 << 24) - 1))) */
  }
  // (hash_size >= (1 << 16)) : Required for (numHashBytes > 2)
  hs |= (1 << 16) - 1; /* don't change it! */
  // bt5: we adjust the size with recommended minimum size
  if (p->numHashBytes >= 5)
    hs |= (256 << kLzHash_CrcShift_2) - 1;
  return hs;
}

// Assembly:
movl $0xffff, %eax           # imm = 0xFFFF
cmpl $0x2, %edi
je 0x37a36
xorl %eax, %eax
subl $0x1, %esi
cmovbl %eax, %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
cmpl $0x1000000, %eax        # imm = 0x1000000
movl $0xff0000, %edx         # imm = 0xFF0000
cmovbl %ecx, %edx
cmpl $0x3, %edi
cmovnel %ecx, %edx
cmpl $0x5, %edi
movl $0x3ffff, %ecx          # imm = 0x3FFFF
movl $0xffff, %eax           # imm = 0xFFFF
cmovael %ecx, %eax
orl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: MatchFinder_Init_LowHash
void MatchFinder_Init_LowHash(CMatchFinder *p)
{
  size_t i;
  CLzRef *items = p->hash;
  const size_t numItems = p->fixedHashSize;
  for (i = 0; i < numItems; i++)
    items[i] = kEmptyHashValue;
}

// Assembly:
movl 0x6c(%rdi), %edx
testq %rdx, %rdx
je 0x37aa9
movq 0x28(%rdi), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
jmp 0x41c0
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: MatchFinder_Init
void MatchFinder_Init(void *_p)
{
  CMatchFinder *p = (CMatchFinder *)_p;
  MatchFinder_Init_HighHash(p);
  MatchFinder_Init_LowHash(p);
  MatchFinder_Init_4(p);
  // if (readData)
  MatchFinder_ReadBlock(p);

  /* if we init (cyclicBufferPos = pos), then we can use one variable
     instead of both (cyclicBufferPos) and (pos) : only before (cyclicBufferPos) wrapping */
  p->cyclicBufferPos = (p->pos - CYC_TO_POS_OFFSET); // init with relation to (pos)
  // p->cyclicBufferPos = 0; // smallest value
  // p->son[0] = p->son[1] = 0; // unused: we can init skipped record for speculated accesses.
  MatchFinder_SetLimits(p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movl 0x6c(%rdi), %eax
leaq (%r14,%rax,4), %rdi
movl 0x38(%rbx), %eax
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
callq 0x41c0
movl 0x6c(%rbx), %edx
testq %rdx, %rdx
je 0x37b28
shlq $0x2, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x41c0
cmpb $0x0, 0x23(%rbx)
jne 0x37b35
movq 0x40(%rbx), %rax
movq %rax, (%rbx)
movl $0x1, %eax
movl %eax, 0x10(%rbx)
movl %eax, 0x8(%rbx)
movl $0x0, 0x74(%rbx)
movb $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x375fc
movl 0x8(%rbx), %eax
movl %eax, 0x18(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x37b65
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: MatchFinder_Normalize3
Z7_NO_INLINE
void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, size_t numItems)
{
  #define LZFIND_NORM_ALIGN_BLOCK_SIZE (1 << 7)
  Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
  for (; numItems != 0 && ((unsigned)(ptrdiff_t)items & (LZFIND_NORM_ALIGN_BLOCK_SIZE - 1)) != 0; numItems--)
  {
    SASUB_32(0)
    items++;
  }
  {
    const size_t k_Align_Mask = (LZFIND_NORM_ALIGN_BLOCK_SIZE / 4 - 1);
    CLzRef *lim = items + (numItems & ~(size_t)k_Align_Mask);
    numItems &= k_Align_Mask;
    if (items != lim)
    {
      #if defined(USE_LZFIND_SATUR_SUB_128) && !defined(FORCE_LZFIND_SATUR_SUB_128)
        if (g_LzFind_SaturSub)
          g_LzFind_SaturSub(subValue, items, lim);
        else
      #endif
          DEFAULT_SaturSub(subValue, items, lim);
    }
    items = lim;
  }
  Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
  for (; numItems != 0; numItems--)
  {
    SASUB_32(0)
    items++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %edi, %ebx
testq %rdx, %rdx
sete %al
testb $0x7f, %sil
sete %cl
orb %al, %cl
jne 0x37c0d
leaq 0x4(%rsi), %rax
xorl %ecx, %ecx
movq %r14, %rdx
movl (%rsi), %edi
subl %ebx, %edi
cmovbl %ecx, %edi
movl %edi, (%rsi)
addq $0x4, %rsi
decq %r14
cmpq $0x1, %rdx
je 0x37c0d
movl %eax, %edx
andl $0x7f, %edx
addq $0x4, %rax
testq %rdx, %rdx
jne 0x37be6
movq %r14, %rax
andq $-0x20, %rax
leaq (%rsi,%rax,4), %r15
andl $0x1f, %r14d
testq %rax, %rax
je 0x37c3b
movq 0x449b8(%rip), %rax     # 0x7c5e0
movl %ebx, %edi
movq %r15, %rdx
testq %rax, %rax
je 0x37c36
callq *%rax
jmp 0x37c3b
callq 0x37c5f
testq %r14, %r14
je 0x37c59
xorl %eax, %eax
xorl %ecx, %ecx
movl (%r15,%rcx,4), %edx
subl %ebx, %edx
cmovbl %eax, %edx
movl %edx, (%r15,%rcx,4)
incq %rcx
cmpq %rcx, %r14
jne 0x37c44
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: LzFind_SaturSub_32
Z7_FASTCALL
LzFind_SaturSub_32(UInt32 subValue, CLzRef *items, const CLzRef *lim)
{
  Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
  do
  {
    SASUB_32(0)  SASUB_32(1)  items += 2;
    SASUB_32(0)  SASUB_32(1)  items += 2;
    SASUB_32(0)  SASUB_32(1)  items += 2;
    SASUB_32(0)  SASUB_32(1)  items += 2;
  }
  while (items != lim);
}

// Assembly:
movd %edi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa 0x27d50(%rip), %xmm1    # 0x5f9c0
movdqa %xmm0, %xmm2
pxor %xmm1, %xmm2
movdqu (%rsi), %xmm3
movdqu 0x10(%rsi), %xmm4
movdqa %xmm3, %xmm5
pxor %xmm1, %xmm5
pcmpgtd %xmm2, %xmm5
psubd %xmm0, %xmm3
pand %xmm5, %xmm3
movdqu %xmm3, (%rsi)
movdqa %xmm4, %xmm3
pxor %xmm1, %xmm3
pcmpgtd %xmm2, %xmm3
psubd %xmm0, %xmm4
pand %xmm3, %xmm4
movdqu %xmm4, 0x10(%rsi)
addq $0x20, %rsi
cmpq %rdx, %rsi
jne 0x37c78
retq