// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%r14), %r13
cmpb $0x1, 0x8(%r13)
je 0x49433
movq 0xa8(%r13), %rbp
movq %rbp, %r15
subq %rsi, %r15
jb 0x49458
movq %rbx, %rax
subq %rdx, %rax
leaq (%rax,%rsi), %r12
cmpq %rbp, %r12
jbe 0x48f11
addq %rdx, %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0x48eb7
movq %rbp, %rsi
movq %r15, %rdx
jmp 0x48ecb
movl 0xa4(%r13), %ecx
testl %ecx, %ecx
js 0x48f64
cmpl 0x90(%r13), %ecx
jge 0x49679
movq 0x10(%r13), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x39945
testb %al, %al
jne 0x48f80
leaq 0x13001(%rip), %rdi     # 0x5bf44
callq 0x4510
leaq 0x6101(%rip), %rdi      # 0x4f050
leaq 0x12cca(%rip), %rsi     # 0x5bc20
leaq 0x12dd3(%rip), %rcx     # 0x5bd30
pushq $0x54
jmp 0x4946f
movq 0x170(%r13), %rdi
addq 0x98(%r13), %rdi
addq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x42c0
cmpq 0xa8(%r13), %r12
jb 0x49421
cmpl $0x0, 0xa4(%r13)
js 0x48fd0
movq 0x10(%r13), %rdi
callq 0x39649
testb %al, %al
jne 0x49042
leaq 0x13499(%rip), %rdi     # 0x5c448
callq 0x4510
leaq 0x6095(%rip), %rdi      # 0x4f050
leaq 0x12c5e(%rip), %rsi     # 0x5bc20
leaq 0x12d67(%rip), %rcx     # 0x5bd30
pushq $0x63
jmp 0x4946f
leaq 0xd0(%r13), %rdi
movzbl 0x20(%r13), %esi
movq 0x28(%r13), %rdx
callq 0x37a44
testb %al, %al
je 0x497f9
cmpb $0x1, 0x159(%r13)
jne 0x4900a
movq 0x168(%r13), %rax
cmpq 0x120(%r13), %rax
setb %al
jmp 0x4900c
xorl %eax, %eax
movq 0x18(%r13), %rdx
movb $0x1, %cl
cmpb $0x1, 0x89(%rdx)
jne 0x49029
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 0x38334
movl 0xa4(%r13), %ebp
incl %ebp
movl %ebp, 0xa4(%r13)
leaq 0xd0(%r13), %r12
movl 0x90(%r13), %eax
cmpl %eax, %ebp
jge 0x49368
movq 0xb0(%r13), %rax
cmpq 0x38(%r13), %rax
jae 0x491a5
movq 0x30(%r13), %rcx
cmpl (%rcx,%rax,8), %ebp
jne 0x491a5
movl 0x4(%rcx,%rax,8), %r14d
movq 0x18(%r13), %rdi
movl %r14d, %esi
callq 0x370d6
movb %al, 0xa(%rsp)
movq 0x18(%r13), %rdi
movl %r14d, %esi
callq 0x37b03
movq %r12, %r15
movl %eax, %r12d
movq 0x18(%r13), %rdi
movl %r14d, %esi
callq 0x37b21
movl %eax, %ebx
movq 0x18(%r13), %rdi
movl %r14d, 0xc(%rsp)
movl %r14d, %esi
callq 0x37b16
movl %eax, %r14d
movq %r15, %rdi
movl %ebp, %esi
callq 0x37b03
cmpl %r12d, %eax
jne 0x4954c
movq %r14, 0x10(%rsp)
movq %r15, %rdi
movl %ebp, %esi
callq 0x37b21
cmpl %ebx, %eax
jne 0x495a2
movq %r15, %rdi
movl %ebp, %esi
callq 0x370d6
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 0x37b16
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 0x38c7e
testb %al, %al
je 0x49521
movq %r15, %r12
movq 0x10(%r13), %rdi
callq 0x39910
testq %rax, %rax
je 0x4933b
movq 0x18(%r13), %rdi
testb %bl, %bl
je 0x49325
movl 0xc(%rsp), %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x37f48
testb %al, %al
jne 0x4933b
jmp 0x49623
movq %r12, %rdi
movl %ebp, %esi
callq 0x37b03
testl %eax, %eax
jne 0x491ca
movl 0xa4(%r13), %esi
movq %r12, %rdi
callq 0x370d6
testb %al, %al
je 0x492de
movl 0xa4(%r13), %esi
movq %r12, %rdi
callq 0x37b03
movl %eax, %ebp
movl 0xa4(%r13), %esi
movq %r12, %rdi
callq 0x370d6
movl %ebp, %ebx
testb %al, %al
je 0x49212
movq 0xc0(%r13), %rax
cmpq 0x68(%r13), %rax
jae 0x494f6
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 0x49281
movq 0x40(%r13), %rcx
cmpl %edx, (%rcx,%rax,4)
jne 0x49281
incq %rax
movq %rax, 0xb8(%r13)
movb $0x1, %r15b
cmpb $0x1, 0x50(%r13)
jne 0x49284
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 0x38c98
popq %rcx
popq %rdx
testb %al, %al
jne 0x492a8
jmp 0x4964e
xorl %r15d, %r15d
movq 0x10(%r13), %rdi
movzbl %r15b, %ecx
movq %r12, %rsi
movq %r14, %r8
callq 0x38c7e
testb %al, %al
je 0x494cb
testb %r15b, %r15b
cmovel %ebp, %ebx
movq %rbx, %r14
addq %r14, 0xa8(%r13)
testl %ebp, %ebp
jne 0x49421
movq 0x10(%r13), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x39945
testb %al, %al
je 0x494a0
movq 0x10(%r13), %rdi
callq 0x39649
testb %al, %al
jne 0x49353
jmp 0x49475
movslq 0xa4(%r13), %rax
movq 0x130(%r13), %rcx
andl $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 0x38c7e
testb %al, %al
je 0x495cd
movq 0x10(%r13), %rdi
callq 0x39649
testb %al, %al
jne 0x49353
jmp 0x495f8
movl 0xc(%rsp), %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x37ba4
testb %al, %al
je 0x496a1
movq 0x10(%r13), %rdi
callq 0x39649
testb %al, %al
je 0x49577
incq 0xb0(%r13)
movl 0xa4(%r13), %ebp
incl %ebp
movl %ebp, 0xa4(%r13)
jmp 0x49059
cmpb $0x1, 0x8(%r13)
je 0x496cc
cmpl %eax, %ebp
jne 0x496f7
movq 0xb0(%r13), %rax
cmpq 0x38(%r13), %rax
jne 0x49722
movq 0xb8(%r13), %rax
cmpq 0x48(%r13), %rax
jne 0x4974d
movq 0xc0(%r13), %rax
cmpq 0x68(%r13), %rax
jne 0x49778
movq 0x10(%r13), %rdi
movq %r12, %rsi
callq 0x39a3c
testb %al, %al
je 0x497a3
xorl %ebx, %ebx
movq 0x10(%r13), %rdi
cmpl 0x90(%r13), %ebx
jge 0x4940c
movq %r12, %rsi
movl %ebx, %edx
callq 0x39a5c
incl %ebx
testb %al, %al
jne 0x493c4
leaq 0x13221(%rip), %rdi     # 0x5c609
callq 0x4510
leaq 0x5c5c(%rip), %rdi      # 0x4f050
leaq 0x12825(%rip), %rsi     # 0x5bc20
leaq 0x12a0b(%rip), %rcx     # 0x5be0d
movl $0x10f, %edx            # imm = 0x10F
callq 0x4230
movq %r12, %rsi
callq 0x39aab
testb %al, %al
je 0x497ce
movb $0x1, 0x8(%r13)
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13216(%rip), %rdi     # 0x5c650
callq 0x4510
leaq 0x5c0a(%rip), %rdi      # 0x4f050
leaq 0x127d3(%rip), %rsi     # 0x5bc20
leaq 0x128dc(%rip), %rcx     # 0x5bd30
pushq $0x3e
jmp 0x4946f
leaq 0x12954(%rip), %rdi     # 0x5bdb3
leaq 0x127ba(%rip), %rsi     # 0x5bc20
leaq 0x128c3(%rip), %rcx     # 0x5bd30
pushq $0x40
popq %rdx
callq 0x4230
leaq 0x12fcc(%rip), %rdi     # 0x5c448
callq 0x4510
leaq 0x5bc8(%rip), %rdi      # 0x4f050
leaq 0x12791(%rip), %rsi     # 0x5bc20
leaq 0x1289a(%rip), %rcx     # 0x5bd30
movl $0xc0, %edx
callq 0x4230
leaq 0x12d98(%rip), %rdi     # 0x5c23f
callq 0x4510
leaq 0x5b9d(%rip), %rdi      # 0x4f050
leaq 0x12766(%rip), %rsi     # 0x5bc20
leaq 0x1286f(%rip), %rcx     # 0x5bd30
movl $0xbf, %edx
callq 0x4230
leaq 0x12bc1(%rip), %rdi     # 0x5c093
callq 0x4510
leaq 0x5b72(%rip), %rdi      # 0x4f050
leaq 0x1273b(%rip), %rsi     # 0x5bc20
leaq 0x12844(%rip), %rcx     # 0x5bd30
movl $0xba, %edx
callq 0x4230
leaq 0x12b50(%rip), %rdi     # 0x5c04d
callq 0x4510
leaq 0x5b47(%rip), %rdi      # 0x4f050
leaq 0x12710(%rip), %rsi     # 0x5bc20
leaq 0x12819(%rip), %rcx     # 0x5bd30
movl $0x8e, %edx
callq 0x4230
leaq 0x12de7(%rip), %rdi     # 0x5c30f
callq 0x4510
leaq 0x5b1c(%rip), %rdi      # 0x4f050
leaq 0x126e5(%rip), %rsi     # 0x5bc20
leaq 0x12895(%rip), %rcx     # 0x5bdd7
movl $0x14c, %edx            # imm = 0x14C
callq 0x4230
leaq 0x12d22(%rip), %rdi     # 0x5c275
callq 0x4510
leaq 0x5af1(%rip), %rdi      # 0x4f050
leaq 0x126ba(%rip), %rsi     # 0x5bc20
leaq 0x1286a(%rip), %rcx     # 0x5bdd7
movl $0x12a, %edx            # imm = 0x12A
callq 0x4230
leaq 0x12eca(%rip), %rdi     # 0x5c448
callq 0x4510
leaq 0x5ac6(%rip), %rdi      # 0x4f050
leaq 0x1268f(%rip), %rsi     # 0x5bc20
leaq 0x1283f(%rip), %rcx     # 0x5bdd7
movl $0x170, %edx            # imm = 0x170
callq 0x4230
leaq 0x12d24(%rip), %rdi     # 0x5c2cd
callq 0x4510
leaq 0x5a9b(%rip), %rdi      # 0x4f050
leaq 0x12664(%rip), %rsi     # 0x5bc20
leaq 0x12814(%rip), %rcx     # 0x5bdd7
movl $0x12b, %edx            # imm = 0x12B
callq 0x4230
leaq 0x12a16(%rip), %rdi     # 0x5bfea
callq 0x4510
leaq 0x5a70(%rip), %rdi      # 0x4f050
leaq 0x12639(%rip), %rsi     # 0x5bc20
leaq 0x12742(%rip), %rcx     # 0x5bd30
movl $0x83, %edx
callq 0x4230
leaq 0x12e49(%rip), %rdi     # 0x5c448
callq 0x4510
leaq 0x5a45(%rip), %rdi      # 0x4f050
leaq 0x1260e(%rip), %rsi     # 0x5bc20
leaq 0x12717(%rip), %rcx     # 0x5bd30
movl $0x84, %edx
callq 0x4230
leaq 0x12dd2(%rip), %rdi     # 0x5c3fc
callq 0x4510
leaq 0x5a1a(%rip), %rdi      # 0x4f050
leaq 0x125e3(%rip), %rsi     # 0x5bc20
leaq 0x12793(%rip), %rcx     # 0x5bdd7
movl $0x169, %edx            # imm = 0x169
callq 0x4230
leaq 0x12afe(%rip), %rdi     # 0x5c153
callq 0x4510
leaq 0x59ef(%rip), %rdi      # 0x4f050
leaq 0x125b8(%rip), %rsi     # 0x5bc20
leaq 0x126c1(%rip), %rcx     # 0x5bd30
movl $0xb0, %edx
callq 0x4230
leaq 0x12898(%rip), %rdi     # 0x5bf18
callq 0x4510
leaq 0x59c4(%rip), %rdi      # 0x4f050
leaq 0x1258d(%rip), %rsi     # 0x5bc20
leaq 0x12696(%rip), %rcx     # 0x5bd30
pushq $0x4c
jmp 0x4946f
leaq 0x12d0e(%rip), %rdi     # 0x5c3b6
callq 0x4510
leaq 0x599c(%rip), %rdi      # 0x4f050
leaq 0x12565(%rip), %rsi     # 0x5bc20
leaq 0x12715(%rip), %rcx     # 0x5bdd7
movl $0x16b, %edx            # imm = 0x16B
callq 0x4230
leaq 0x12f7d(%rip), %rdi     # 0x5c650
callq 0x4510
leaq 0x5971(%rip), %rdi      # 0x4f050
leaq 0x1253a(%rip), %rsi     # 0x5bc20
leaq 0x12720(%rip), %rcx     # 0x5be0d
movl $0x106, %edx            # imm = 0x106
callq 0x4230
leaq 0x12d7b(%rip), %rdi     # 0x5c479
callq 0x4510
leaq 0x5946(%rip), %rdi      # 0x4f050
leaq 0x1250f(%rip), %rsi     # 0x5bc20
leaq 0x126f5(%rip), %rcx     # 0x5be0d
movl $0x107, %edx            # imm = 0x107
callq 0x4230
leaq 0x12d7d(%rip), %rdi     # 0x5c4a6
callq 0x4510
leaq 0x591b(%rip), %rdi      # 0x4f050
leaq 0x124e4(%rip), %rsi     # 0x5bc20
leaq 0x126ca(%rip), %rcx     # 0x5be0d
movl $0x108, %edx            # imm = 0x108
callq 0x4230
leaq 0x12d87(%rip), %rdi     # 0x5c4db
callq 0x4510
leaq 0x58f0(%rip), %rdi      # 0x4f050
leaq 0x124b9(%rip), %rsi     # 0x5bc20
leaq 0x1269f(%rip), %rcx     # 0x5be0d
movl $0x109, %edx            # imm = 0x109
callq 0x4230
leaq 0x12da6(%rip), %rdi     # 0x5c525
callq 0x4510
leaq 0x58c5(%rip), %rdi      # 0x4f050
leaq 0x1248e(%rip), %rsi     # 0x5bc20
leaq 0x12674(%rip), %rcx     # 0x5be0d
movl $0x10a, %edx            # imm = 0x10A
callq 0x4230
leaq 0x12dc2(%rip), %rdi     # 0x5c56c
callq 0x4510
leaq 0x589a(%rip), %rdi      # 0x4f050
leaq 0x12463(%rip), %rsi     # 0x5bc20
leaq 0x12649(%rip), %rcx     # 0x5be0d
movl $0x10c, %edx            # imm = 0x10C
callq 0x4230
leaq 0x12de6(%rip), %rdi     # 0x5c5bb
callq 0x4510
leaq 0x586f(%rip), %rdi      # 0x4f050
leaq 0x12438(%rip), %rsi     # 0x5bc20
leaq 0x1261e(%rip), %rcx     # 0x5be0d
movl $0x111, %edx            # imm = 0x111
callq 0x4230
leaq 0x12784(%rip), %rdi     # 0x5bf84
callq 0x4510
leaq 0x5844(%rip), %rdi      # 0x4f050
leaq 0x1240d(%rip), %rsi     # 0x5bc20
leaq 0x12516(%rip), %rcx     # 0x5bd30
pushq $0x5c
jmp 0x4946f
nopl (%rax)