LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %eax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x6fbee
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6fbc7
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x6c(%rcx), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x6fc50
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6fc29
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: MatchFinder_Init_4
void MatchFinder_Init_4(CMatchFinder *p)
{
  if (!p->directInput)
    p->buffer = p->bufBase;
  {
    /* kEmptyHashValue = 0 (Zero) is used in hash tables as NO-VALUE marker.
       the code in CMatchFinderMt expects (pos = 1) */
    p->pos =
    p->streamPos =
        1; // it's smallest optimal value. do not change it
        // 0; // for debug
  }
  p->result = SZ_OK;
  p->streamEndWasReached = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x23(%rax)
jne 0x6fc81
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x74(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6fbf0
movq -0x10(%rbp), %rdi
callq 0x6fba0
movq -0x10(%rbp), %rdi
callq 0x6fc60
movq -0x10(%rbp), %rdi
callq 0x6f170
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
subl $0x0, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x6fd10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: MatchFinder_SetLimits
static void MatchFinder_SetLimits(CMatchFinder *p)
{
  UInt32 k;
  UInt32 n = kMaxValForNormalize - p->pos;
  if (n == 0)
    n = (UInt32)(Int32)-1;  // we allow (pos == 0) at start even with (kMaxValForNormalize == 0)
  
  k = p->cyclicBufferSize - p->cyclicBufferPos;
  if (k < n)
    n = k;

  k = GET_AVAIL_BYTES(p);
  {
    const UInt32 ksa = p->keepSizeAfter;
    UInt32 mm = p->matchMaxLen;
    if (k > ksa)
      k -= ksa; // we must limit exactly to keepSizeAfter for ReadBlock
    else if (k >= mm)
    {
      // the limitation for (p->lenLimit) update
      k -= mm;   // optimization : to reduce the number of checks
      k++;
      // k = 1; // non-optimized version : for debug
    }
    else
    {
      mm = k;
      if (k != 0)
        k = 1;
    }
    p->lenLimit = mm;
  }
  if (k < n)
    n = k;
  
  p->posLimit = p->pos + n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subl 0x8(%rcx), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x6fd31
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x18(%rcx), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x6fd50
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x6fd8a
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x6fdbf
movl -0xc(%rbp), %eax
cmpl -0x18(%rbp), %eax
jb 0x6fda8
movl -0x18(%rbp), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6fdbd
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x6fdbb
movl $0x1, -0xc(%rbp)
jmp 0x6fdbd
jmp 0x6fdbf
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x6fdd7
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x35(%rbp)
je 0x6fe1f
movq -0x10(%rbp), %rax
andl $0x7f, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x6fe28
jmp 0x6fe65
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x6fe3f
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
subl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6fe03
movq $0x1f, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
andq $-0x20, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
andq $0x1f, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x6fecc
cmpq $0x0, 0x767ee(%rip)     # 0xe6690
je 0x6feba
movq 0x767e5(%rip), %rax     # 0xe6690
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq *%rax
jmp 0x6feca
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x6ff20
jmp 0x6fecc
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6ff18
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x6fef2
movl -0x4(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
subl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6fed4
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x6ff46
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
subl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x6ff6a
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
subl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x6ff9a
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
subl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x6ffbe
movl -0x4(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
subl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x6ffee
movl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
subl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x70012
movl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
subl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x70042
movl -0x4(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
subl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x70066
movl -0x4(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %ecx
subl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x6ff2f
popq %rbp
retq
nop
// File: sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: Bt3Zip_MatchFinder_Skip
void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
{
  SKIP_HEADER(3)
  {
    HASH_ZIP_CALC
    curMatch = p->hash[hv];
    p->hash[hv] = p->pos;
  }
  SKIP_FOOTER
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jae 0x70cad
movq -0x8(%rbp), %rdi
callq 0x707d0
jmp 0x70d95
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzbl 0x1(%rdx), %edx
xorl 0x78(%rcx,%rdx,4), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x10(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x10(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %edi
movl -0x1c(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %r9d
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %r10d
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x70db0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x70d93
movq -0x8(%rbp), %rdi
callq 0x70830
jmp 0x70d95
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x70c8f
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: Hc3Zip_MatchFinder_Skip
void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
{
  HC_SKIP_HEADER(3)

    HASH_ZIP_CALC
    curMatch = hash[hv];
    hash[hv] = pos;

  HC_SKIP_FOOTER
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x14(%rax)
jae 0x71000
movq -0x8(%rbp), %rdi
callq 0x707d0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x71123
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x34(%rbp), %eax
jbe 0x7102b
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x38(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x38(%rbp), %ecx
addl -0x30(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzbl 0x1(%rdx), %edx
xorl 0x78(%rcx,%rdx,4), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl -0x40(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rax
movl -0x40(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x3c(%rbp), %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
jne 0x7107a
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x71121
movq -0x8(%rbp), %rdi
callq 0x70830
jmp 0x71123
cmpl $0x0, -0xc(%rbp)
jne 0x70fdf
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: MatchFinder_CreateVTable
void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder2 *vTable)
{
  vTable->Init = MatchFinder_Init;
  vTable->GetNumAvailableBytes = MatchFinder_GetNumAvailableBytes;
  vTable->GetPointerToCurrentPos = MatchFinder_GetPointerToCurrentPos;
  if (!p->btMode)
  {
    if (p->numHashBytes <= 4)
    {
      vTable->GetMatches = Hc4_MatchFinder_GetMatches;
      vTable->Skip = Hc4_MatchFinder_Skip;
    }
    else
    {
      vTable->GetMatches = Hc5_MatchFinder_GetMatches;
      vTable->Skip = Hc5_MatchFinder_Skip;
    }
  }
  else if (p->numHashBytes == 2)
  {
    vTable->GetMatches = Bt2_MatchFinder_GetMatches;
    vTable->Skip = Bt2_MatchFinder_Skip;
  }
  else if (p->numHashBytes == 3)
  {
    vTable->GetMatches = Bt3_MatchFinder_GetMatches;
    vTable->Skip = Bt3_MatchFinder_Skip;
  }
  else if (p->numHashBytes == 4)
  {
    vTable->GetMatches = Bt4_MatchFinder_GetMatches;
    vTable->Skip = Bt4_MatchFinder_Skip;
  }
  else
  {
    vTable->GetMatches = Bt5_MatchFinder_GetMatches;
    vTable->Skip = Bt5_MatchFinder_Skip;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq -0x14a7(%rip), %rcx     # 0x6fcb0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x11b(%rip), %rcx       # 0x71280
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x12c(%rip), %rcx       # 0x712a0
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x21(%rax)
jne 0x711cf
movq -0x8(%rbp), %rax
cmpl $0x4, 0x5c(%rax)
ja 0x711ac
movq -0x10(%rbp), %rax
leaq 0x129(%rip), %rcx       # 0x712c0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x86a(%rip), %rcx       # 0x71a10
movq %rcx, 0x20(%rax)
jmp 0x711ca
movq -0x10(%rbp), %rax
leaq 0xa29(%rip), %rcx       # 0x71be0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x11ca(%rip), %rcx      # 0x72390
movq %rcx, 0x20(%rax)
jmp 0x71271
movq -0x8(%rbp), %rax
cmpl $0x2, 0x5c(%rax)
jne 0x711f9
movq -0x10(%rbp), %rax
leaq 0x139c(%rip), %rcx      # 0x72580
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x17fd(%rip), %rcx      # 0x729f0
movq %rcx, 0x20(%rax)
jmp 0x7126f
movq -0x8(%rbp), %rax
cmpl $0x3, 0x5c(%rax)
jne 0x71223
movq -0x10(%rbp), %rax
leaq 0x1902(%rip), %rcx      # 0x72b10
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x2063(%rip), %rcx      # 0x73280
movq %rcx, 0x20(%rax)
jmp 0x7126d
movq -0x8(%rbp), %rax
cmpl $0x4, 0x5c(%rax)
jne 0x7124d
movq -0x10(%rbp), %rax
leaq 0x21a8(%rip), %rcx      # 0x733e0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x2a89(%rip), %rcx      # 0x73cd0
movq %rcx, 0x20(%rax)
jmp 0x7126b
movq -0x10(%rbp), %rax
leaq 0x2c18(%rip), %rcx      # 0x73e70
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x3559(%rip), %rcx      # 0x747c0
movq %rcx, 0x20(%rax)
jmp 0x7126d
jmp 0x7126f
jmp 0x71271
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: Bt2_MatchFinder_Skip
static void Bt2_MatchFinder_Skip(void *_p, UInt32 num)
{
  CMatchFinder *p = (CMatchFinder *)_p;
  SKIP_HEADER(2)
  {
    HASH2_CALC
    curMatch = p->hash[hv];
    p->hash[hv] = p->pos;
  }
  SKIP_FOOTER
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $0x2, -0x30(%rbp)
jae 0x72a25
movq -0x18(%rbp), %rdi
callq 0x707d0
jmp 0x72aeb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x1c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %r9d
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %r10d
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x70db0
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x34(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x72ae9
movq -0x18(%rbp), %rdi
callq 0x70830
jmp 0x72aeb
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x72a07
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: Bt3_MatchFinder_Skip
static void Bt3_MatchFinder_Skip(void *_p, UInt32 num)
{
  CMatchFinder *p = (CMatchFinder *)_p;
  SKIP_HEADER(3)
  {
    UInt32 h2;
    UInt32 *hash;
    HASH3_CALC
    hash = p->hash;
    curMatch = (hash + kFix3HashSize)[hv];
    hash[h2] =
    (hash + kFix3HashSize)[hv] = p->pos;
  }
  SKIP_FOOTER
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $0x3, -0x30(%rbp)
jae 0x732b5
movq -0x18(%rbp), %rdi
callq 0x707d0
jmp 0x733c8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movl 0x78(%rax,%rcx,4), %eax
movq -0x28(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
xorl %ecx, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x34(%rbp)
movl -0x44(%rbp), %eax
movq -0x28(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
xorl %ecx, %eax
movq -0x18(%rbp), %rcx
andl 0x38(%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl 0x1000(%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %edx, 0x1000(%rax,%rcx,4)
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %r9d
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %r10d
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x70db0
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x48(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x733c6
movq -0x18(%rbp), %rdi
callq 0x70830
jmp 0x733c8
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x73297
addq $0x60, %rsp
popq %rbp
retq
// File: sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: Bt4_MatchFinder_Skip
static void Bt4_MatchFinder_Skip(void *_p, UInt32 num)
{
  CMatchFinder *p = (CMatchFinder *)_p;
  SKIP_HEADER(4)
  {
    UInt32 h2, h3;
    UInt32 *hash;
    HASH4_CALC
    hash = p->hash;
    curMatch = (hash + kFix4HashSize)[hv];
    hash                  [h2] =
    (hash + kFix3HashSize)[h3] =
    (hash + kFix4HashSize)[hv] = p->pos;
  }
  SKIP_FOOTER
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $0x4, -0x30(%rbp)
jae 0x73d05
movq -0x18(%rbp), %rdi
callq 0x707d0
jmp 0x73e4a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movl 0x78(%rax,%rcx,4), %eax
movq -0x28(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
xorl %ecx, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x8, %eax
xorl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x38(%rbp)
movl -0x44(%rbp), %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl 0x3(%rdx), %edx
movl 0x78(%rcx,%rdx,4), %ecx
shll $0x5, %ecx
xorl %ecx, %eax
movq -0x18(%rbp), %rcx
andl 0x38(%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl 0x41000(%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %edx, 0x41000(%rax,%rcx,4)
movq -0x40(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %edx, 0x1000(%rax,%rcx,4)
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %r9d
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %r10d
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x70db0
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x48(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x73e48
movq -0x18(%rbp), %rdi
callq 0x70830
jmp 0x73e4a
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x73ce7
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: Bt5_MatchFinder_Skip
static void Bt5_MatchFinder_Skip(void *_p, UInt32 num)
{
  CMatchFinder *p = (CMatchFinder *)_p;
  SKIP_HEADER(5)
  {
    UInt32 h2, h3;
    UInt32 *hash;
    HASH5_CALC
    hash = p->hash;
    curMatch = (hash + kFix5HashSize)[hv];
    hash                  [h2] =
    (hash + kFix3HashSize)[h3] =
    // (hash + kFix4HashSize)[h4] =
    (hash + kFix5HashSize)[hv] = p->pos;
  }
  SKIP_FOOTER
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $0x5, -0x30(%rbp)
jae 0x747f5
movq -0x18(%rbp), %rdi
callq 0x707d0
jmp 0x74953
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movl 0x78(%rax,%rcx,4), %eax
movq -0x28(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
xorl %ecx, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x8, %eax
xorl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
movl 0x78(%rax,%rcx,4), %eax
shll $0x5, %eax
xorl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl 0x4(%rdx), %edx
movl 0x78(%rcx,%rdx,4), %ecx
shll $0xa, %ecx
xorl %ecx, %eax
movq -0x18(%rbp), %rcx
andl 0x38(%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl 0x41000(%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %edx, 0x41000(%rax,%rcx,4)
movq -0x40(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %edx, 0x1000(%rax,%rcx,4)
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %r9d
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %r10d
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x70db0
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x48(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x74951
movq -0x18(%rbp), %rdi
callq 0x70830
jmp 0x74953
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x747d7
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFind.c
// Function: LzFind_SaturSub_128
void
Z7_FASTCALL
LzFind_SaturSub_128(UInt32 subValue, CLzRef *items, const CLzRef *lim)
{
  const LzFind_v128 sub2 =
    #ifdef MY_CPU_ARM_OR_ARM64
      vdupq_n_u32(subValue);
    #else
      _mm_set_epi32((Int32)subValue, (Int32)subValue, (Int32)subValue, (Int32)subValue);
    #endif
  Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
  do
  {
    SASUB_128(0)  SASUB_128(1)  items += 2 * 4;
    SASUB_128(0)  SASUB_128(1)  items += 2 * 4;
  }
  while (items != lim);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x124(%rbp)
movq %rsi, -0x130(%rbp)
movq %rdx, -0x138(%rbp)
movl -0x124(%rbp), %eax
movl %eax, -0x104(%rbp)
movl %eax, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
movl %eax, -0x110(%rbp)
movl -0x10c(%rbp), %edx
movl -0x108(%rbp), %ecx
movl -0x104(%rbp), %eax
movd -0x110(%rbp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movdqa %xmm0, -0x120(%rbp)
movdqa -0x120(%rbp), %xmm0
movdqa %xmm0, -0x150(%rbp)
movq -0x130(%rbp), %rax
movdqa (%rax), %xmm1
movdqa -0x150(%rbp), %xmm0
movdqa %xmm1, -0x10(%rbp)
movdqa %xmm0, -0x20(%rbp)
movdqa -0x10(%rbp), %xmm1
movdqa -0x20(%rbp), %xmm0
pmaxud %xmm0, %xmm1
movdqa -0x150(%rbp), %xmm0
movdqa %xmm1, -0x90(%rbp)
movdqa %xmm0, -0xa0(%rbp)
movdqa -0x90(%rbp), %xmm0
movdqa -0xa0(%rbp), %xmm1
psubd %xmm1, %xmm0
movq -0x130(%rbp), %rax
movdqa %xmm0, (%rax)
movq -0x130(%rbp), %rax
movdqa 0x10(%rax), %xmm1
movdqa -0x150(%rbp), %xmm0
movdqa %xmm1, -0x30(%rbp)
movdqa %xmm0, -0x40(%rbp)
movdqa -0x30(%rbp), %xmm1
movdqa -0x40(%rbp), %xmm0
pmaxud %xmm0, %xmm1
movdqa -0x150(%rbp), %xmm0
movdqa %xmm1, -0xb0(%rbp)
movdqa %xmm0, -0xc0(%rbp)
movdqa -0xb0(%rbp), %xmm0
movdqa -0xc0(%rbp), %xmm1
psubd %xmm1, %xmm0
movq -0x130(%rbp), %rax
movdqa %xmm0, 0x10(%rax)
movq -0x130(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rax
movdqa (%rax), %xmm1
movdqa -0x150(%rbp), %xmm0
movdqa %xmm1, -0x50(%rbp)
movdqa %xmm0, -0x60(%rbp)
movdqa -0x50(%rbp), %xmm1
movdqa -0x60(%rbp), %xmm0
pmaxud %xmm0, %xmm1
movdqa -0x150(%rbp), %xmm0
movdqa %xmm1, -0xd0(%rbp)
movdqa %xmm0, -0xe0(%rbp)
movdqa -0xd0(%rbp), %xmm0
movdqa -0xe0(%rbp), %xmm1
psubd %xmm1, %xmm0
movq -0x130(%rbp), %rax
movdqa %xmm0, (%rax)
movq -0x130(%rbp), %rax
movdqa 0x10(%rax), %xmm1
movdqa -0x150(%rbp), %xmm0
movdqa %xmm1, -0x70(%rbp)
movdqa %xmm0, -0x80(%rbp)
movdqa -0x70(%rbp), %xmm1
movdqa -0x80(%rbp), %xmm0
pmaxud %xmm0, %xmm1
movdqa -0x150(%rbp), %xmm0
movdqa %xmm1, -0xf0(%rbp)
movdqa %xmm0, -0x100(%rbp)
movdqa -0xf0(%rbp), %xmm0
movdqa -0x100(%rbp), %xmm1
psubd %xmm1, %xmm0
movq -0x130(%rbp), %rax
movdqa %xmm0, 0x10(%rax)
movq -0x130(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rax
cmpq -0x138(%rbp), %rax
jne 0x74a41
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFindMt.c
// Function: MtSync_Construct
Z7_NO_INLINE
static void MtSync_Construct(CMtSync *p)
{
  p->affinity = 0;
  p->wasCreated = False;
  p->csWasInitialized = False;
  p->csWasEntered = False;
  Thread_CONSTRUCT(&p->thread)
  Event_Construct(&p->canStart);
  Event_Construct(&p->wasStopped);
  Semaphore_Construct(&p->freeSemaphore);
  Semaphore_Construct(&p->filledSemaphore);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xa0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x108(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x170(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFindMt.c
// Function: MtSync_Destruct
Z7_NO_INLINE
static void MtSync_Destruct(CMtSync *p)
{
    PRF(printf("\nMtSync_Destruct %p\n", p));
  
  if (Thread_WasCreated(&p->thread))
  {
    /* we want thread to be in Stopped state before sending EXIT command.
       note: stop(btSync) will stop (htSync) also */
    MtSync_StopWriting(p);
    /* thread in Stopped state here : (p->needStart == true) */
    p->exit = True;
    // if (p->needStart)  // it's (true)
    Event_Set(&p->canStart);  // we send EXIT command to thread
    Thread_Wait_Close(&p->thread);  // we wait thread finishing
  }

  if (p->csWasInitialized)
  {
    CriticalSection_Delete(&p->cs);
    p->csWasInitialized = False;
  }
  p->csWasEntered = False;

  Event_Close(&p->canStart);
  Event_Close(&p->wasStopped);
  Semaphore_Close(&p->freeSemaphore);
  Semaphore_Close(&p->filledSemaphore);

  p->wasCreated = False;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x755c4
movq -0x8(%rbp), %rdi
callq 0x759f0
movq -0x8(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x7b600
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x7b460
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x755e9
movq -0x8(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x7bb10
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x7b750
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
callq 0x7b750
movq -0x8(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x7ba00
movq -0x8(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0x7ba00
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFindMt.c
// Function: MatchFinderMt_Create
SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddBufferBefore,
    UInt32 matchMaxLen, UInt32 keepAddBufferAfter, ISzAllocPtr alloc)
{
  CMatchFinder *mf = MF(p);
  p->historySize = historySize;
  if (kMtBtBlockSize <= matchMaxLen * 4)
    return SZ_ERROR_PARAM;
  if (!p->hashBuf)
  {
    p->hashBuf = (UInt32 *)ISzAlloc_Alloc(alloc, ((size_t)kHashBufferSize + (size_t)kBtBufferSize) * sizeof(UInt32));
    if (!p->hashBuf)
      return SZ_ERROR_MEM;
    p->btBuf = p->hashBuf + kHashBufferSize;
  }
  keepAddBufferBefore += (kHashBufferSize + kBtBufferSize);
  keepAddBufferAfter += kMtHashBlockSize;
  if (!MatchFinder_Create(mf, historySize, keepAddBufferBefore, matchMaxLen, keepAddBufferAfter, alloc))
    return SZ_ERROR_MEM;

  RINOK(MtSync_Create(&p->hashSync, HashThreadFunc2, p))
  RINOK(MtSync_Create(&p->btSync, BtThreadFunc2, p))
  return SZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x520(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
movl $0x10000, %eax          # imm = 0x10000
cmpl %ecx, %eax
ja 0x756e1
movl $0x5, -0x4(%rbp)
jmp 0x757dd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2d0(%rax)
jne 0x75743
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rdi
movl $0x500000, %esi         # imm = 0x500000
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2d0(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2d0(%rax)
jne 0x75729
movl $0x2, -0x4(%rbp)
jmp 0x757dd
movq -0x10(%rbp), %rax
movq 0x2d0(%rax), %rcx
addq $0x100000, %rcx         # imm = 0x100000
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x18(%rbp), %eax
addl $0x140000, %eax         # imm = 0x140000
movl %eax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x20000, %eax          # imm = 0x20000
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0x6f4b0
cmpl $0x0, %eax
jne 0x75781
movl $0x2, -0x4(%rbp)
jmp 0x757dd
movq -0x10(%rbp), %rdi
addq $0x318, %rdi            # imm = 0x318
movq -0x10(%rbp), %rdx
leaq 0xd9(%rip), %rsi        # 0x75870
callq 0x757f0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x757ad
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x757dd
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rdx
leaq 0xd0(%rip), %rsi        # 0x75890
callq 0x757f0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x757d6
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x757dd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFindMt.c
// Function: MtSync_Create
Z7_NO_INLINE
static SRes MtSync_Create(CMtSync *p, THREAD_FUNC_TYPE startAddress, void *obj)
{
  const WRes wres = MtSync_Create_WRes(p, startAddress, obj);
  if (wres == 0)
    return 0;
  MtSync_Destruct(p);
  return MY_SRes_HRESULT_FROM_WRes(wres);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x76db0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x75827
movl $0x0, -0x4(%rbp)
jmp 0x75859
movq -0x10(%rbp), %rdi
callq 0x75580
cmpl $0x0, -0x24(%rbp)
jg 0x7583e
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x75853
movl -0x24(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
orl $0x8000000, %eax        # imm = 0x8000000
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFindMt.c
// Function: BtThreadFunc2
static THREAD_FUNC_DECL BtThreadFunc2(void *p)
{
  Byte allocaDummy[0x180];
  unsigned i = 0;
  for (i = 0; i < 16; i++)
    allocaDummy[i] = (Byte)0;
  if (allocaDummy[0] == 0)
    BtThreadFunc((CMatchFinderMt *)p);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movl $0x0, -0x194(%rbp)
movl $0x0, -0x194(%rbp)
cmpl $0x10, -0x194(%rbp)
jae 0x758db
movl -0x194(%rbp), %eax
movb $0x0, -0x190(%rbp,%rax)
movl -0x194(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x194(%rbp)
jmp 0x758b3
movzbl -0x190(%rbp), %eax
cmpl $0x0, %eax
jne 0x758f0
movq -0x8(%rbp), %rdi
callq 0x771f0
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopl (%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFindMt.c
// Function: MtSync_Init
Z7_NO_INLINE
static SRes MtSync_Init(CMtSync *p, UInt32 numBlocks)
{
  WRes wres;
  // BUFFER_MUST_BE_UNLOCKED(p)
  if (!p->needStart || p->csWasEntered)
    return SZ_ERROR_FAIL;
  wres = Semaphore_OptCreateInit(&p->freeSemaphore, numBlocks, numBlocks);
  if (wres == 0)
    wres = Semaphore_OptCreateInit(&p->filledSemaphore, 0, numBlocks);
  return MY_SRes_HRESULT_FROM_WRes(wres);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0x75973
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x7597c
movl $0xb, -0x4(%rbp)
jmp 0x759dc
movq -0x10(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
movl -0x14(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x7b860
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x759b3
movq -0x10(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
movl -0x14(%rbp), %edx
xorl %esi, %esi
callq 0x7b860
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x759c1
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x759d6
movl -0x18(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
orl $0x8000000, %eax        # imm = 0x8000000
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFindMt.c
// Function: MatchFinderMt_GetNumAvailableBytes
static UInt32 MatchFinderMt_GetNumAvailableBytes(void *_p)
{
  CMatchFinderMt *p = (CMatchFinderMt *)_p;
  if (p->btBufPos != p->btBufPosLimit)
    return p->btNumAvailBytes;
  return MatchFinderMt_GetNextBlock_Bt(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x75de2
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x75dee
movq -0x18(%rbp), %rdi
callq 0x77880
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFindMt.c
// Function: MatchFinderMt2_GetMatches
static UInt32 * MatchFinderMt2_GetMatches(void *_p, UInt32 *d)
{
  CMatchFinderMt *p = (CMatchFinderMt *)_p;
  const UInt32 *bt = p->btBufPos;
  const UInt32 len = *bt++;
  const UInt32 *btLim = bt + len;
  p->btBufPos = btLim;
  p->btNumAvailBytes--;
  INCREASE_LZ_POS
  {
    while (bt != btLim)
    {
      const UInt32 v0 = bt[0];
      const UInt32 v1 = bt[1];
      bt += 2;
      d[0] = v0;
      d[1] = v1;
      d += 2;
    }
  }
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x76154
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x38(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x7610a
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFindMt.c
// Function: MixMatches2
static UInt32 * MixMatches2(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *d)
{
  UInt32 h2, c2;
  UInt32 *hash = p->hash;
  const Byte *cur = p->pointerToCurPos;
  const UInt32 m = p->lzPos;
  MT_HASH2_CALC
      
  c2 = hash[h2];
  hash[h2] = m;

  if (c2 >= matchMinPos)
  {
    CHECK_FAILURE_LZ(c2, m)
    if (cur[(ptrdiff_t)c2 - (ptrdiff_t)m] == cur[0])
    {
      *d++ = 2;
      *d++ = m - c2 - 1;
    }
  }
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
movl (%rax,%rcx,4), %eax
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
xorl %ecx, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x34(%rbp), %edx
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jb 0x76343
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
movl -0x34(%rbp), %edx
subq %rdx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x76341
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x18(%rbp)
movl $0x2, (%rax)
movl -0x34(%rbp), %ecx
subl -0x20(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x18(%rbp)
movl %ecx, (%rax)
jmp 0x76343
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzFindMt.c
// Function: MatchFinderMt2_Skip
static void MatchFinderMt2_Skip(void *_p, UInt32 num)
{
  CMatchFinderMt *p = (CMatchFinderMt *)_p;
  SKIP_HEADER_MT(2)
      UInt32 h2;
      MT_HASH2_CALC
      hash[h2] = p->lzPos;
  SKIP_FOOTER_MT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x76382
movq -0x18(%rbp), %rdi
callq 0x77880
movq -0x18(%rbp), %rcx
movl 0x24(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x24(%rcx)
cmpl $0x2, %eax
jb 0x763e2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
movl (%rax,%rcx,4), %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
xorl %ecx, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %eax
movl %eax, %ecx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
shlq $0x2, %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x76367
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)