LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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)
testq %rax, %rax
je 0x32538
movq %rax, %rbx
leaq 0x8(%rax), %r12
movq %r12, %rdi
callq 0x330dc
xorl %r13d, %r13d
movq %r13, 0x50(%rbx)
movq $-0x1, %rbp
movq %rbp, 0x58(%rbx)
movl $0xffffffff, 0x60(%rbx) # imm = 0xFFFFFFFF
movq %r12, %rdi
callq 0x322de
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 0x324f7
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)
jmp 0x3253a
xorl %ebx, %ebx
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_O1/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 0x3257a
movq 0x78(%rbx), %rsi
movq 0x80(%rbx), %rdx
callq 0x3375d
movq $0x0, (%rbx,%r14)
addq $0x18, %r14
cmpq $0x688, %r14            # imm = 0x688
jne 0x32559
cmpl $0x0, 0x908(%rbx)
je 0x325a6
leaq 0x910(%rbx), %rdi
callq 0x3bb55
movl $0x0, 0x908(%rbx)
movl $0x68a, %r14d           # imm = 0x68A
movq (%rbx,%r14,8), %rsi
testq %rsi, %rsi
je 0x325c4
movq 0x78(%rbx), %rdi
callq *0x8(%rdi)
movq $0x0, (%rbx,%r14,8)
incq %r14
cmpq $0x6d6, %r14            # imm = 0x6D6
jne 0x325ac
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_O1/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 0x33112
movl 0xc(%r15), %ecx
addl 0x8(%r15), %ecx
movl $0x5, %eax
cmpl $0x4, %ecx
jg 0x32652
addq $0x8, %rbx
movl $0xc, %ecx
movq %rbx, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x322de
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33221
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 0x32690
incl %eax
cmpl $0x28, %eax
jne 0x3266f
movl $0x28, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32904
movq 0x78(%rbx), %rdi
callq *(%rdi)
testq %rax, %rax
je 0x3297a
movq %rax, %r13
movq %rax, 0x3450(%rbx,%r15,8)
movq %r12, (%rsp)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x3ba84
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 0x329ed
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 0x3296b
// File: /workspace/github_cpp_makefile_star2_O1/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 0x329b8
movq %rbx, %rdx
callq *(%rdi)
xorl %ecx, %ecx
cmpq %rbx, %rax
setne %cl
leal (%rcx,%rcx,8), %eax
jmp 0x329e5
movl $0x7, %eax
cmpq 0x698(%r14), %rbx
ja 0x329e5
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_O1/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), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rdi), %rax
cmpq $-0x1, %rax
je 0x3309b
subq 0x18(%r14), %rax
cmpq %rax, %rcx
jbe 0x3309b
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x330c6
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 0x330c8
xorl %eax, %eax
movq 0x8(%rsp), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: LzmaEncProps_Init
void LzmaEncProps_Init(CLzmaEncProps *p)
{
  p->level = 5;
  p->dictSize = p->mc = 0;
  p->reduceSize = (UInt64)(Int64)-1;
  p->lc = p->lp = p->pb = p->algo = p->fb = p->btMode = p->numHashBytes = p->numThreads = -1;
  p->numHashOutBits = 0;
  p->writeEndMark = 0;
  p->affinity = 0;
}

