LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: import_fileRead
hpatch_BOOL _import_fileRead(hpatch_FileHandle file,TByte* buf,TByte* buf_end){
    while (buf<buf_end) {
        size_t readLen=(size_t)(buf_end-buf);
        if (readLen>hpatch_kFileIOBestMaxSize) readLen=hpatch_kFileIOBestMaxSize;
        if (readLen!=fread(buf,1,readLen,file)) return hpatch_FALSE;
        buf+=readLen;
    }
    return buf==buf_end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x8d970
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x100000, -0x28(%rbp)  # imm = 0x100000
jbe 0x8d92f
movq $0x100000, -0x28(%rbp)  # imm = 0x100000
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x4570
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x8d962
movl $0x0, -0x4(%rbp)
jmp 0x8d983
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x8d904
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: import_fileWrite
hpatch_BOOL _import_fileWrite(hpatch_FileHandle file,const TByte* data,const TByte* data_end){
    while (data<data_end) {
        size_t writeLen=(size_t)(data_end-data);
        if (writeLen>hpatch_kFileIOBestMaxSize) writeLen=hpatch_kFileIOBestMaxSize;
        if (writeLen!=fwrite(data,1,writeLen,file)) return hpatch_FALSE;
        data+=writeLen;
    }
    return data==data_end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x8da10
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x100000, -0x28(%rbp)  # imm = 0x100000
jbe 0x8d9cf
movq $0x100000, -0x28(%rbp)  # imm = 0x100000
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x4720
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x8da02
movl $0x0, -0x4(%rbp)
jmp 0x8da23
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x8d9a4
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: import_fileTruncate
hpatch_BOOL _import_fileTruncate(hpatch_FileHandle file,hpatch_StreamPos_t new_file_length){
#ifdef _MSC_VER
    int fno=_fileno(file);
    if (fno==-1) return hpatch_FALSE;
    if (_chsize_s(fno,new_file_length)!=0) return hpatch_FALSE;
#else
    int fno=fileno(file);
    if (fno==-1) return hpatch_FALSE;
    if (ftruncate(fno,new_file_length)!=0) return hpatch_FALSE;
#endif
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43e0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x8da5b
movl $0x0, -0x4(%rbp)
jmp 0x8da7c
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x41c0
cmpl $0x0, %eax
je 0x8da75
movl $0x0, -0x4(%rbp)
jmp 0x8da7c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: hpatch_TFileStreamInput_open
hpatch_BOOL hpatch_TFileStreamInput_open(hpatch_TFileStreamInput* self,const char* fileName_utf8){
    assert(self->m_file==0);
    self->fileError=hpatch_FALSE;
    if (self->m_file) _ferr_returnv(EINVAL);
    if (!_import_fileOpenRead(fileName_utf8,&self->m_file,&self->base.streamSize))
        _ferr_return();
    
    self->base.streamImport=self;
    self->base.read=_TFileStreamInput_read_file;
    self->m_fpos=0;
    self->m_offset=0;
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x8daad
jmp 0x8dacc
leaq 0x27f00(%rip), %rdi     # 0xb59b4
leaq 0x27e61(%rip), %rsi     # 0xb591c
movl $0x24b, %edx            # imm = 0x24B
leaq 0x27efd(%rip), %rcx     # 0xb59c4
callq 0x4270
movq -0x10(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x8db54
jmp 0x8dae4
jmp 0x8dae6
callq 0x4050
movl $0x16, (%rax)
jmp 0x8daf3
movq -0x10(%rbp), %rax
cmpl $0x16, 0x38(%rax)
je 0x8db44
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x8db12
movq -0x10(%rbp), %rax
movl $0x16, 0x38(%rax)
movq 0x584b7(%rip), %rax     # 0xe5fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x16, %edi
callq 0x4100
movq -0x28(%rbp), %rdi
movq %rax, %rcx
leaq 0x1f1e7(%rip), %rsi     # 0xacd1f
movl $0x16, %edx
movb $0x0, %al
callq 0x4520
jmp 0x8db46
jmp 0x8db48
movl $0x0, -0x4(%rbp)
jmp 0x8dc1e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
callq 0x8dc30
cmpl $0x0, %eax
jne 0x8dbe5
jmp 0x8db74
callq 0x4050
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
cmpl -0x1c(%rbp), %eax
je 0x8dbd8
cmpl $0x0, -0x1c(%rbp)
je 0x8dbd8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x8dba4
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq 0x58425(%rip), %rax     # 0xe5fd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x4100
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %edx
movq %rax, %rcx
leaq 0x1f14e(%rip), %rsi     # 0xacd1f
movb $0x0, %al
callq 0x4520
jmp 0x8dbda
jmp 0x8dbdc
movl $0x0, -0x4(%rbp)
jmp 0x8dc1e
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xe5(%rip), %rcx        # 0x8dce0
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: import_fileOpenRead
static hpatch_inline
hpatch_BOOL _import_fileOpenRead(const char* fileName_utf8,hpatch_FileHandle* out_fileHandle,
                                 hpatch_StreamPos_t* out_fileSize){
    hpatch_FileHandle file=0;
    assert(out_fileHandle!=0);
    if (out_fileHandle==0) { _set_errno_new(EINVAL); return hpatch_FALSE; }
    file=_import_fileOpenWithSize(fileName_utf8,_kFileReadMode,out_fileSize);
    if (file==0) return hpatch_FALSE;
    *out_fileHandle=file;
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8dc55
jmp 0x8dc74
leaq 0x27f12(%rip), %rdi     # 0xb5b6e
leaq 0x27cb9(%rip), %rsi     # 0xb591c
movl $0x210, %edx            # imm = 0x210
leaq 0x27f11(%rip), %rcx     # 0xb5b80
callq 0x4270
cmpq $0x0, -0x18(%rbp)
jne 0x8dc91
jmp 0x8dc7d
callq 0x4050
movl $0x16, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8dccb
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x27f3a(%rip), %rsi     # 0xb5bda
callq 0x8ee80
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8dcb9
movl $0x0, -0x4(%rbp)
jmp 0x8dccb
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: hpatch_TFileStreamInput_setOffset
hpatch_BOOL hpatch_TFileStreamInput_setOffset(hpatch_TFileStreamInput* self,hpatch_StreamPos_t offset){
    if (self->base.streamSize<offset)
        _ferr_returnv(EFBIG);
    self->m_offset+=offset;
    self->base.streamSize-=offset;
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x8dffd
jmp 0x8df90
jmp 0x8df92
callq 0x4050
movl $0x1b, (%rax)
jmp 0x8df9f
movq -0x10(%rbp), %rax
cmpl $0x1b, 0x38(%rax)
je 0x8dff0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x8dfbe
movq -0x10(%rbp), %rax
movl $0x1b, 0x38(%rax)
movq 0x5800b(%rip), %rax     # 0xe5fd0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x1b, %edi
callq 0x4100
movq -0x20(%rbp), %rdi
movq %rax, %rcx
leaq 0x1ed3b(%rip), %rsi     # 0xacd1f
movl $0x1b, %edx
movb $0x0, %al
callq 0x4520
jmp 0x8dff2
jmp 0x8dff4
movl $0x0, -0x4(%rbp)
jmp 0x8e027
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: import_fileClose
hpatch_inline static
hpatch_BOOL _import_fileClose(hpatch_FileHandle* pfile){
    hpatch_FileHandle file=*pfile;
    if (file){
        *pfile=0;
        if (0!=fclose(file))
            return hpatch_FALSE;
    }
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8e125
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x4390
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x8e123
movl $0x0, -0x4(%rbp)
jmp 0x8e12c
jmp 0x8e125
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: hpatch_TFileStreamOutput_open
hpatch_BOOL hpatch_TFileStreamOutput_open(hpatch_TFileStreamOutput* self,const char* fileName_utf8,
                                          hpatch_StreamPos_t max_file_length){
    assert(self->m_file==0);
    self->fileError=hpatch_FALSE;
    if (self->m_file) _ferr_returnv(EINVAL);
    if (!_import_fileOpenCreateOrReWrite(fileName_utf8,&self->m_file))
        _ferr_return();
    
    self->base.streamImport=self;
    self->base.streamSize=max_file_length;
    self->base.read_writed=_hpatch_TFileStreamOutput_read_file;
    self->base.write=_TFileStreamOutput_write_file;
    self->m_fpos=0;
    self->m_offset=0;
    self->is_in_readModel=hpatch_FALSE;
    self->is_random_out=hpatch_FALSE;
    self->out_length=0;
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x8e161
jmp 0x8e180
leaq 0x2784c(%rip), %rdi     # 0xb59b4
leaq 0x277ad(%rip), %rsi     # 0xb591c
movl $0x291, %edx            # imm = 0x291
leaq 0x2789b(%rip), %rcx     # 0xb5a16
callq 0x4270
movq -0x10(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x8e208
jmp 0x8e198
jmp 0x8e19a
callq 0x4050
movl $0x16, (%rax)
jmp 0x8e1a7
movq -0x10(%rbp), %rax
cmpl $0x16, 0x38(%rax)
je 0x8e1f8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x8e1c6
movq -0x10(%rbp), %rax
movl $0x16, 0x38(%rax)
movq 0x57e03(%rip), %rax     # 0xe5fd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x16, %edi
callq 0x4100
movq -0x30(%rbp), %rdi
movq %rax, %rcx
leaq 0x1eb33(%rip), %rsi     # 0xacd1f
movl $0x16, %edx
movb $0x0, %al
callq 0x4520
jmp 0x8e1fa
jmp 0x8e1fc
movl $0x0, -0x4(%rbp)
jmp 0x8e307
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x8e310
cmpl $0x0, %eax
jne 0x8e291
jmp 0x8e220
callq 0x4050
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
cmpl -0x24(%rbp), %eax
je 0x8e284
cmpl $0x0, -0x24(%rbp)
je 0x8e284
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x8e250
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq 0x57d79(%rip), %rax     # 0xe5fd0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x24(%rbp), %edi
callq 0x4100
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %edx
movq %rax, %rcx
leaq 0x1eaa2(%rip), %rsi     # 0xacd1f
movb $0x0, %al
callq 0x4520
jmp 0x8e286
jmp 0x8e288
movl $0x0, -0x4(%rbp)
jmp 0x8e307
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0xfd(%rip), %rcx        # 0x8e3b0
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x1ee(%rip), %rcx       # 0x8e4b0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: import_fileOpenCreateOrReWrite
static hpatch_inline
hpatch_BOOL _import_fileOpenCreateOrReWrite(const char* fileName_utf8,hpatch_FileHandle* out_fileHandle){
    hpatch_FileHandle file=0;
    assert(out_fileHandle!=0);
    if (out_fileHandle==0) { _set_errno_new(EINVAL); return hpatch_FALSE; }
    file=_import_fileOpen(fileName_utf8,_kFileWriteMode);
    if (file==0) return hpatch_FALSE;
    *out_fileHandle=file;
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8e331
jmp 0x8e350
leaq 0x27836(%rip), %rdi     # 0xb5b6e
leaq 0x275dd(%rip), %rsi     # 0xb591c
movl $0x21b, %edx            # imm = 0x21B
leaq 0x27914(%rip), %rcx     # 0xb5c5f
callq 0x4270
cmpq $0x0, -0x18(%rbp)
jne 0x8e36d
jmp 0x8e359
callq 0x4050
movl $0x16, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8e3a3
movq -0x10(%rbp), %rdi
leaq 0x27936(%rip), %rsi     # 0xb5cae
callq 0x8ef30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8e391
movl $0x0, -0x4(%rbp)
jmp 0x8e3a3
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: hpatch_TFileStreamOutput_read_file
static hpatch_BOOL _hpatch_TFileStreamOutput_read_file(const hpatch_TStreamOutput* stream,
                                                           hpatch_StreamPos_t readFromPos,
                                                           TByte* out_data,TByte* out_data_end){
         //hpatch_TFileStreamOutput is A hpatch_TFileStreamInput !
        hpatch_TFileStreamOutput* self=(hpatch_TFileStreamOutput*)stream->streamImport;
        const hpatch_TStreamInput* in_stream=(const hpatch_TStreamInput*)stream;
        if (!self->is_in_readModel){
            if (!hpatch_TFileStreamOutput_flush(self)) _rw_ferr_return();
            self->is_in_readModel=hpatch_TRUE;
            self->m_fpos=hpatch_kNullStreamPos;
        }
        return _TFileStreamInput_read_file(in_stream,readFromPos,out_data,out_data_end);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x8e48b
movq -0x30(%rbp), %rdi
callq 0x8ecf0
cmpl $0x0, %eax
jne 0x8e474
movq -0x30(%rbp), %rax
movq $-0x1, 0x28(%rax)
callq 0x4050
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movl 0x38(%rax), %eax
cmpl -0x3c(%rbp), %eax
je 0x8e467
cmpl $0x0, -0x3c(%rbp)
je 0x8e467
movq -0x30(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x8e433
movl -0x3c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x38(%rax)
movq 0x57b96(%rip), %rax     # 0xe5fd0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %edi
callq 0x4100
movq -0x48(%rbp), %rdi
movl -0x40(%rbp), %edx
movq %rax, %rcx
leaq 0x1e8bf(%rip), %rsi     # 0xacd1f
movb $0x0, %al
callq 0x4520
jmp 0x8e469
jmp 0x8e46b
movl $0x0, -0x4(%rbp)
jmp 0x8e4a3
movq -0x30(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x30(%rbp), %rax
movq $-0x1, 0x28(%rax)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x8dce0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: import_fileReopenWrite
static
hpatch_BOOL _import_fileReopenWrite(const char* fileName_utf8,hpatch_FileHandle* out_fileHandle,
                                    hpatch_StreamPos_t* out_curFileWritePos){
    hpatch_FileHandle file=0;
    hpatch_StreamPos_t curFileSize=0;
    assert(out_fileHandle!=0);
    if (out_fileHandle==0) { _set_errno_new(EINVAL); return hpatch_FALSE; }
    file=_import_fileOpenWithSize(fileName_utf8,_kFileReadWriteMode,&curFileSize);
    if (file==0) return hpatch_FALSE;
    if (out_curFileWritePos!=0) *out_curFileWritePos=curFileSize;
    if (!_import_fileSeek64To(file,curFileSize))  
        { _import_fileClose_No_errno(&file); return hpatch_FALSE; }
    *out_fileHandle=file;
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8eb7d
jmp 0x8eb9c
leaq 0x26fea(%rip), %rdi     # 0xb5b6e
leaq 0x26d91(%rip), %rsi     # 0xb591c
movl $0x228, %edx            # imm = 0x228
leaq 0x271b6(%rip), %rcx     # 0xb5d4d
callq 0x4270
cmpq $0x0, -0x18(%rbp)
jne 0x8ebb9
jmp 0x8eba5
callq 0x4050
movl $0x16, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8ec29
movq -0x10(%rbp), %rdi
leaq 0x271e6(%rip), %rsi     # 0xb5daa
leaq -0x30(%rbp), %rdx
callq 0x8ee80
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8ebe1
movl $0x0, -0x4(%rbp)
jmp 0x8ec29
cmpq $0x0, -0x20(%rbp)
je 0x8ebf3
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8efe0
cmpl $0x0, %eax
jne 0x8ec17
leaq -0x28(%rbp), %rdi
callq 0x8f010
movl $0x0, -0x4(%rbp)
jmp 0x8ec29
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: import_fileOpenWithSize
static hpatch_FileHandle _import_fileOpenWithSize(const char* fileName_utf8,_FileModeType mode,hpatch_StreamPos_t* out_fileSize){
    hpatch_FileHandle file=0;
    file=_import_fileOpen(fileName_utf8,mode);
    if ((out_fileSize==0)||(file==0)) return file;
    
    if (_import_fileSeek64(file,0,SEEK_END)){
        if (_import_fileTell64(file,out_fileSize)){
            if (_import_fileSeek64(file,0,SEEK_SET)){
                return file;
            }
        }
    }

    //error clear
    _import_fileClose(&file);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8ef30
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8eebb
cmpq $0x0, -0x28(%rbp)
jne 0x8eec5
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8ef21
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x8ef60
cmpl $0x0, %eax
je 0x8ef10
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8efa0
cmpl $0x0, %eax
je 0x8ef0e
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x8ef60
cmpl $0x0, %eax
je 0x8ef0c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8ef21
jmp 0x8ef0e
jmp 0x8ef10
leaq -0x28(%rbp), %rdi
callq 0x8e0e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: import_fileTell64
hpatch_inline static
hpatch_BOOL _import_fileTell64(hpatch_FileHandle file,hpatch_StreamPos_t* outPos){
#ifdef _MSC_VER
    __int64 pos=_ftelli64(file);
#else
# ifdef ANDROID
#  if __ANDROID_API__ >= 24
    off64_t pos=ftello64(file);
#  else
    off64_t pos=_import_lseek64(file,0,SEEK_CUR);
#  endif
# else
    off_t pos=ftello(file);
# endif
#endif
    *outPos=(hpatch_StreamPos_t)pos;
    return (pos>=0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4580
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/file_for_patch.c
// Function: import_fileClose_No_errno
hpatch_inline static
    hpatch_BOOL _import_fileClose_No_errno(hpatch_FileHandle* pfile){
        int err=errno;
        hpatch_BOOL result=_import_fileClose(pfile); 
        if (err) _set_errno_new(err);
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4050
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8e0e0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x8f04c
jmp 0x8f03a
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x4050
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x8f04c
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: sisong[P]ApkDiffPatch/HDiffPatch/libParallel/parallel_import.cpp
// Function: thread_parallel(int, void (*)(int, void*), void*, int, int)
void thread_parallel(int threadCount,TThreadRunCallBackProc threadProc,void* workData,
                     int isUseThisThread,int threadIndexOffset){
    for (int i=0; i<threadCount; ++i) {
        if ((i==threadCount-1)&&(isUseThisThread)){
            threadProc(i+threadIndexOffset,workData);
        }else{
            _TThreadProc tp={threadProc,i+threadIndexOffset,workData};
            std::thread t(tp);
            t.detach();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x8f32b
movl -0x24(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8f2c2
cmpl $0x0, -0x1c(%rbp)
je 0x8f2c2
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %edi
addl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq *%rax
jmp 0x8f31b
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl -0x20(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x8f420
movq -0x60(%rbp), %rdi
callq 0x4670
jmp 0x8f2f9
leaq -0x48(%rbp), %rdi
callq 0x2a0f0
jmp 0x8f31b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2a0f0
jmp 0x8f331
jmp 0x8f31d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8f291
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4680
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libParallel/parallel_channel.cpp
// Function: CChannel_import::~_CChannel_import()
~_CChannel_import(){
        close();
        while (true) { //wait all thread exit
            {
                CAutoLocker locker(_locker);
                if (_waitingCount==0) break;
            }
            this_thread_yield(); //todo:优化?
        }
        locker_delete(_locker);
        assert(_dataList.empty()); // why? if saved resource then leaks
        condvar_delete(_acceptCond);
        condvar_delete(_sendCond);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x8fba0
jmp 0x8facb
jmp 0x8facd
jmp 0x8facf
movq -0x28(%rbp), %rax
movq (%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0x42c30
jmp 0x8fae1
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
cmpq $0x0, %rax
jne 0x8faf8
movl $0x3, -0x1c(%rbp)
jmp 0x8faff
movl $0x0, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x42f60
movl -0x1c(%rbp), %eax
testl %eax, %eax
je 0x8fb13
jmp 0x8fb11
jmp 0x8fb1c
callq 0x8f260
jmp 0x8fb1a
jmp 0x8facd
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x8f0a0
jmp 0x8fb2a
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x90b10
testb $0x1, %al
jne 0x8fb3d
jmp 0x8fb3f
jmp 0x8fb5e
leaq 0x262ac(%rip), %rdi     # 0xb5df2
leaq 0x262b7(%rip), %rsi     # 0xb5e04
movl $0x34, %edx
leaq 0x262d7(%rip), %rcx     # 0xb5e30
callq 0x4270
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8f170
jmp 0x8fb6d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8f170
jmp 0x8fb7c
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x900a0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x89d0
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libParallel/parallel_channel.cpp
// Function: CChannel_import::close()
void close(){
        if (_isClosed) return;
        {
            CAutoLocker locker(_locker);
            if (_isClosed) return;
            _isClosed=true;
            condvar_broadcast(_sendCond);
            condvar_broadcast(_acceptCond);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb 0x78(%rax), %al
testb $0x1, %al
je 0x8fbbd
jmp 0x8fc13
movq -0x38(%rbp), %rax
movq (%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0x42c30
movq -0x38(%rbp), %rax
movb 0x78(%rax), %al
testb $0x1, %al
je 0x8fbe1
movl $0x1, -0x1c(%rbp)
jmp 0x8fc0a
movq -0x38(%rbp), %rax
movb $0x1, 0x78(%rax)
movq 0x8(%rax), %rdi
callq 0x8f230
jmp 0x8fbf4
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8f230
jmp 0x8fc03
movl $0x0, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x42f60
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x42f60
movq -0x28(%rbp), %rdi
callq 0x4680
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libParallel/parallel_channel.cpp
// Function: CChannel_import::is_can_fast_send(bool)
bool is_can_fast_send(bool isWait){
        if (_maxDataCount<0) return true;
        if (_maxDataCount==0) return false;

        CAutoLocker locker(_locker);
        while (true) {
            if (_isClosed) return false;
            if (_dataList.size()<(size_t)_maxDataCount) {
                return true;
            }else if(!isWait){
                return false;
            }//else wait
            ++_waitingCount;
            condvar_wait(_sendCond,&locker);
            --_waitingCount;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, 0x68(%rax)
jge 0x8fc6c
movb $0x1, -0x1(%rbp)
jmp 0x8fd39
movq -0x48(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x8fc80
movb $0x0, -0x1(%rbp)
jmp 0x8fd39
movq -0x48(%rbp), %rax
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x42c30
jmp 0x8fc92
movq -0x48(%rbp), %rax
movb 0x78(%rax), %al
testb $0x1, %al
je 0x8fcad
movb $0x0, -0x1(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x8fd30
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x90b70
movq -0x48(%rbp), %rcx
cmpq 0x68(%rcx), %rax
jae 0x8fcd1
movb $0x1, -0x1(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x8fd30
testb $0x1, -0x11(%rbp)
jne 0x8fce4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x8fd30
jmp 0x8fce6
movq -0x48(%rbp), %rax
movq 0x70(%rax), %rcx
incq %rcx
movq %rcx, 0x70(%rax)
movq 0x8(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8f1c0
jmp 0x8fd04
movq -0x48(%rbp), %rax
movq 0x70(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x70(%rax)
jmp 0x8fc90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x42f60
jmp 0x8fd44
leaq -0x28(%rbp), %rdi
callq 0x42f60
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4680
nopl (%rax)
// File: sisong[P]ApkDiffPatch/HDiffPatch/libParallel/parallel_channel.cpp
// Function: CChannel_import::accept(bool)
TChanData accept(bool isWait){
        CAutoLocker locker(_locker);
        while (true) {
            if (!_dataList.empty()) {
                TChanData result=_dataList.front();
                _dataList.pop_front();
                if (!_isClosed)
                    condvar_signal(_sendCond);
                return result; //ok
            }else if(_isClosed){
                return 0;
            }else if(!isWait){
                return 0;
            }//else wait
            ++_waitingCount;
            condvar_wait(_acceptCond,&locker);
            --_waitingCount;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x42c30
jmp 0x8ff7a
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x90b10
testb $0x1, %al
jne 0x8fff3
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x91380
movq -0x48(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
callq 0x913b0
movq -0x48(%rbp), %rax
movb 0x78(%rax), %al
testb $0x1, %al
jne 0x8ffe2
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8f200
jmp 0x8ffc6
jmp 0x8ffe2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x42f60
jmp 0x90070
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x9005d
movq -0x48(%rbp), %rax
movb 0x78(%rax), %al
testb $0x1, %al
je 0x9000f
movq $0x0, -0x8(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x9005d
testb $0x1, -0x11(%rbp)
jne 0x90026
movq $0x0, -0x8(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x9005d
jmp 0x90028
jmp 0x9002a
movq -0x48(%rbp), %rax
movq 0x70(%rax), %rcx
incq %rcx
movq %rcx, 0x70(%rax)
movq 0x10(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8f1c0
jmp 0x90048
movq -0x48(%rbp), %rax
movq 0x70(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x70(%rax)
jmp 0x8ff78
leaq -0x28(%rbp), %rdi
callq 0x42f60
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4680
nopl (%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/adler32.c
// Function: adler32_combine_
local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2) {
    unsigned long sum1;
    unsigned long sum2;
    unsigned rem;

    /* for negative len, return invalid adler32 as a clue for debugging */
    if (len2 < 0)
        return 0xffffffffUL;

    /* the derivation of this formula is left as an exercise for the reader */
    MOD63(len2);                /* assumes len2 >= 0 */
    rem = (unsigned)len2;
    sum1 = adler1 & 0xffff;
    sum2 = rem * sum1;
    MOD(sum2);
    sum1 += (adler2 & 0xffff) + BASE - 1;
    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
    if (sum1 >= BASE) sum1 -= BASE;
    if (sum1 >= BASE) sum1 -= BASE;
    if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
    if (sum2 >= BASE) sum2 -= BASE;
    return sum1 | (sum2 << 16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x91b45
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, -0x8(%rbp)
jmp 0x91c4d
movq -0x20(%rbp), %rax
movl $0xfff1, %ecx           # imm = 0xFFF1
cqto
idivq %rcx
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %eax
imulq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divq %rcx
movq %rdx, -0x30(%rbp)
movq -0x18(%rbp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
addq $0xfff1, %rax           # imm = 0xFFF1
subq $0x1, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
shrq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movq -0x18(%rbp), %rcx
shrq $0x10, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
addq %rcx, %rax
addq $0xfff1, %rax           # imm = 0xFFF1
movl -0x34(%rbp), %ecx
subq %rcx, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0xfff1, -0x28(%rbp)    # imm = 0xFFF1
jb 0x91bf2
movq -0x28(%rbp), %rax
subq $0xfff1, %rax           # imm = 0xFFF1
movq %rax, -0x28(%rbp)
cmpq $0xfff1, -0x28(%rbp)    # imm = 0xFFF1
jb 0x91c0a
movq -0x28(%rbp), %rax
subq $0xfff1, %rax           # imm = 0xFFF1
movq %rax, -0x28(%rbp)
cmpq $0x1ffe2, -0x30(%rbp)   # imm = 0x1FFE2
jb 0x91c22
movq -0x30(%rbp), %rax
subq $0x1ffe2, %rax          # imm = 0x1FFE2
movq %rax, -0x30(%rbp)
cmpq $0xfff1, -0x30(%rbp)    # imm = 0xFFF1
jb 0x91c3a
movq -0x30(%rbp), %rax
subq $0xfff1, %rax           # imm = 0xFFF1
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x10, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/crc32.c
// Function: crc_word
local z_crc_t crc_word(z_word_t data) {
    int k;
    for (k = 0; k < W; k++)
        data = (data >> 8) ^ crc_table[data & 0xff];
    return (z_crc_t)data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x92904
movq -0x8(%rbp), %rax
shrq $0x8, %rax
movq -0x8(%rbp), %rdx
andq $0xff, %rdx
leaq 0x235d1(%rip), %rcx     # 0xb5ec0
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x928cf
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/crc32.c
// Function: byte_swap
local z_word_t byte_swap(z_word_t word) {
#  if W == 8
    return
        (word & 0xff00000000000000) >> 56 |
        (word & 0xff000000000000) >> 40 |
        (word & 0xff0000000000) >> 24 |
        (word & 0xff00000000) >> 8 |
        (word & 0xff000000) << 8 |
        (word & 0xff0000) << 24 |
        (word & 0xff00) << 40 |
        (word & 0xff) << 56;
#  else   /* W == 4 */
    return
        (word & 0xff000000) >> 24 |
        (word & 0xff0000) >> 8 |
        (word & 0xff00) << 8 |
        (word & 0xff) << 24;
#  endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movabsq $-0x100000000000000, %rax # imm = 0xFF00000000000000
andq -0x8(%rbp), %rax
shrq $0x38, %rax
movabsq $0xff000000000000, %rcx # imm = 0xFF000000000000
andq -0x8(%rbp), %rcx
shrq $0x28, %rcx
orq %rcx, %rax
movabsq $0xff0000000000, %rcx   # imm = 0xFF0000000000
andq -0x8(%rbp), %rcx
shrq $0x18, %rcx
orq %rcx, %rax
movabsq $0xff00000000, %rcx     # imm = 0xFF00000000
andq -0x8(%rbp), %rcx
shrq $0x8, %rcx
orq %rcx, %rax
movabsq $0xff000000, %rcx       # imm = 0xFF000000
andq -0x8(%rbp), %rcx
shlq $0x8, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
andq $0xff0000, %rcx         # imm = 0xFF0000
shlq $0x18, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
andq $0xff00, %rcx           # imm = 0xFF00
shlq $0x28, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
andq $0xff, %rcx
shlq $0x38, %rcx
orq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/crc32.c
// Function: crc_word_big
local z_word_t crc_word_big(z_word_t data) {
    int k;
    for (k = 0; k < W; k++)
        data = (data << 8) ^
            crc_big_table[(data >> ((W - 1) << 3)) & 0xff];
    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x92a06
movq -0x8(%rbp), %rax
shlq $0x8, %rax
movq -0x8(%rbp), %rdx
shrq $0x38, %rdx
andq $0xff, %rdx
leaq 0x298cd(%rip), %rcx     # 0xbc2c0
xorq (%rcx,%rdx,8), %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x929cf
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/crc32.c
// Function: multmodp
local z_crc_t multmodp(z_crc_t a, z_crc_t b) {
    z_crc_t m, p;

    m = (z_crc_t)1 << 31;
    p = 0;
    for (;;) {
        if (a & m) {
            p ^= b;
            if ((a & (m - 1)) == 0)
                break;
        }
        m >>= 1;
        b = b & 1 ? (b >> 1) ^ POLY : b >> 1;
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x80000000, -0xc(%rbp) # imm = 0x80000000
movl $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0x92ad0
movl -0x8(%rbp), %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x92ace
jmp 0x92b02
jmp 0x92ad0
movl -0xc(%rbp), %eax
shrl %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x92af2
movl -0x8(%rbp), %eax
shrl %eax
xorl $0xedb88320, %eax       # imm = 0xEDB88320
movl %eax, -0x14(%rbp)
jmp 0x92afa
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x92aa8
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/crc32.c
// Function: x2nmodp
local z_crc_t x2nmodp(z_off64_t n, unsigned k) {
    z_crc_t p;

    p = (z_crc_t)1 << 31;           /* x^0 == 1 */
    while (n) {
        if (n & 1)
            p = multmodp(x2n_table[k & 31], p);
        n >>= 1;
        k++;
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x80000000, -0x10(%rbp) # imm = 0x80000000
cmpq $0x0, -0x8(%rbp)
je 0x92b70
movq -0x8(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x92b5a
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x29f74(%rip), %rax     # 0xbcac0
movl (%rax,%rcx,4), %edi
movl -0x10(%rbp), %esi
callq 0x92a90
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
sarq %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x92b26
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/deflate.c
// Function: deflateEnd
int ZEXPORT deflateEnd(z_streamp strm) {
    int status;

    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;

    status = strm->state->status;

    /* Deallocate in reverse order of allocations: */
    TRY_FREE(strm, strm->state->pending_buf);
    TRY_FREE(strm, strm->state->head);
    TRY_FREE(strm, strm->state->prev);
    TRY_FREE(strm, strm->state->window);

    ZFREE(strm, strm->state);
    strm->state = Z_NULL;

    return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x93560
cmpl $0x0, %eax
je 0x930e6
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x931e1
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x93121
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x78(%rax)
je 0x9314e
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq 0x78(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x70(%rax)
je 0x9317b
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq 0x70(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x60(%rax)
je 0x931a8
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq 0x60(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
cmpl $0x71, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/deflate.c
// Function: deflateReset
int ZEXPORT deflateReset(z_streamp strm) {
    int ret;

    ret = deflateResetKeep(strm);
    if (ret == Z_OK)
        lm_init(strm->state);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x93b50
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x9321b
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x93c70
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/deflate.c
// Function: deflateStateCheck
local int deflateStateCheck(z_streamp strm) {
    deflate_state *s;
    if (strm == Z_NULL ||
        strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
        return 1;
    s = strm->state;
    if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
#ifdef GZIP
                                           s->status != GZIP_STATE &&
#endif
                                           s->status != EXTRA_STATE &&
                                           s->status != NAME_STATE &&
                                           s->status != COMMENT_STATE &&
                                           s->status != HCRC_STATE &&
                                           s->status != BUSY_STATE &&
                                           s->status != FINISH_STATE))
        return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x93585
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x93585
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x93591
movl $0x1, -0x4(%rbp)
jmp 0x93614
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x93604
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x93604
movq -0x18(%rbp), %rax
cmpl $0x2a, 0x8(%rax)
je 0x9360d
movq -0x18(%rbp), %rax
cmpl $0x39, 0x8(%rax)
je 0x9360d
movq -0x18(%rbp), %rax
cmpl $0x45, 0x8(%rax)
je 0x9360d
movq -0x18(%rbp), %rax
cmpl $0x49, 0x8(%rax)
je 0x9360d
movq -0x18(%rbp), %rax
cmpl $0x5b, 0x8(%rax)
je 0x9360d
movq -0x18(%rbp), %rax
cmpl $0x67, 0x8(%rax)
je 0x9360d
movq -0x18(%rbp), %rax
cmpl $0x71, 0x8(%rax)
je 0x9360d
movq -0x18(%rbp), %rax
cmpl $0x29a, 0x8(%rax)       # imm = 0x29A
je 0x9360d
movl $0x1, -0x4(%rbp)
jmp 0x93614
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/deflate.c
// Function: deflateGetDictionary
int ZEXPORT deflateGetDictionary(z_streamp strm, Bytef *dictionary,
                                 uInt *dictLength) {
    deflate_state *s;
    uInt len;

    if (deflateStateCheck(strm))
        return Z_STREAM_ERROR;
    s = strm->state;
    len = s->strstart + s->lookahead;
    if (len > s->w_size)
        len = s->w_size;
    if (dictionary != Z_NULL && len)
        zmemcpy(dictionary, s->window + s->strstart + s->lookahead - len, len);
    if (dictLength != Z_NULL)
        *dictLength = len;
    return Z_OK;
}

// 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
callq 0x93560
cmpl $0x0, %eax
je 0x93a9e
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x93b38
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0xac(%rax), %eax
movq -0x28(%rbp), %rcx
addl 0xb4(%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jbe 0x93ad7
movq -0x28(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x93b21
cmpl $0x0, -0x2c(%rbp)
je 0x93b21
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x28(%rbp), %rax
movl 0xac(%rax), %eax
addq %rax, %rsi
movq -0x28(%rbp), %rax
movl 0xb4(%rax), %eax
addq %rax, %rsi
movl -0x2c(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
callq 0x4320
cmpq $0x0, -0x20(%rbp)
je 0x93b31
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/deflate.c
// Function: lm_init
local void lm_init(deflate_state *s) {
    s->window_size = (ulg)2L*s->w_size;

    CLEAR_HASH(s);

    /* Set the default configuration parameters:
     */
    s->max_lazy_match   = configuration_table[s->level].max_lazy;
    s->good_match       = configuration_table[s->level].good_length;
    s->nice_match       = configuration_table[s->level].nice_length;
    s->max_chain_length = configuration_table[s->level].max_chain;

    s->strstart = 0;
    s->block_start = 0L;
    s->lookahead = 0;
    s->insert = 0;
    s->match_length = s->prev_length = MIN_MATCH-1;
    s->match_available = 0;
    s->ins_h = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, %ecx
shlq %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x84(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movw $0x0, (%rax,%rcx,2)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x84(%rax), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq %rdx
xorl %esi, %esi
callq 0x4210
movq -0x8(%rbp), %rax
movslq 0xc4(%rax), %rcx
leaq 0x51f5e(%rip), %rax     # 0xe5c40
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x2(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc0(%rax)
movq -0x8(%rbp), %rax
movslq 0xc4(%rax), %rcx
leaq 0x51f37(%rip), %rax     # 0xe5c40
shlq $0x4, %rcx
addq %rcx, %rax
movzwl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xcc(%rax)
movq -0x8(%rbp), %rax
movslq 0xc4(%rax), %rcx
leaq 0x51f11(%rip), %rax     # 0xe5c40
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xd0(%rax)
movq -0x8(%rbp), %rax
movslq 0xc4(%rax), %rcx
leaq 0x51eea(%rip), %rax     # 0xe5c40
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x6(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xbc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xac(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xb4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x172c(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0xb8(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0xa0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xa8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x80(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/deflate.c
// Function: deflateSetHeader
int ZEXPORT deflateSetHeader(z_streamp strm, gz_headerp head) {
    if (deflateStateCheck(strm) || strm->state->wrap != 2)
        return Z_STREAM_ERROR;
    strm->state->gzhead = head;
    return Z_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x93560
cmpl $0x0, %eax
jne 0x93e1c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpl $0x2, 0x30(%rax)
je 0x93e25
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x93e3c
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x38(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/deflate.c
// Function: deflatePending
int ZEXPORT deflatePending(z_streamp strm, unsigned *pending, int *bits) {
    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
    if (pending != Z_NULL)
        *pending = strm->state->pending;
    if (bits != Z_NULL)
        *bits = strm->state->bi_valid;
    return Z_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x93560
cmpl $0x0, %eax
je 0x93e7b
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x93eb8
cmpq $0x0, -0x18(%rbp)
je 0x93e96
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x28(%rax), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x93eb1
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x1734(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)