// File: /workspace/github_cpp_makefile_star2_O1/sisong[P]ApkDiffPatch/src/patch/NewStream.cpp
// Function: NewStream_write(hpatch_TStreamOutput const*, unsigned long long, unsigned char const*, unsigned char const*)
static hpatch_BOOL _NewStream_write(const hpatch_TStreamOutput* stream,
                                    const hpatch_StreamPos_t _writeToPos,
                                    const unsigned char* data,const unsigned char* data_end){
    size_t dataSize=(size_t)(data_end-data);
    hpatch_StreamPos_t writeToPos=_writeToPos;
    NewStream* self=(NewStream*)stream->streamImport;
    check(!self->isFinish);
    assert(dataSize>=0);
    assert(writeToPos<=self->_curWriteToPosEnd);
    if (writeToPos+dataSize>self->_curWriteToPosEnd){
        size_t leftLen=(size_t)(self->_curWriteToPosEnd-writeToPos);
        check(_NewStream_write(stream,writeToPos,data,data+leftLen));
        check(_NewStream_write(stream,writeToPos+leftLen,data+leftLen,data_end));
        return hpatch_TRUE;
    }
    
    //write data
    if (self->_curFileIndex<0){//fvce
        memcpy(self->_newZipVCE._cache_fvce+self->_extraEditSize+writeToPos,data,dataSize);
    }else{
        check(self->_curFileIndex<self->_fileCount);
#if (_IS_NEED_VIRTUAL_ZIP)
        if ((self->_vout)&&(self->_vout->virtualStream)){
            hpatch_TStreamOutput* stream=self->_vout->virtualStream;
            hpatch_StreamPos_t wpos=stream->streamSize-(self->_curWriteToPosEnd-writeToPos);
            check(stream->write(stream,wpos,data,data+dataSize));
        }else
#endif
            check(Zipper_file_append_part(self->_out_newZip,data,dataSize));
    }
    
    if (writeToPos+dataSize<self->_curWriteToPosEnd)//write continue
        return hpatch_TRUE;
    
    //write one end
    if (self->_curFileIndex<0){//vce ok
        check(UnZipper_updateVirtualVCE(&self->_newZipVCE,self->_newZipIsDataNormalized,self->_newZipCESize));
        bool newIsStable=self->_newZipVCE._isDataNormalized && UnZipper_isHaveApkV2Sign(&self->_newZipVCE);
        bool oldIsStable=self->_oldZip->_isDataNormalized && UnZipper_isHaveApkV2Sign(self->_oldZip);
        self->_isAlwaysReCompress=newIsStable&(!oldIsStable);
        //if (newIsStable)
            Zipper_by_multi_thread(self->_out_newZip,self->_threadNum);
    }else{
        check(Zipper_file_append_end(self->_out_newZip));
#if (_IS_NEED_VIRTUAL_ZIP)
        if ((self->_vout)&&(self->_vout->virtualStream))
            check(self->_vout->endVirtual(self->_vout));
#endif
    }
    ++self->_curFileIndex;
    
    while (self->_curFileIndex<self->_fileCount) {
        if ((self->_curSamePairIndex<self->_samePairCount)
            &&(self->_curFileIndex==(int)self->_samePairList[self->_curSamePairIndex*2])){
            const uint32_t* pairNewiOldi=self->_samePairList+self->_curSamePairIndex*2;
            check(_copy_same_file(self,pairNewiOldi[0],pairNewiOldi[1]));
            ++self->_curSamePairIndex;
            ++self->_curFileIndex;
        }else if ((0==UnZipper_file_uncompressedSize(&self->_newZipVCE,self->_curFileIndex))
                  &&(!UnZipper_file_isCompressed(&self->_newZipVCE,self->_curFileIndex))){
            _update_compressedSize(self,self->_curFileIndex,0);
#if (_IS_NEED_VIRTUAL_ZIP)
            if (self->_vout){
                TVirtualZip_out_type ty=self->_vout->beginVirtual(self->_vout,&self->_newZipVCE,self->_curFileIndex);
                switch (ty) {
                    case kVirtualZip_out_void: { //ok, do nothing
                        assert(self->_vout->virtualStream==0); } break;
                    case kVirtualZip_out_emptyFile_cast: { //ok, already fileSize==0, do nothing
                        assert(self->_vout->virtualStream==0); } break;
                    case kVirtualZip_out_emptyFile_uncompressed: { //already fileSize==0, need endVirtual
                        assert(self->_vout->virtualStream!=0); } break;
                    default: { check(false); } break; //error, or unknow as error
                }
            }
#endif
            check(Zipper_file_append_begin(self->_out_newZip,&self->_newZipVCE,self->_curFileIndex,false,0,0));
            check(Zipper_file_append_end(self->_out_newZip));
#if (_IS_NEED_VIRTUAL_ZIP)
            if ((self->_vout)&&(self->_vout->virtualStream))
                check(self->_vout->endVirtual(self->_vout));
#endif
            ++self->_curFileIndex;
        }else{//open file for write
            ZipFilePos_t uncompressedSize=UnZipper_file_uncompressedSize(&self->_newZipVCE,self->_curFileIndex);
            ZipFilePos_t compressedSize=uncompressedSize;
            if (UnZipper_file_isCompressed(&self->_newZipVCE,self->_curFileIndex)){
                check(self->_curNewReCompressSizeIndex<self->_newReCompressSizeCount);
                compressedSize=self->_newReCompressSizeList[self->_curNewReCompressSizeIndex];
                ++self->_curNewReCompressSizeIndex;
            }
            _update_compressedSize(self,self->_curFileIndex,compressedSize);
            
            bool isWriteOtherCompressedData=(self->_curNewOtherCompressIndex<self->_newRefOtherCompressedCount)
                    &&((int)self->_newRefOtherCompressedList[self->_curNewOtherCompressIndex]==self->_curFileIndex);
            if (isWriteOtherCompressedData)
                ++self->_curNewOtherCompressIndex;

            bool isVirtualFile0Size=false; // is notInZip virtualFile && uncompressedFizeSize==0 ?
    #if (_IS_NEED_VIRTUAL_ZIP)
            TVirtualZip_out_type ty=kVirtualZip_out_void;
            if (self->_vout){
                ty=self->_vout->beginVirtual(self->_vout,&self->_newZipVCE,self->_curFileIndex);
                switch (ty) {
                    case kVirtualZip_out_void: { //ok, do nothing
                        assert(self->_vout->virtualStream==0); } break;
                    case kVirtualZip_out_emptyFile_cast: { // set fileSize==0
                        assert(self->_vout->virtualStream==0);
                        _update_fileSize(self,self->_curFileIndex,0,0);
                        isVirtualFile0Size=true; } break;
                    case kVirtualZip_out_emptyFile_uncompressed: { //set fileSize==0, need out and endVirtual
                        assert(self->_vout->virtualStream!=0);
                        _update_fileSize(self,self->_curFileIndex,0,0);
                        isVirtualFile0Size=true; } break;
                    default: { check(false); } break; //error, or unknow as error
                }
            }
    #endif
            if (isWriteOtherCompressedData && self->_newOtherCompressIsValid){
                check(Zipper_file_append_beginWith(self->_out_newZip,&self->_newZipVCE,self->_curFileIndex,
                                                   false,isVirtualFile0Size?0:uncompressedSize,isVirtualFile0Size?0:compressedSize,
                                                   self->_newOtherCompressLevel,self->_newOtherCompressMemLevel));
                self->_curWriteToPosEnd+=uncompressedSize;
            }else{
    #if (_IS_NEED_VIRTUAL_ZIP)
                if (ty==kVirtualZip_out_emptyFile_uncompressed){
                    check(!isWriteOtherCompressedData); //now unsupport auto decompress data
                }
    #endif
                check(Zipper_file_append_begin(self->_out_newZip,&self->_newZipVCE,self->_curFileIndex,
                                            isWriteOtherCompressedData,
                                            isVirtualFile0Size?0:uncompressedSize,isVirtualFile0Size?0:compressedSize));
                self->_curWriteToPosEnd+=isWriteOtherCompressedData?compressedSize:uncompressedSize;
            }

            if ((!isVirtualFile0Size)&&(uncompressedSize==0)){ // compressed && empty file 
                check(Zipper_file_append_part(self->_out_newZip,0,0));
                check(Zipper_file_append_end(self->_out_newZip));
                ++self->_curFileIndex;
            }else{
                return hpatch_TRUE; //opened a file wait for write;
            }
        }
    }
    
    //file entry end
    check(_file_entry_end(self));
    return hpatch_TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movl $0x0, 0x4(%rsp)
movq (%r14), %r13
cmpb $0x1, 0x8(%r13)
je 0x53ad8
movq 0xa8(%r13), %rbp
movq %rbp, %r15
subq %rsi, %r15
jb 0x53b03
movq %rbx, %rax
subq %rdx, %rax
leaq (%rax,%rsi), %r12
cmpq %rbp, %r12
jbe 0x53599
addq %rdx, %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0x5351c
testb $0x1, 0x4(%rsp)
movl 0xc(%rsp), %eax
movl $0x1, %ecx
cmovel %ecx, %eax
movl %eax, 0xc(%rsp)
movb $0x1, %al
movl %eax, 0x4(%rsp)
movq %rbp, %rsi
movq %r15, %rdx
jmp 0x53538
movl 0xa4(%r13), %ecx
testl %ecx, %ecx
js 0x535ef
cmpl 0x90(%r13), %ecx
jge 0x53d26
movq 0x10(%r13), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x42ab8
testb %al, %al
jne 0x5360b
leaq 0x13869(%rip), %rdi     # 0x66e34
callq 0x44e0
leaq 0x6a79(%rip), %rdi      # 0x5a050
leaq 0x13532(%rip), %rsi     # 0x66b10
leaq 0x1363b(%rip), %rcx     # 0x66c20
movl $0x54, %edx
callq 0x4200
movq 0x170(%r13), %rdi
addq 0x98(%r13), %rdi
addq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x4290
cmpq 0xa8(%r13), %r12
jb 0x53aba
cmpl $0x0, 0xa4(%r13)
js 0x5365e
movq 0x10(%r13), %rdi
callq 0x4273b
testb %al, %al
jne 0x536d0
leaq 0x13cfe(%rip), %rdi     # 0x67338
callq 0x44e0
leaq 0x6a0a(%rip), %rdi      # 0x5a050
leaq 0x134c3(%rip), %rsi     # 0x66b10
leaq 0x135cc(%rip), %rcx     # 0x66c20
movl $0x63, %edx
callq 0x4200
leaq 0xd0(%r13), %rdi
movzbl 0x20(%r13), %esi
movq 0x28(%r13), %rdx
callq 0x4086a
testb %al, %al
je 0x53ed4
cmpb $0x1, 0x159(%r13)
jne 0x53698
movq 0x168(%r13), %rax
cmpq 0x120(%r13), %rax
setb %al
jmp 0x5369a
xorl %eax, %eax
movq 0x18(%r13), %rdx
movb $0x1, %cl
cmpb $0x1, 0x89(%rdx)
jne 0x536b7
movq 0x98(%rdx), %rcx
cmpq 0x50(%rdx), %rcx
setae %cl
andb %al, %cl
movb %cl, 0xc8(%r13)
movq 0x10(%r13), %rdi
movl 0xa0(%r13), %esi
callq 0x411b7
movl 0x90(%r13), %eax
movl 0xa4(%r13), %esi
incl %esi
movl %esi, 0xa4(%r13)
cmpl %eax, %esi
jge 0x53a13
leaq 0xd0(%r13), %r15
movq 0xb0(%r13), %rax
cmpq 0x38(%r13), %rax
jae 0x5382c
movq 0x30(%r13), %rcx
movslq (%rcx,%rax,8), %r14
cmpl %r14d, %esi
jne 0x5382c
movl 0x4(%rcx,%rax,8), %ebp
movq 0x18(%r13), %rdi
movl %ebp, %esi
callq 0x3fee7
movb %al, 0x2(%rsp)
movq 0x18(%r13), %rdi
movl %ebp, %esi
callq 0x4092e
movl %eax, %r12d
movq 0x18(%r13), %rdi
movl %ebp, %esi
callq 0x4094c
movl %eax, %ebx
movq 0x18(%r13), %rdi
movl %ebp, 0x8(%rsp)
movl %ebp, %esi
callq 0x40941
movl %eax, %ebp
movq %r15, %rdi
movl %r14d, %esi
callq 0x4092e
cmpl %r12d, %eax
jne 0x53bf9
movq %rbp, 0x10(%rsp)
movq %r15, %rdi
movl %r14d, %esi
callq 0x4094c
cmpl %ebx, %eax
jne 0x53c24
movq %r15, %rdi
movl %r14d, %esi
callq 0x3fee7
movl %eax, %ebx
movb %al, 0x3(%rsp)
xorb $0x1, %bl
andb 0x2(%rsp), %bl
orb 0xc8(%r13), %bl
sete %bpl
movq %r15, %rdi
movl %r14d, %esi
callq 0x40941
testl %eax, %eax
movq 0x10(%rsp), %r9
cmovnel %eax, %r9d
cmpb $0x0, 0x3(%rsp)
movl %r12d, %r8d
cmovnel %r9d, %r12d
movq 0x130(%r13), %rax
movl %r12d, (%rax,%r14,4)
andb 0x2(%rsp), %bpl
movq 0x10(%r13), %rdi
movzbl %bpl, %ecx
movq %r15, %rsi
movl %r14d, %edx
callq 0x41c0e
testb %al, %al
je 0x53c4f
movq 0x10(%r13), %rdi
callq 0x42a83
testq %rax, %rax
je 0x539dc
movq 0x18(%r13), %rdi
testb %bl, %bl
je 0x539c6
movl 0x8(%rsp), %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x40d86
testb %al, %al
jne 0x539dc
jmp 0x53d51
movq %r15, %rdi
callq 0x4092e
testl %eax, %eax
jne 0x5384f
movl 0xa4(%r13), %esi
movq %r15, %rdi
callq 0x3fee7
testb %al, %al
je 0x5397c
movl 0xa4(%r13), %esi
movq %r15, %rdi
callq 0x4092e
movl %eax, %ebp
movl 0xa4(%r13), %esi
movq %r15, %rdi
callq 0x3fee7
movl %ebp, %ebx
testb %al, %al
je 0x53897
movq 0xc0(%r13), %rax
cmpq 0x68(%r13), %rax
jae 0x53bce
movq 0x60(%r13), %rcx
movl (%rcx,%rax,4), %ebx
incq %rax
movq %rax, 0xc0(%r13)
movslq 0xa4(%r13), %rax
movq 0x130(%r13), %rcx
movl %ebx, (%rcx,%rax,4)
movq 0xb8(%r13), %rax
cmpq 0x48(%r13), %rax
jae 0x538c9
movq 0x40(%r13), %rcx
movl (%rcx,%rax,4), %ecx
cmpl 0xa4(%r13), %ecx
sete %r14b
jmp 0x538cc
xorl %r14d, %r14d
testb %r14b, %r14b
je 0x53918
incq %rax
movq %rax, 0xb8(%r13)
cmpb $0x1, 0x50(%r13)
jne 0x53918
movq 0x10(%r13), %rdi
movl 0xa4(%r13), %edx
movl %ebp, %r14d
movl %ebx, %r9d
movl 0x54(%r13), %eax
movl 0x58(%r13), %r10d
movq %r15, %rsi
xorl %ecx, %ecx
movq %r14, %r8
pushq %r10
pushq %rax
callq 0x41c2a
addq $0x10, %rsp
testb %al, %al
jne 0x53946
jmp 0x53ca5
movq 0x10(%r13), %rdi
movl 0xa4(%r13), %edx
movl %ebp, %r8d
movl %ebx, %r9d
movzbl %r14b, %ecx
movq %r15, %rsi
callq 0x41c0e
testb %al, %al
je 0x53ba3
testb %r14b, %r14b
cmovel %ebp, %ebx
movq %rbx, %r14
addq %r14, 0xa8(%r13)
testl %ebp, %ebp
jne 0x53aba
movq 0x10(%r13), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x42ab8
testb %al, %al
je 0x53b4d
movq 0x10(%r13), %rdi
callq 0x4273b
testb %al, %al
jne 0x539f4
jmp 0x53b78
movslq 0xa4(%r13), %rax
movq 0x130(%r13), %rcx
movl $0x0, (%rcx,%rax,4)
movq 0x10(%r13), %rdi
movl 0xa4(%r13), %edx
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x41c0e
testb %al, %al
je 0x53cd0
movq 0x10(%r13), %rdi
callq 0x4273b
testb %al, %al
jne 0x539f4
jmp 0x53cfb
movl 0x8(%rsp), %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x409cf
testb %al, %al
je 0x53ea9
movq 0x10(%r13), %rdi
callq 0x4273b
testb %al, %al
je 0x53c7a
incq 0xb0(%r13)
movl 0x90(%r13), %eax
movl 0xa4(%r13), %esi
incl %esi
movl %esi, 0xa4(%r13)
cmpl %eax, %esi
jl 0x536f6
cmpb $0x1, 0x8(%r13)
je 0x53d7c
cmpl %eax, %esi
jne 0x53da7
movq 0xb0(%r13), %rax
cmpq 0x38(%r13), %rax
jne 0x53dd2
movq 0xb8(%r13), %rax
cmpq 0x48(%r13), %rax
jne 0x53dfd
movq 0xc0(%r13), %rax
cmpq 0x68(%r13), %rax
jne 0x53e28
movq 0x10(%r13), %rdi
leaq 0xd0(%r13), %rbx
movq %rbx, %rsi
callq 0x42bf1
testb %al, %al
je 0x53e53
cmpl $0x0, 0x90(%r13)
jle 0x53aa1
xorl %ebp, %ebp
movq 0x10(%r13), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x42c11
testb %al, %al
je 0x53b22
incl %ebp
cmpl 0x90(%r13), %ebp
jl 0x53a80
movq 0x10(%r13), %rdi
movq %rbx, %rsi
callq 0x42c62
testb %al, %al
je 0x53e7e
movb $0x1, 0x8(%r13)
testb $0x1, 0x4(%rsp)
movl $0x1, %eax
cmovnel 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13a61(%rip), %rdi     # 0x67540
callq 0x44e0
leaq 0x6565(%rip), %rdi      # 0x5a050
leaq 0x1301e(%rip), %rsi     # 0x66b10
leaq 0x13127(%rip), %rcx     # 0x66c20
movl $0x3e, %edx
callq 0x4200
leaq 0x13199(%rip), %rdi     # 0x66ca3
leaq 0x12fff(%rip), %rsi     # 0x66b10
leaq 0x13108(%rip), %rcx     # 0x66c20
movl $0x40, %edx
callq 0x4200
leaq 0x139d0(%rip), %rdi     # 0x674f9
callq 0x44e0
leaq 0x651b(%rip), %rdi      # 0x5a050
leaq 0x12fd4(%rip), %rsi     # 0x66b10
leaq 0x131ba(%rip), %rcx     # 0x66cfd
movl $0x10f, %edx            # imm = 0x10F
callq 0x4200
leaq 0x135db(%rip), %rdi     # 0x6712f
callq 0x44e0
leaq 0x64f0(%rip), %rdi      # 0x5a050
leaq 0x12fa9(%rip), %rsi     # 0x66b10
leaq 0x130b2(%rip), %rcx     # 0x66c20
movl $0xbf, %edx
callq 0x4200
leaq 0x137b9(%rip), %rdi     # 0x67338
callq 0x44e0
leaq 0x64c5(%rip), %rdi      # 0x5a050
leaq 0x12f7e(%rip), %rsi     # 0x66b10
leaq 0x13087(%rip), %rcx     # 0x66c20
movl $0xc0, %edx
callq 0x4200
leaq 0x133d9(%rip), %rdi     # 0x66f83
callq 0x44e0
leaq 0x649a(%rip), %rdi      # 0x5a050
leaq 0x12f53(%rip), %rsi     # 0x66b10
leaq 0x1305c(%rip), %rcx     # 0x66c20
movl $0xba, %edx
callq 0x4200
leaq 0x13368(%rip), %rdi     # 0x66f3d
callq 0x44e0
leaq 0x646f(%rip), %rdi      # 0x5a050
leaq 0x12f28(%rip), %rsi     # 0x66b10
leaq 0x13031(%rip), %rcx     # 0x66c20
movl $0x8e, %edx
callq 0x4200
leaq 0x13565(%rip), %rdi     # 0x67165
callq 0x44e0
leaq 0x6444(%rip), %rdi      # 0x5a050
leaq 0x12efd(%rip), %rsi     # 0x66b10
leaq 0x130ad(%rip), %rcx     # 0x66cc7
movl $0x12a, %edx            # imm = 0x12A
callq 0x4200
leaq 0x13592(%rip), %rdi     # 0x671bd
callq 0x44e0
leaq 0x6419(%rip), %rdi      # 0x5a050
leaq 0x12ed2(%rip), %rsi     # 0x66b10
leaq 0x13082(%rip), %rcx     # 0x66cc7
movl $0x12b, %edx            # imm = 0x12B
callq 0x4200
leaq 0x135a9(%rip), %rdi     # 0x671ff
callq 0x44e0
leaq 0x63ee(%rip), %rdi      # 0x5a050
leaq 0x12ea7(%rip), %rsi     # 0x66b10
leaq 0x13057(%rip), %rcx     # 0x66cc7
movl $0x14c, %edx            # imm = 0x14C
callq 0x4200
leaq 0x136b7(%rip), %rdi     # 0x67338
callq 0x44e0
leaq 0x63c3(%rip), %rdi      # 0x5a050
leaq 0x12e7c(%rip), %rsi     # 0x66b10
leaq 0x1302c(%rip), %rcx     # 0x66cc7
movl $0x170, %edx            # imm = 0x170
callq 0x4200
leaq 0x13397(%rip), %rdi     # 0x67043
callq 0x44e0
leaq 0x6398(%rip), %rdi      # 0x5a050
leaq 0x12e51(%rip), %rsi     # 0x66b10
leaq 0x12f5a(%rip), %rcx     # 0x66c20
movl $0xb0, %edx
callq 0x4200
leaq 0x13203(%rip), %rdi     # 0x66eda
callq 0x44e0
leaq 0x636d(%rip), %rdi      # 0x5a050
leaq 0x12e26(%rip), %rsi     # 0x66b10
leaq 0x12f2f(%rip), %rcx     # 0x66c20
movl $0x83, %edx
callq 0x4200
leaq 0x13636(%rip), %rdi     # 0x67338
callq 0x44e0
leaq 0x6342(%rip), %rdi      # 0x5a050
leaq 0x12dfb(%rip), %rsi     # 0x66b10
leaq 0x12f04(%rip), %rcx     # 0x66c20
movl $0x84, %edx
callq 0x4200
leaq 0x130db(%rip), %rdi     # 0x66e08
callq 0x44e0
leaq 0x6317(%rip), %rdi      # 0x5a050
leaq 0x12dd0(%rip), %rsi     # 0x66b10
leaq 0x12ed9(%rip), %rcx     # 0x66c20
movl $0x4c, %edx
callq 0x4200
leaq 0x13594(%rip), %rdi     # 0x672ec
callq 0x44e0
leaq 0x62ec(%rip), %rdi      # 0x5a050
leaq 0x12da5(%rip), %rsi     # 0x66b10
leaq 0x12f55(%rip), %rcx     # 0x66cc7
movl $0x169, %edx            # imm = 0x169
callq 0x4200
leaq 0x137bd(%rip), %rdi     # 0x67540
callq 0x44e0
leaq 0x62c1(%rip), %rdi      # 0x5a050
leaq 0x12d7a(%rip), %rsi     # 0x66b10
leaq 0x12f60(%rip), %rcx     # 0x66cfd
movl $0x106, %edx            # imm = 0x106
callq 0x4200
leaq 0x135bb(%rip), %rdi     # 0x67369
callq 0x44e0
leaq 0x6296(%rip), %rdi      # 0x5a050
leaq 0x12d4f(%rip), %rsi     # 0x66b10
leaq 0x12f35(%rip), %rcx     # 0x66cfd
movl $0x107, %edx            # imm = 0x107
callq 0x4200
leaq 0x135bd(%rip), %rdi     # 0x67396
callq 0x44e0
leaq 0x626b(%rip), %rdi      # 0x5a050
leaq 0x12d24(%rip), %rsi     # 0x66b10
leaq 0x12f0a(%rip), %rcx     # 0x66cfd
movl $0x108, %edx            # imm = 0x108
callq 0x4200
leaq 0x135c7(%rip), %rdi     # 0x673cb
callq 0x44e0
leaq 0x6240(%rip), %rdi      # 0x5a050
leaq 0x12cf9(%rip), %rsi     # 0x66b10
leaq 0x12edf(%rip), %rcx     # 0x66cfd
movl $0x109, %edx            # imm = 0x109
callq 0x4200
leaq 0x135e6(%rip), %rdi     # 0x67415
callq 0x44e0
leaq 0x6215(%rip), %rdi      # 0x5a050
leaq 0x12cce(%rip), %rsi     # 0x66b10
leaq 0x12eb4(%rip), %rcx     # 0x66cfd
movl $0x10a, %edx            # imm = 0x10A
callq 0x4200
leaq 0x13602(%rip), %rdi     # 0x6745c
callq 0x44e0
leaq 0x61ea(%rip), %rdi      # 0x5a050
leaq 0x12ca3(%rip), %rsi     # 0x66b10
leaq 0x12e89(%rip), %rcx     # 0x66cfd
movl $0x10c, %edx            # imm = 0x10C
callq 0x4200
leaq 0x13626(%rip), %rdi     # 0x674ab
callq 0x44e0
leaq 0x61bf(%rip), %rdi      # 0x5a050
leaq 0x12c78(%rip), %rsi     # 0x66b10
leaq 0x12e5e(%rip), %rcx     # 0x66cfd
movl $0x111, %edx            # imm = 0x111
callq 0x4200
leaq 0x133f6(%rip), %rdi     # 0x672a6
callq 0x44e0
leaq 0x6194(%rip), %rdi      # 0x5a050
leaq 0x12c4d(%rip), %rsi     # 0x66b10
leaq 0x12dfd(%rip), %rcx     # 0x66cc7
movl $0x16b, %edx            # imm = 0x16B
callq 0x4200
leaq 0x12f99(%rip), %rdi     # 0x66e74
callq 0x44e0
leaq 0x6169(%rip), %rdi      # 0x5a050
leaq 0x12c22(%rip), %rsi     # 0x66b10
leaq 0x12d2b(%rip), %rcx     # 0x66c20
movl $0x5c, %edx
callq 0x4200
nop