// Assembly:
movq $0x5, (%rdi)
movq $-0x1, 0x38(%rdi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rdi)
movdqu %xmm0, 0x14(%rdi)
xorl %eax, %eax
movq %rax, 0x24(%rdi)
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movq %rcx, 0x2c(%rdi)
movq %rax, 0x40(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
testl %ecx, %ecx
movl $0x5, %eax
cmovnsl %ecx, %eax
movl %eax, (%rdi)
cmpl $0x0, 0x4(%rdi)
jne 0x3314f
cmpl $0x4, %eax
ja 0x33137
leal (%rax,%rax), %ecx
movl $0x10000, %edx          # imm = 0x10000
shll %cl, %edx
jmp 0x3314c
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 0x4(%rdi), %ecx
movq 0x38(%rdi), %rdx
cmpq %rcx, %rdx
jae 0x33170
cmpl $0x1001, %edx           # imm = 0x1001
movl $0x1000, %esi           # imm = 0x1000
cmovael %edx, %esi
cmpl %esi, %ecx
jbe 0x33170
movl %esi, 0x4(%rdi)
cmpl $0x0, 0x8(%rdi)
jns 0x3317d
movl $0x3, 0x8(%rdi)
cmpl $0x0, 0xc(%rdi)
jns 0x3318a
movl $0x0, 0xc(%rdi)
cmpl $0x0, 0x10(%rdi)
jns 0x33197
movl $0x2, 0x10(%rdi)
cmpl $0x0, 0x14(%rdi)
jns 0x331a8
xorl %ecx, %ecx
cmpl $0x5, %eax
setae %cl
movl %ecx, 0x14(%rdi)
cmpl $0x0, 0x18(%rdi)
jns 0x331bf
xorl %ecx, %ecx
cmpl $0x7, %eax
setae %cl
shll $0x5, %ecx
addl $0x20, %ecx
movl %ecx, 0x18(%rdi)
cmpl $0x0, 0x1c(%rdi)
jns 0x331d1
xorl %eax, %eax
cmpl $0x0, 0x14(%rdi)
setne %al
movl %eax, 0x1c(%rdi)
cmpl $0x0, 0x20(%rdi)
jns 0x331e3
xorl %eax, %eax
cmpl $0x1, 0x1c(%rdi)
adcl $0x4, %eax
movl %eax, 0x20(%rdi)
cmpl $0x0, 0x28(%rdi)
jne 0x331fd
movl 0x18(%rdi), %eax
shrl %eax
addl $0x10, %eax
cmpl $0x0, 0x1c(%rdi)
sete %cl
shrl %cl, %eax
movl %eax, 0x28(%rdi)
cmpl $0x0, 0x30(%rdi)
js 0x33204
retq
cmpl $0x0, 0x1c(%rdi)
je 0x33218
cmpl $0x1, 0x14(%rdi)
movl $0x2, %eax
sbbl $0x0, %eax
jmp 0x3321d
movl $0x1, %eax
movl %eax, 0x30(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3374f
pxor %xmm0, %xmm0
movdqu %xmm0, 0x98(%rbx)
leaq 0x628(%rbx), %r14
movq %r14, %rdi
callq 0x379f1
leaq 0x100(%rbx), %rdi
movq %r14, 0x620(%rbx)
callq 0x3a0b4
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 0x334f0
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 0x336cb
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 0x3371e
movl %esi, %edi
shrl %edi
incl %ecx
cmpl $0x1ffff, %esi          # imm = 0x1FFFF
movl %edi, %esi
ja 0x3370e
jmp 0x33720
movl %esi, %edi
incl %edx
movl %edi, %esi
cmpl $0x4, %edx
jne 0x336ff
movl $0xa1, %edx
subl %ecx, %edx
movl %edx, 0xb30(%rbx,%rax,4)
incq %rax
cmpq $0x80, %rax
jne 0x336f3
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_O1/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        # 0x33b8b
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 0x33afc
movq %r15, %rdi
callq 0x33bcd
movq %r15, %rdi
callq 0x33dab
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 0x33e48
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_O1/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 0x33ba9
movl $0x1, 0x18(%r14)
movq %rax, %rbx
testq %rbx, %rbx
je 0x33bc2
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_O1/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 0x33dce
movq %rbx, %rdi
callq 0x36896
movq %rbx, %rdi
callq 0x36bb0
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 0x36c8a
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 0x36c8a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33e48
testl %eax, %eax
je 0x3664a
movl %eax, %ebp
cmpl $0x0, 0xfc(%rbx)
je 0x36643
addq $0x100, %rbx            # imm = 0x100
movq %rbx, %rdi
callq 0x3a14c
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
cmpl $0x0, 0xd4(%rbx)
jne 0x3662b
testq %r14, %r14
je 0x36687
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 0x36699
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33e48
testl %eax, %eax
je 0x3664c
jmp 0x36629
movl $0xa, %ebp
jmp 0x3662b
// File: /workspace/github_cpp_makefile_star2_O1/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 -0x2baa(%rip), %rdi     # 0x33b8b
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 0x337ee
testl %eax, %eax
jne 0x367b7
movq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x36612
testl %eax, %eax
jne 0x367b7
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_O1/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 0x33628
testq %rax, %rax
je 0x36847
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x334f0
testl %eax, %eax
jne 0x3682b
movq 0x40(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x366a0
testl %eax, %eax
je 0x3685d
movl %eax, %ebx
movq 0x58(%rsp), %r15
movq 0x60(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3375d
jmp 0x3684c
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 0x36712
addq $0x20, %rsp
movl %eax, %ebx
jmp 0x36837
// File: /workspace/github_cpp_makefile_star2_O1/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: FillAlignPrices
Z7_NO_INLINE static void FillAlignPrices(CLzmaEnc *p)
{
  unsigned i;
  const CProbPrice *ProbPrices = p->ProbPrices;
  const CLzmaProb *probs = p->posAlignEncoder;
  // p->alignPriceCount = 0;
  for (i = 0; i < kAlignTableSize / 2; i++)
  {
    UInt32 price = 0;
    unsigned sym = i;
    unsigned m = 1;
    unsigned bit;
    UInt32 prob;
    bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;
    bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;
    bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;
    prob = probs[m];
    p->alignPrices[i    ] = price + GET_PRICEa_0(prob);
    p->alignPrices[i + 8] = price + GET_PRICEa_1(prob);
    // p->alignPrices[i] = RcTree_ReverseGetPrice(p->posAlignEncoder, kNumAlignBits, i, p->ProbPrices);
  }
}

// Assembly:
pushq %rbx
movzwl 0x2202(%rdi), %eax
xorl %ecx, %ecx
movl $0x7f0, %edx            # imm = 0x7F0
movl %ecx, %esi
andl $0x1, %esi
movl %ecx, %r8d
shrl %r8d
andl $0x1, %r8d
leal 0x4(,%rsi,2), %r10d
leal (%r8,%rsi,2), %r9d
addl $0x4, %r9d
movl %esi, %r11d
negl %r11d
andl %edx, %r11d
xorl %eax, %r11d
shrl $0x4, %r11d
negl %r8d
movl %ecx, %ebx
shrl $0x2, %ebx
movzwl 0x2200(%rdi,%r10), %esi
andl %edx, %r8d
xorl %esi, %r8d
shrl $0x4, %r8d
movl 0xb30(%rdi,%r8,4), %esi
addl 0xb30(%rdi,%r11,4), %esi
leal (%r9,%r9), %r8d
movzwl 0x2200(%rdi,%r8), %r8d
leal (%rbx,%r9,2), %r9d
negl %ebx
andl %edx, %ebx
xorl %r8d, %ebx
shrl $0x2, %ebx
andl $0x3ffc, %ebx           # imm = 0x3FFC
addl 0xb30(%rdi,%rbx), %esi
movzwl 0x2200(%rdi,%r9,2), %r8d
shrl $0x2, %r8d
andl $-0x4, %r8d
movl 0xb30(%rdi,%r8), %r9d
addl %esi, %r9d
movl %r9d, 0x15c0(%rdi,%rcx,4)
xorl $0x1fc, %r8d            # imm = 0x1FC
addl 0xb30(%rdi,%r8), %esi
movl %esi, 0x15e0(%rdi,%rcx,4)
incq %rcx
cmpq $0x8, %rcx
jne 0x36bbf
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %r9d, %r9d
movl %r9d, %r10d
shrl $0x2, %r10d
movzwl 0x4(%rdi,%r10,2), %r11d
negl %r10d
andl $0x7f0, %r10d           # imm = 0x7F0
xorl %eax, %r10d
shrl $0x4, %r10d
movl (%rcx,%r10,4), %r10d
addl %esi, %r10d
testb $0x2, %r9b
movl $0x7f0, %ebx            # imm = 0x7F0
cmovel %r8d, %ebx
xorl %r11d, %ebx
shrl $0x4, %ebx
addl (%rcx,%rbx,4), %r10d
movzwl 0x8(%rdi,%r9), %r11d
shrl $0x2, %r11d
andl $-0x4, %r11d
movl (%rcx,%r11), %ebx
addl %r10d, %ebx
movl %ebx, (%rdx,%r9,4)
xorl $0x1fc, %r11d           # imm = 0x1FC
addl (%rcx,%r11), %r10d
movl %r10d, 0x4(%rdx,%r9,4)
leaq 0x2(%r9), %r10
cmpq $0x6, %r9
movq %r10, %r9
jb 0x36e31
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x370b4
movl %esi, %r15d
andl 0x64(%rbx), %r15d
leaq 0x70(%rbx), %r14
movl 0x44(%rbx), %eax
movl 0x70(%rbx), %ebp
shlq $0x5, %rax
addq %rbx, %rax
movzwl 0x2280(%rax,%r15,2), %ecx
movl %ebp, %edx
shrl $0xb, %edx
imull %ecx, %edx
subl %edx, %ebp
addq %rdx, 0x78(%rbx)
movl %ecx, %edx
shrl $0x5, %edx
subl %edx, %ecx
movw %cx, 0x2280(%rax,%r15,2)
cmpl $0xffffff, %ebp         # imm = 0xFFFFFF
ja 0x36f7b
shll $0x8, %ebp
movq %r14, %rdi
callq 0x3721d
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 0x36fb3
shll $0x8, %ebp
movq %r14, %rdi
callq 0x3721d
movl 0x44(%rbx), %eax
leaq 0x289d7(%rip), %rcx     # 0x5f994
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 0x372ab
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 0x37024
shll $0x8, %r15d
movq %r14, %rdi
callq 0x3721d
leal 0x1(,%r12,2), %eax
cmpl $0x20, %r12d
movl %eax, %r12d
jb 0x36fe5
movl $0xffffffe6, %ebp       # imm = 0xFFFFFFE6
movl %r15d, %eax
shrl %r15d
addq %r15, 0x78(%rbx)
cmpl $0x1ffffff, %eax        # imm = 0x1FFFFFF
ja 0x37057
shll $0x8, %r15d
movq %r14, %rdi
callq 0x3721d
incl %ebp
jne 0x3703a
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 0x370a0
shll $0x8, %r15d
movq %r14, %rdi
callq 0x3721d
leal 0x1(,%r12,2), %eax
cmpl $0x8, %r12d
movl %eax, %r12d
jb 0x37061
movl %r15d, (%r14)
leaq 0x70(%rbx), %r14
movl $0x5, %ebp
movq %r14, %rdi
callq 0x3721d
decl %ebp
jne 0x370bd
movq %r14, %rdi
callq 0x374db
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x36ea5
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37180
movl %eax, %r12d
movl 0xd28(%rbx,%r12,4), %r14d
cmpl 0x48(%rbx), %r14d
jne 0x37183
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 0x37179
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 0x37179
incq %rdx
decq %r15
jne 0x37164
movq %rax, %rdx
subl %ecx, %edx
movl %edx, %r14d
jmp 0x37183
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: LitEnc_Encode
static void LitEnc_Encode(CRangeEnc *p, CLzmaProb *probs, UInt32 sym)
{
  UInt32 range = p->range;
  sym |= 0x100;
  do
  {
    UInt32 ttt, newBound;
    // RangeEnc_EncodeBit(p, probs + (sym >> 8), (sym >> 7) & 1);
    CLzmaProb *prob = probs + (sym >> 8);
    UInt32 bit = (sym >> 7) & 1;
    sym <<= 1;
    RC_BIT(p, prob, bit)
  }
  while (sym < 0x10000);
  p->range = range;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %ebp
orl $0x100, %ebx            # imm = 0x100
movl %ebx, %eax
shrl $0x7, %eax
movl %eax, %ecx
andl $-0x2, %ecx
andl $0x1, %eax
movzwl (%r15,%rcx), %edx
movl %ebp, %esi
shrl $0xb, %esi
imull %edx, %esi
movl %eax, %edi
negl %edi
andl %edi, %ebp
andl %esi, %edi
movl %ebp, %r8d
addq %rdi, 0x8(%r14)
subl %edi, %r8d
decl %eax
andl %eax, %esi
movl %esi, %ebp
addl %r8d, %ebp
andl $0x7e1, %eax            # imm = 0x7E1
subl %edx, %eax
addl $0x1f, %eax
shrl $0x5, %eax
addl %edx, %eax
movw %ax, (%r15,%rcx)
cmpl $0xffffff, %ebp         # imm = 0xFFFFFF
ja 0x37205
shll $0x8, %ebp
movq %r14, %rdi
callq 0x3721d
addl %ebx, %ebx
cmpl $0x10000, %ebx          # imm = 0x10000
jb 0x371a9
movl %ebp, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3729f
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 0x37271
movq %rbx, %rdi
callq 0x374db
cmpq $0x0, 0x10(%rbx)
je 0x372a3
decb %r14b
movq 0x18(%rbx), %rax
movb %r14b, (%rax)
incq %rax
movq %rax, 0x18(%rbx)
cmpq 0x20(%rbx), %rax
jne 0x37297
movq %rbx, %rdi
callq 0x374db
decq 0x10(%rbx)
jne 0x3727b
jmp 0x372a3
incq 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37508
movq 0x30(%rbx), %rdi
movq %r14, %rdx
callq *(%rdi)
cmpq %rax, %r14
je 0x37508
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_O1/sisong[P]ApkDiffPatch/lzma/C/LzmaEnc.c
// Function: LitEnc_Matched_GetPrice
static UInt32 LitEnc_Matched_GetPrice(const CLzmaProb *probs, UInt32 sym, UInt32 matchByte, const CProbPrice *ProbPrices)
{
  UInt32 price = 0;
  UInt32 offs = 0x100;
  sym |= 0x100;
  do
  {
    matchByte <<= 1;
    price += GET_PRICEa(probs[offs + (matchByte & offs) + (sym >> 8)], (sym >> 7) & 1);
    sym <<= 1;
    offs &= ~(matchByte ^ sym);
  }
  while (sym < 0x10000);
  return price;
}

// Assembly:
orl $0x100, %esi            # imm = 0x100
movl $0x100, %r8d            # imm = 0x100
xorl %eax, %eax
addl %edx, %edx
movl %r8d, %r9d
andl %edx, %r9d
movl %esi, %r10d
shrl $0x8, %r10d
addl %r8d, %r10d
addl %r9d, %r10d
movzwl (%rdi,%r10,2), %r9d
movsbl %sil, %r10d
shrl $0x7, %r10d
andl $0x7f0, %r10d           # imm = 0x7F0
xorl %r9d, %r10d
shrl $0x4, %r10d
addl (%rcx,%r10,4), %eax
addl %esi, %esi
movl %edx, %r9d
xorl %esi, %r9d
notl %r9d
andl %r9d, %r8d
cmpl $0x10000, %esi          # imm = 0x10000
jb 0x3752a
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x375d0
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 0x375d2
addq %rcx, %r14
subq %rcx, %r13
testq %rcx, %rcx
jne 0x37599
jmp 0x375d2
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_O1/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 0x37669
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 0x3765f
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_O1/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
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsp, %r13
testq %r14, %r14
je 0x376c4
movq %r14, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *0x10(%r12)
testl %eax, %eax
cmovnel %eax, %ebp
je 0x376a7
xorl %eax, %eax
jmp 0x376be
movq (%rsp), %rax
testq %rax, %rax
je 0x376ba
addq %rax, %r15
subq %rax, %r14
movb $0x1, %al
jmp 0x376be
xorl %eax, %eax
movl %ebx, %ebp
testb %al, %al
jne 0x37685
jmp 0x376c6
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_O1/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 0xa4(%rip), %rax        # 0x377f0
leaq 0x29(%rip), %rcx        # 0x3777c
cmoveq %rax, %rcx
movq %rcx, (%rdi)
leaq 0xf8(%rip), %rax        # 0x37859
movq %rax, 0x8(%rdi)
leaq 0xf4(%rip), %rax        # 0x37860
movq %rax, 0x10(%rdi)
leaq 0x13d(%rip), %rax       # 0x378b4
movq %rax, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq 0x28(%rdi), %rcx
movq %rcx, (%rsp)
jne 0x377cd
cmpq $0x0, (%r15)
je 0x377cd
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 (%rsp), %rcx
cmpq %rcx, (%r15)
jbe 0x377d9
movq %rcx, (%r15)
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_O1/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
xorl %eax, %eax
subq 0x28(%rdi), %rcx
jne 0x37840
cmpq $0x0, (%r15)
je 0x3783c
leaq 0x28(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x40(%r14), %rax
cmpq %rax, (%r15)
jbe 0x37826
movq %rax, (%r15)
movq 0x20(%r14), %rdi
movq 0x38(%r14), %rsi
movq %r15, %rdx
callq *(%rdi)
movq (%r15), %rcx
movq %rcx, 0x30(%r14)
jmp 0x37840
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, (%r15)
jbe 0x37848
movq %rcx, (%r15)
movq 0x38(%r14), %rcx
addq 0x28(%r14), %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/sisong[P]ApkDiffPatch/lzma/C/7zStream.c
// Function: LookToRead2_Read
static SRes LookToRead2_Read(ILookInStreamPtr pp, void *buf, size_t *size)
{
  GET_LookToRead2
  size_t rem = p->size - p->pos;
  if (rem == 0)
    return ISeekInStream_Read(p->realStream, buf, size);
  if (rem > *size)
    rem = *size;
  memcpy(buf, p->buf + p->pos, rem);
  p->pos += rem;
  *size = rem;
  return SZ_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rcx
subq %rax, %rcx
jne 0x37889
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq (%rbx), %r15
cmpq %r15, %rcx
cmovbq %rcx, %r15
addq 0x38(%r14), %rax
movq %rsi, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x4290
addq %r15, 0x28(%r14)
movq %r15, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: MatchFinder_MoveBlock
Z7_NO_INLINE
void MatchFinder_MoveBlock(CMatchFinder *p)
{
  const size_t offset = (size_t)(p->buffer - p->bufBase) - p->keepSizeBefore;
  const size_t keepBefore = (offset & (kBlockMoveAlign - 1)) + p->keepSizeBefore;
  p->buffer = p->bufBase + keepBefore;
  memmove(p->bufBase,
      p->bufBase + (offset & ~((size_t)kBlockMoveAlign - 1)),
      keepBefore + (size_t)GET_AVAIL_BYTES(p));
}

// Assembly:
movq (%rdi), %rsi
movq 0x40(%rdi), %rax
movl 0x54(%rdi), %ecx
subq %rax, %rsi
subq %rcx, %rsi
movl %esi, %r8d
andl $0x7f, %r8d
addq %rcx, %r8
leaq (%rax,%r8), %rcx
movq %rcx, (%rdi)
andq $-0x80, %rsi
addq %rax, %rsi
movl 0x10(%rdi), %edx
subl 0x8(%rdi), %edx
addq %r8, %rdx
movq %rax, %rdi
jmp 0x4510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37a31
movl %edx, 0x78(%rdi,%rax,4)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x37a2a
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c(%rdi), %ecx
movl $0xffff, %eax           # imm = 0xFFFF
cmpl $0x2, %ecx
je 0x37d7d
xorl %eax, %eax
subl $0x1, %esi
cmovbl %eax, %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %edx
shrl $0x2, %edx
orl %eax, %edx
movl %edx, %eax
shrl $0x4, %eax
orl %edx, %eax
movl %eax, %edx
shrl $0x8, %edx
orl %eax, %edx
cmpl $0x3, %ecx
movl $0xff0000, %esi         # imm = 0xFF0000
cmovnel %edx, %esi
cmpl $0x1000000, %eax        # imm = 0x1000000
cmovbl %edx, %esi
cmpl $0x5, %ecx
movl $0x3ffff, %ecx          # imm = 0x3FFFF
movl $0xffff, %eax           # imm = 0xFFFF
cmovael %ecx, %eax
orl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37df3
movq 0x28(%rdi), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
jmp 0x41c0
retq
// File: /workspace/github_cpp_makefile_star2_O1/sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: MatchFinder_Init_HighHash
void MatchFinder_Init_HighHash(CMatchFinder *p)
{
  size_t i;
  CLzRef *items = p->hash + p->fixedHashSize;
  const size_t numItems = (size_t)p->hashMask + 1;
  for (i = 0; i < numItems; i++)
    items[i] = kEmptyHashValue;
}

// Assembly:
movl 0x38(%rdi), %ecx
movl 0x6c(%rdi), %eax
shlq $0x2, %rax
addq 0x28(%rdi), %rax
leaq 0x4(,%rcx,4), %rdx
movq %rax, %rdi
xorl %esi, %esi
jmp 0x41c0