// File: /workspace/github_cpp_makefile_star2_O3/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 (%rdi), %r13
cmpb $0x0, 0x8(%r13)
jne 0x533aa
movq %rcx, %rbx
movq %rdi, %r14
movq 0xa8(%r13), %rbp
movq %rbp, %r15
subq %rsi, %r15
jb 0x538f8
movq %rbx, %rax
subq %rdx, %rax
leaq (%rax,%rsi), %r12
cmpq %rbp, %r12
jbe 0x533d5
addq %rdx, %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0x5334c
movq (%r14), %r13
cmpb $0x0, 0x8(%r13)
movq %r15, %rdx
movq %rbp, %rsi
je 0x5336a
leaq 0x1423f(%rip), %rdi     # 0x675f0
callq 0x44e0
leaq 0x6c93(%rip), %rdi      # 0x5a050
leaq 0x137fc(%rip), %rsi     # 0x66bc0
leaq 0x13905(%rip), %rcx     # 0x66cd0
movl $0x3e, %edx
callq 0x4200
movl 0xa4(%r13), %ecx
testl %ecx, %ecx
js 0x5342b
cmpl 0x90(%r13), %ecx
jge 0x53af0
movq 0x10(%r13), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x425c9
testb %al, %al
jne 0x53447
leaq 0x13add(%rip), %rdi     # 0x66ee4
callq 0x44e0
leaq 0x6c3d(%rip), %rdi      # 0x5a050
leaq 0x137a6(%rip), %rsi     # 0x66bc0
leaq 0x138af(%rip), %rcx     # 0x66cd0
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 0x538e4
cmpl $0x0, 0xa4(%r13)
js 0x5349a
movq 0x10(%r13), %rdi
callq 0x4224c
testb %al, %al
jne 0x5350c
leaq 0x13f72(%rip), %rdi     # 0x673e8
callq 0x44e0
leaq 0x6bce(%rip), %rdi      # 0x5a050
leaq 0x13737(%rip), %rsi     # 0x66bc0
leaq 0x13840(%rip), %rcx     # 0x66cd0
movl $0x63, %edx
callq 0x4200
leaq 0xd0(%r13), %rdi
movzbl 0x20(%r13), %esi
movq 0x28(%r13), %rdx
callq 0x4045c
testb %al, %al
je 0x53cc9
cmpb $0x1, 0x159(%r13)
jne 0x534d4
movq 0x168(%r13), %rax
cmpq 0x120(%r13), %rax
setb %al
jmp 0x534d6
xorl %eax, %eax
movq 0x18(%r13), %rdx
movb $0x1, %cl
cmpb $0x1, 0x89(%rdx)
jne 0x534f3
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 0x40db1
movl 0x90(%r13), %eax
movl 0xa4(%r13), %ebp
incl %ebp
movl %ebp, 0xa4(%r13)
cmpl %eax, %ebp
jge 0x53841
leaq 0xd0(%r13), %r12
movq 0xb0(%r13), %rax
cmpq 0x38(%r13), %rax
jae 0x5366f
movq 0x30(%r13), %rcx
cmpl (%rcx,%rax,8), %ebp
jne 0x5366f
movl 0x4(%rcx,%rax,8), %r14d
movq 0x18(%r13), %rdi
movl %r14d, %esi
callq 0x3fadd
movb %al, 0xa(%rsp)
movq 0x18(%r13), %rdi
movl %r14d, %esi
callq 0x40520
movq %r12, %r15
movl %eax, %r12d
movq 0x18(%r13), %rdi
movl %r14d, %esi
callq 0x4053e
movl %eax, %ebx
movq 0x18(%r13), %rdi
movl %r14d, 0xc(%rsp)
movl %r14d, %esi
callq 0x40533
movl %eax, %r14d
movq %r15, %rdi
movl %ebp, %esi
callq 0x40520
cmpl %r12d, %eax
jne 0x539ee
movq %r14, 0x10(%rsp)
movq %r15, %rdi
movl %ebp, %esi
callq 0x4053e
cmpl %ebx, %eax
jne 0x53a19
movq %r15, %rdi
movl %ebp, %esi
callq 0x3fadd
movl %eax, %ebx
movb %al, 0xb(%rsp)
xorb $0x1, %bl
andb 0xa(%rsp), %bl
orb 0xc8(%r13), %bl
sete %r14b
movq %r15, %rdi
movl %ebp, %esi
callq 0x40533
testl %eax, %eax
movq 0x10(%rsp), %r9
cmovnel %eax, %r9d
cmpb $0x0, 0xb(%rsp)
movl %r12d, %r8d
cmovnel %r9d, %r12d
movq 0x130(%r13), %rax
movslq %ebp, %rcx
movl %r12d, (%rax,%rcx,4)
andb 0xa(%rsp), %r14b
movq 0x10(%r13), %rdi
movzbl %r14b, %ecx
movq %r15, %rsi
movl %ebp, %edx
callq 0x41762
testb %al, %al
je 0x53a44
movq %r15, %r12
movq 0x10(%r13), %rdi
callq 0x42594
testq %rax, %rax
je 0x5380a
movq 0x18(%r13), %rdi
testb %bl, %bl
je 0x537f4
movl 0xc(%rsp), %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x40983
testb %al, %al
jne 0x5380a
jmp 0x53b1b
movq %r12, %rdi
movl %ebp, %esi
callq 0x40520
testl %eax, %eax
jne 0x53694
movl 0xa4(%r13), %esi
movq %r12, %rdi
callq 0x3fadd
testb %al, %al
je 0x537aa
movl 0xa4(%r13), %esi
movq %r12, %rdi
callq 0x40520
movl %eax, %ebp
movl 0xa4(%r13), %esi
movq %r12, %rdi
callq 0x3fadd
movl %ebp, %ebx
testb %al, %al
je 0x536dc
movq 0xc0(%r13), %rax
cmpq 0x68(%r13), %rax
jae 0x539c3
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
movl 0xa4(%r13), %edx
movl %ebp, %r14d
movl %ebx, %r9d
cmpq 0x48(%r13), %rax
jae 0x5374d
movq 0x40(%r13), %rcx
cmpl %edx, (%rcx,%rax,4)
jne 0x5374d
incq %rax
movq %rax, 0xb8(%r13)
movb $0x1, %r15b
cmpb $0x1, 0x50(%r13)
jne 0x53750
movq 0x10(%r13), %rdi
movl 0x54(%r13), %eax
movl 0x58(%r13), %r10d
movq %r12, %rsi
xorl %ecx, %ecx
movq %r14, %r8
pushq %r10
pushq %rax
callq 0x4177e
addq $0x10, %rsp
testb %al, %al
jne 0x53774
jmp 0x53c73
xorl %r15d, %r15d
movq 0x10(%r13), %rdi
movzbl %r15b, %ecx
movq %r12, %rsi
movq %r14, %r8
callq 0x41762
testb %al, %al
je 0x53998
testb %r15b, %r15b
cmovel %ebp, %ebx
movq %rbx, %r14
addq %r14, 0xa8(%r13)
testl %ebp, %ebp
jne 0x538e4
movq 0x10(%r13), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x425c9
testb %al, %al
je 0x53942
movq 0x10(%r13), %rdi
callq 0x4224c
testb %al, %al
jne 0x53822
jmp 0x5396d
movslq 0xa4(%r13), %rax
movq 0x130(%r13), %rcx
movl $0x0, (%rcx,%rax,4)
movq 0x10(%r13), %rdi
movl 0xa4(%r13), %edx
movq %r12, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x41762
testb %al, %al
je 0x53a9a
movq 0x10(%r13), %rdi
callq 0x4224c
testb %al, %al
jne 0x53822
jmp 0x53ac5
movl 0xc(%rsp), %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x405c1
testb %al, %al
je 0x53c9e
movq 0x10(%r13), %rdi
callq 0x4224c
testb %al, %al
je 0x53a6f
incq 0xb0(%r13)
movl 0x90(%r13), %eax
movl 0xa4(%r13), %ebp
incl %ebp
movl %ebp, 0xa4(%r13)
cmpl %eax, %ebp
jl 0x53532
cmpb $0x1, 0x8(%r13)
je 0x53b46
cmpl %eax, %ebp
jne 0x53b71
movq 0xb0(%r13), %rax
cmpq 0x38(%r13), %rax
jne 0x53b9c
movq 0xb8(%r13), %rax
cmpq 0x48(%r13), %rax
jne 0x53bc7
movq 0xc0(%r13), %rax
cmpq 0x68(%r13), %rax
jne 0x53bf2
movq 0x10(%r13), %rdi
leaq 0xd0(%r13), %rbx
movq %rbx, %rsi
callq 0x426f3
testb %al, %al
je 0x53c1d
cmpl $0x0, 0x90(%r13)
jle 0x538cb
xorl %ebp, %ebp
movq 0x10(%r13), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x42713
testb %al, %al
je 0x53917
incl %ebp
cmpl 0x90(%r13), %ebp
jl 0x538ae
movq 0x10(%r13), %rdi
movq %rbx, %rsi
callq 0x42766
testb %al, %al
je 0x53c48
movb $0x1, 0x8(%r13)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13454(%rip), %rdi     # 0x66d53
leaq 0x132ba(%rip), %rsi     # 0x66bc0
leaq 0x133c3(%rip), %rcx     # 0x66cd0
movl $0x40, %edx
callq 0x4200
leaq 0x13c8b(%rip), %rdi     # 0x675a9
callq 0x44e0
leaq 0x6726(%rip), %rdi      # 0x5a050
leaq 0x1328f(%rip), %rsi     # 0x66bc0
leaq 0x13475(%rip), %rcx     # 0x66dad
movl $0x10f, %edx            # imm = 0x10F
callq 0x4200
leaq 0x13896(%rip), %rdi     # 0x671df
callq 0x44e0
leaq 0x66fb(%rip), %rdi      # 0x5a050
leaq 0x13264(%rip), %rsi     # 0x66bc0
leaq 0x1336d(%rip), %rcx     # 0x66cd0
movl $0xbf, %edx
callq 0x4200
leaq 0x13a74(%rip), %rdi     # 0x673e8
callq 0x44e0
leaq 0x66d0(%rip), %rdi      # 0x5a050
leaq 0x13239(%rip), %rsi     # 0x66bc0
leaq 0x13342(%rip), %rcx     # 0x66cd0
movl $0xc0, %edx
callq 0x4200
leaq 0x13694(%rip), %rdi     # 0x67033
callq 0x44e0
leaq 0x66a5(%rip), %rdi      # 0x5a050
leaq 0x1320e(%rip), %rsi     # 0x66bc0
leaq 0x13317(%rip), %rcx     # 0x66cd0
movl $0xba, %edx
callq 0x4200
leaq 0x13623(%rip), %rdi     # 0x66fed
callq 0x44e0
leaq 0x667a(%rip), %rdi      # 0x5a050
leaq 0x131e3(%rip), %rsi     # 0x66bc0
leaq 0x132ec(%rip), %rcx     # 0x66cd0
movl $0x8e, %edx
callq 0x4200
leaq 0x13820(%rip), %rdi     # 0x67215
callq 0x44e0
leaq 0x664f(%rip), %rdi      # 0x5a050
leaq 0x131b8(%rip), %rsi     # 0x66bc0
leaq 0x13368(%rip), %rcx     # 0x66d77
movl $0x12a, %edx            # imm = 0x12A
callq 0x4200
leaq 0x1384d(%rip), %rdi     # 0x6726d
callq 0x44e0
leaq 0x6624(%rip), %rdi      # 0x5a050
leaq 0x1318d(%rip), %rsi     # 0x66bc0
leaq 0x1333d(%rip), %rcx     # 0x66d77
movl $0x12b, %edx            # imm = 0x12B
callq 0x4200
leaq 0x13864(%rip), %rdi     # 0x672af
callq 0x44e0
leaq 0x65f9(%rip), %rdi      # 0x5a050
leaq 0x13162(%rip), %rsi     # 0x66bc0
leaq 0x13312(%rip), %rcx     # 0x66d77
movl $0x14c, %edx            # imm = 0x14C
callq 0x4200
leaq 0x13972(%rip), %rdi     # 0x673e8
callq 0x44e0
leaq 0x65ce(%rip), %rdi      # 0x5a050
leaq 0x13137(%rip), %rsi     # 0x66bc0
leaq 0x132e7(%rip), %rcx     # 0x66d77
movl $0x170, %edx            # imm = 0x170
callq 0x4200
leaq 0x134e9(%rip), %rdi     # 0x66f8a
callq 0x44e0
leaq 0x65a3(%rip), %rdi      # 0x5a050
leaq 0x1310c(%rip), %rsi     # 0x66bc0
leaq 0x13215(%rip), %rcx     # 0x66cd0
movl $0x83, %edx
callq 0x4200
leaq 0x1391c(%rip), %rdi     # 0x673e8
callq 0x44e0
leaq 0x6578(%rip), %rdi      # 0x5a050
leaq 0x130e1(%rip), %rsi     # 0x66bc0
leaq 0x131ea(%rip), %rcx     # 0x66cd0
movl $0x84, %edx
callq 0x4200
leaq 0x133c1(%rip), %rdi     # 0x66eb8
callq 0x44e0
leaq 0x654d(%rip), %rdi      # 0x5a050
leaq 0x130b6(%rip), %rsi     # 0x66bc0
leaq 0x131bf(%rip), %rcx     # 0x66cd0
movl $0x4c, %edx
callq 0x4200
leaq 0x1387a(%rip), %rdi     # 0x6739c
callq 0x44e0
leaq 0x6522(%rip), %rdi      # 0x5a050
leaq 0x1308b(%rip), %rsi     # 0x66bc0
leaq 0x1323b(%rip), %rcx     # 0x66d77
movl $0x169, %edx            # imm = 0x169
callq 0x4200
leaq 0x13aa3(%rip), %rdi     # 0x675f0
callq 0x44e0
leaq 0x64f7(%rip), %rdi      # 0x5a050
leaq 0x13060(%rip), %rsi     # 0x66bc0
leaq 0x13246(%rip), %rcx     # 0x66dad
movl $0x106, %edx            # imm = 0x106
callq 0x4200
leaq 0x138a1(%rip), %rdi     # 0x67419
callq 0x44e0
leaq 0x64cc(%rip), %rdi      # 0x5a050
leaq 0x13035(%rip), %rsi     # 0x66bc0
leaq 0x1321b(%rip), %rcx     # 0x66dad
movl $0x107, %edx            # imm = 0x107
callq 0x4200
leaq 0x138a3(%rip), %rdi     # 0x67446
callq 0x44e0
leaq 0x64a1(%rip), %rdi      # 0x5a050
leaq 0x1300a(%rip), %rsi     # 0x66bc0
leaq 0x131f0(%rip), %rcx     # 0x66dad
movl $0x108, %edx            # imm = 0x108
callq 0x4200
leaq 0x138ad(%rip), %rdi     # 0x6747b
callq 0x44e0
leaq 0x6476(%rip), %rdi      # 0x5a050
leaq 0x12fdf(%rip), %rsi     # 0x66bc0
leaq 0x131c5(%rip), %rcx     # 0x66dad
movl $0x109, %edx            # imm = 0x109
callq 0x4200
leaq 0x138cc(%rip), %rdi     # 0x674c5
callq 0x44e0
leaq 0x644b(%rip), %rdi      # 0x5a050
leaq 0x12fb4(%rip), %rsi     # 0x66bc0
leaq 0x1319a(%rip), %rcx     # 0x66dad
movl $0x10a, %edx            # imm = 0x10A
callq 0x4200
leaq 0x138e8(%rip), %rdi     # 0x6750c
callq 0x44e0
leaq 0x6420(%rip), %rdi      # 0x5a050
leaq 0x12f89(%rip), %rsi     # 0x66bc0
leaq 0x1316f(%rip), %rcx     # 0x66dad
movl $0x10c, %edx            # imm = 0x10C
callq 0x4200
leaq 0x1390c(%rip), %rdi     # 0x6755b
callq 0x44e0
leaq 0x63f5(%rip), %rdi      # 0x5a050
leaq 0x12f5e(%rip), %rsi     # 0x66bc0
leaq 0x13144(%rip), %rcx     # 0x66dad
movl $0x111, %edx            # imm = 0x111
callq 0x4200
leaq 0x13479(%rip), %rdi     # 0x670f3
callq 0x44e0
leaq 0x63ca(%rip), %rdi      # 0x5a050
leaq 0x12f33(%rip), %rsi     # 0x66bc0
leaq 0x1303c(%rip), %rcx     # 0x66cd0
movl $0xb0, %edx
callq 0x4200
leaq 0x136b1(%rip), %rdi     # 0x67356
callq 0x44e0
leaq 0x639f(%rip), %rdi      # 0x5a050
leaq 0x12f08(%rip), %rsi     # 0x66bc0
leaq 0x130b8(%rip), %rcx     # 0x66d77
movl $0x16b, %edx            # imm = 0x16B
callq 0x4200
leaq 0x13254(%rip), %rdi     # 0x66f24
callq 0x44e0
leaq 0x6374(%rip), %rdi      # 0x5a050
leaq 0x12edd(%rip), %rsi     # 0x66bc0
leaq 0x12fe6(%rip), %rcx     # 0x66cd0
movl $0x5c, %edx
callq 0x4200