npm - react-native-update - Versions diffs - 8.5.5 → 8.5.6 - Mend

react-native-update 8.5.5 → 8.5.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (762) hide show

package/harmony/src/main/cpp/lzma/Asm/x86/LzmaDecOpt.asm DELETED Viewed

@@ -1,1258 +0,0 @@
-; LzmaDecOpt.asm -- ASM version of LzmaDec_DecodeReal_3() function
-; 2018-02-06: Igor Pavlov : Public domain
-;
-; 3 - is the code compatibility version of LzmaDec_DecodeReal_*()
-; function for check at link time.
-; That code is tightly coupled with LzmaDec_TryDummy()
-; and with another functions in LzmaDec.c file.
-; CLzmaDec structure, (probs) array layout, input and output of
-; LzmaDec_DecodeReal_*() must be equal in both versions (C / ASM).
-ifndef x64
-; x64=1
-; .err <x64_IS_REQUIRED>
-endif
-include 7zAsm.asm
-MY_ASM_START
-_TEXT$LZMADECOPT SEGMENT ALIGN(64) 'CODE'
-MY_ALIGN macro num:req
-        align  num
-endm
-MY_ALIGN_16 macro
-        MY_ALIGN 16
-endm
-MY_ALIGN_32 macro
-        MY_ALIGN 32
-endm
-MY_ALIGN_64 macro
-        MY_ALIGN 64
-endm
-; _LZMA_SIZE_OPT  equ 1
-; _LZMA_PROB32 equ 1
-ifdef _LZMA_PROB32
-        PSHIFT  equ 2
-        PLOAD macro dest, mem
-                mov     dest, dword ptr [mem]
-        endm
-        PSTORE  macro src, mem
-                mov     dword ptr [mem], src
-        endm
-else
-        PSHIFT  equ 1
-        PLOAD macro dest, mem
-                movzx   dest, word ptr [mem]
-        endm
-        PSTORE macro src, mem
-                mov     word ptr [mem], @CatStr(src, _W)
-        endm
-endif
-PMULT           equ (1 SHL PSHIFT)
-PMULT_HALF      equ (1 SHL (PSHIFT - 1))
-PMULT_2         equ (1 SHL (PSHIFT + 1))
-;       x0      range
-;       x1      pbPos / (prob) TREE
-;       x2      probBranch / prm (MATCHED) / pbPos / cnt
-;       x3      sym
-;====== r4 ===  RSP
-;       x5      cod
-;       x6      t1 NORM_CALC / probs_state / dist
-;       x7      t0 NORM_CALC / prob2 IF_BIT_1
-;       x8      state
-;       x9      match (MATCHED) / sym2 / dist2 / lpMask_reg
-;       x10     kBitModelTotal_reg
-;       r11     probs
-;       x12     offs (MATCHED) / dic / len_temp
-;       x13     processedPos
-;       x14     bit (MATCHED) / dicPos
-;       r15     buf
-cod     equ x5
-cod_L   equ x5_L
-range   equ x0
-state   equ x8
-state_R equ r8
-buf     equ r15
-processedPos equ x13
-kBitModelTotal_reg equ x10
-probBranch   equ x2
-probBranch_R equ r2
-probBranch_W equ x2_W
-pbPos   equ x1
-pbPos_R equ r1
-cnt     equ x2
-cnt_R   equ r2
-lpMask_reg equ x9
-dicPos  equ r14
-sym     equ x3
-sym_R   equ r3
-sym_L   equ x3_L
-probs   equ r11
-dic     equ r12
-t0      equ x7
-t0_W    equ x7_W
-t0_R    equ r7
-prob2   equ t0
-prob2_W equ t0_W
-t1      equ x6
-t1_R    equ r6
-probs_state     equ t1
-probs_state_R   equ t1_R
-prm     equ r2
-match   equ x9
-match_R equ r9
-offs    equ x12
-offs_R  equ r12
-bit     equ x14
-bit_R   equ r14
-sym2    equ x9
-sym2_R  equ r9
-len_temp equ x12
-dist    equ sym
-dist2   equ x9
-kNumBitModelTotalBits   equ 11
-kBitModelTotal          equ (1 SHL kNumBitModelTotalBits)
-kNumMoveBits            equ 5
-kBitModelOffset         equ ((1 SHL kNumMoveBits) - 1)
-kTopValue               equ (1 SHL 24)
-NORM_2 macro
-        ; movzx   t0, BYTE PTR [buf]
-        shl     cod, 8
-        mov     cod_L, BYTE PTR [buf]
-        shl     range, 8
-        ; or      cod, t0
-        inc     buf
-endm
-NORM macro
-        cmp     range, kTopValue
-        jae     SHORT @F
-        NORM_2
-@@:
-endm
-; ---------- Branch MACROS ----------
-UPDATE_0 macro probsArray:req, probOffset:req, probDisp:req
-        mov     prob2, kBitModelTotal_reg
-        sub     prob2, probBranch
-        shr     prob2, kNumMoveBits
-        add     probBranch, prob2
-        PSTORE  probBranch, probOffset * 1 + probsArray + probDisp * PMULT
-endm
-UPDATE_1 macro probsArray:req, probOffset:req, probDisp:req
-        sub     prob2, range
-        sub     cod, range
-        mov     range, prob2
-        mov     prob2, probBranch
-        shr     probBranch, kNumMoveBits
-        sub     prob2, probBranch
-        PSTORE  prob2, probOffset * 1 + probsArray + probDisp * PMULT
-endm
-CMP_COD macro probsArray:req, probOffset:req, probDisp:req
-        PLOAD   probBranch, probOffset * 1 + probsArray + probDisp * PMULT
-        NORM
-        mov     prob2, range
-        shr     range, kNumBitModelTotalBits
-        imul    range, probBranch
-        cmp     cod, range
-endm
-IF_BIT_1_NOUP macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
-        CMP_COD probsArray, probOffset, probDisp
-        jae     toLabel
-endm
-IF_BIT_1 macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
-        IF_BIT_1_NOUP probsArray, probOffset, probDisp, toLabel
-        UPDATE_0 probsArray, probOffset, probDisp
-endm
-IF_BIT_0_NOUP macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
-        CMP_COD probsArray, probOffset, probDisp
-        jb      toLabel
-endm
-; ---------- CMOV MACROS ----------
-NORM_CALC macro prob:req
-        NORM
-        mov     t0, range
-        shr     range, kNumBitModelTotalBits
-        imul    range, prob
-        sub     t0, range
-        mov     t1, cod
-        sub     cod, range
-endm
-PUP macro prob:req, probPtr:req
-        sub     t0, prob
-       ; only sar works for both 16/32 bit prob modes
-        sar     t0, kNumMoveBits
-        add     t0, prob
-        PSTORE  t0, probPtr
-endm
-PUP_SUB macro prob:req, probPtr:req, symSub:req
-        sbb     sym, symSub
-        PUP prob, probPtr
-endm
-PUP_COD macro prob:req, probPtr:req, symSub:req
-        mov     t0, kBitModelOffset
-        cmovb   cod, t1
-        mov     t1, sym
-        cmovb   t0, kBitModelTotal_reg
-        PUP_SUB prob, probPtr, symSub
-endm
-BIT_0 macro prob:req, probNext:req
-        PLOAD   prob, probs + 1 * PMULT
-        PLOAD   probNext, probs + 1 * PMULT_2
-        NORM_CALC prob
-        cmovae  range, t0
-        PLOAD   t0, probs + 1 * PMULT_2 + PMULT
-        cmovae  probNext, t0
-        mov     t0, kBitModelOffset
-        cmovb   cod, t1
-        cmovb   t0, kBitModelTotal_reg
-        mov     sym, 2
-        PUP_SUB prob, probs + 1 * PMULT, 0 - 1
-endm
-BIT_1 macro prob:req, probNext:req
-        PLOAD   probNext, probs + sym_R * PMULT_2
-        add     sym, sym
-        NORM_CALC prob
-        cmovae  range, t0
-        PLOAD   t0, probs + sym_R * PMULT + PMULT
-        cmovae  probNext, t0
-        PUP_COD prob, probs + t1_R * PMULT_HALF, 0 - 1
-endm
-BIT_2 macro prob:req, symSub:req
-        add     sym, sym
-        NORM_CALC prob
-        cmovae  range, t0
-        PUP_COD prob, probs + t1_R * PMULT_HALF, symSub
-endm
-; ---------- MATCHED LITERAL ----------
-LITM_0 macro
-        mov     offs, 256 * PMULT
-        shl     match, (PSHIFT + 1)
-        mov     bit, offs
-        and     bit, match
-        PLOAD   x1, probs + 256 * PMULT + bit_R * 1 + 1 * PMULT
-        lea     prm, [probs + 256 * PMULT + bit_R * 1 + 1 * PMULT]
-        ; lea     prm, [probs + 256 * PMULT + 1 * PMULT]
-        ; add     prm, bit_R
-        xor     offs, bit
-        add     match, match
-        NORM_CALC x1
-        cmovae  offs, bit
-        mov     bit, match
-        cmovae  range, t0
-        mov     t0, kBitModelOffset
-        cmovb   cod, t1
-        cmovb   t0, kBitModelTotal_reg
-        mov     sym, 0
-        PUP_SUB x1, prm, -2-1
-endm
-LITM macro
-        and     bit, offs
-        lea     prm, [probs + offs_R * 1]
-        add     prm, bit_R
-        PLOAD   x1, prm + sym_R * PMULT
-        xor     offs, bit
-        add     sym, sym
-        add     match, match
-        NORM_CALC x1
-        cmovae  offs, bit
-        mov     bit, match
-        cmovae  range, t0
-        PUP_COD x1, prm + t1_R * PMULT_HALF, - 1
-endm
-LITM_2 macro
-        and     bit, offs
-        lea     prm, [probs + offs_R * 1]
-        add     prm, bit_R
-        PLOAD   x1, prm + sym_R * PMULT
-        add     sym, sym
-        NORM_CALC x1
-        cmovae  range, t0
-        PUP_COD x1, prm + t1_R * PMULT_HALF, 256 - 1
-endm
-; ---------- REVERSE BITS ----------
-REV_0 macro prob:req, probNext:req
-        ; PLOAD   prob, probs + 1 * PMULT
-        ; lea     sym2_R, [probs + 2 * PMULT]
-        ; PLOAD   probNext, probs + 2 * PMULT
-        PLOAD   probNext, sym2_R
-        NORM_CALC prob
-        cmovae  range, t0
-        PLOAD   t0, probs + 3 * PMULT
-        cmovae  probNext, t0
-        cmovb   cod, t1
-        mov     t0, kBitModelOffset
-        cmovb   t0, kBitModelTotal_reg
-        lea     t1_R, [probs + 3 * PMULT]
-        cmovae  sym2_R, t1_R
-        PUP prob, probs + 1 * PMULT
-endm
-REV_1 macro prob:req, probNext:req, step:req
-        add     sym2_R, step * PMULT
-        PLOAD   probNext, sym2_R
-        NORM_CALC prob
-        cmovae  range, t0
-        PLOAD   t0, sym2_R + step * PMULT
-        cmovae  probNext, t0
-        cmovb   cod, t1
-        mov     t0, kBitModelOffset
-        cmovb   t0, kBitModelTotal_reg
-        lea     t1_R, [sym2_R + step * PMULT]
-        cmovae  sym2_R, t1_R
-        PUP prob, t1_R - step * PMULT_2
-endm
-REV_2 macro prob:req, step:req
-        sub     sym2_R, probs
-        shr     sym2, PSHIFT
-        or      sym, sym2
-        NORM_CALC prob
-        cmovae  range, t0
-        lea     t0, [sym - step]
-        cmovb   sym, t0
-        cmovb   cod, t1
-        mov     t0, kBitModelOffset
-        cmovb   t0, kBitModelTotal_reg
-        PUP prob, probs + sym2_R * PMULT
-endm
-REV_1_VAR macro prob:req
-        PLOAD   prob, sym_R
-        mov     probs, sym_R
-        add     sym_R, sym2_R
-        NORM_CALC prob
-        cmovae  range, t0
-        lea     t0_R, [sym_R + sym2_R]
-        cmovae  sym_R, t0_R
-        mov     t0, kBitModelOffset
-        cmovb   cod, t1
-        ; mov     t1, kBitModelTotal
-        ; cmovb   t0, t1
-        cmovb   t0, kBitModelTotal_reg
-        add     sym2, sym2
-        PUP prob, probs
-endm
-LIT_PROBS macro lpMaskParam:req
-        ; prob += (UInt32)3 * ((((processedPos << 8) + dic[(dicPos == 0 ? dicBufSize : dicPos) - 1]) & lpMask) << lc);
-        mov     t0, processedPos
-        shl     t0, 8
-        add     sym, t0
-        and     sym, lpMaskParam
-        add     probs_state_R, pbPos_R
-        mov     x1, LOC lc2
-        lea     sym, dword ptr[sym_R + 2 * sym_R]
-        add     probs, Literal * PMULT
-        shl     sym, x1_L
-        add     probs, sym_R
-        UPDATE_0 probs_state_R, 0, IsMatch
-        inc     processedPos
-endm
-kNumPosBitsMax          equ 4
-kNumPosStatesMax        equ (1 SHL kNumPosBitsMax)
-kLenNumLowBits          equ 3
-kLenNumLowSymbols       equ (1 SHL kLenNumLowBits)
-kLenNumHighBits         equ 8
-kLenNumHighSymbols      equ (1 SHL kLenNumHighBits)
-kNumLenProbs            equ (2 * kLenNumLowSymbols * kNumPosStatesMax + kLenNumHighSymbols)
-LenLow                  equ 0
-LenChoice               equ LenLow
-LenChoice2              equ (LenLow + kLenNumLowSymbols)
-LenHigh                 equ (LenLow + 2 * kLenNumLowSymbols * kNumPosStatesMax)
-kNumStates              equ 12
-kNumStates2             equ 16
-kNumLitStates           equ 7
-kStartPosModelIndex     equ 4
-kEndPosModelIndex       equ 14
-kNumFullDistances       equ (1 SHL (kEndPosModelIndex SHR 1))
-kNumPosSlotBits         equ 6
-kNumLenToPosStates      equ 4
-kNumAlignBits           equ 4
-kAlignTableSize         equ (1 SHL kNumAlignBits)
-kMatchMinLen            equ 2
-kMatchSpecLenStart      equ (kMatchMinLen + kLenNumLowSymbols * 2 + kLenNumHighSymbols)
-kStartOffset    equ 1664
-SpecPos         equ (-kStartOffset)
-IsRep0Long      equ (SpecPos + kNumFullDistances)
-RepLenCoder     equ (IsRep0Long + (kNumStates2 SHL kNumPosBitsMax))
-LenCoder        equ (RepLenCoder + kNumLenProbs)
-IsMatch         equ (LenCoder + kNumLenProbs)
-kAlign          equ (IsMatch + (kNumStates2 SHL kNumPosBitsMax))
-IsRep           equ (kAlign + kAlignTableSize)
-IsRepG0         equ (IsRep + kNumStates)
-IsRepG1         equ (IsRepG0 + kNumStates)
-IsRepG2         equ (IsRepG1 + kNumStates)
-PosSlot         equ (IsRepG2 + kNumStates)
-Literal         equ (PosSlot + (kNumLenToPosStates SHL kNumPosSlotBits))
-NUM_BASE_PROBS  equ (Literal + kStartOffset)
-if kAlign ne 0
-  .err <Stop_Compiling_Bad_LZMA_kAlign>
-endif
-if NUM_BASE_PROBS ne 1984
-  .err <Stop_Compiling_Bad_LZMA_PROBS>
-endif
-PTR_FIELD equ dq ?
-CLzmaDec_Asm struct
-        lc      db ?
-        lp      db ?
-        pb      db ?
-        _pad_   db ?
-        dicSize dd ?
-        probs_Spec      PTR_FIELD
-        probs_1664      PTR_FIELD
-        dic_Spec        PTR_FIELD
-        dicBufSize      PTR_FIELD
-        dicPos_Spec     PTR_FIELD
-        buf_Spec        PTR_FIELD
-        range_Spec      dd ?
-        code_Spec       dd ?
-        processedPos_Spec  dd ?
-        checkDicSize    dd ?
-        rep0    dd ?
-        rep1    dd ?
-        rep2    dd ?
-        rep3    dd ?
-        state_Spec      dd ?
-        remainLen dd ?
-CLzmaDec_Asm ends
-CLzmaDec_Asm_Loc struct
-        OLD_RSP    PTR_FIELD
-        lzmaPtr    PTR_FIELD
-        _pad0_     PTR_FIELD
-        _pad1_     PTR_FIELD
-        _pad2_     PTR_FIELD
-        dicBufSize PTR_FIELD
-        probs_Spec PTR_FIELD
-        dic_Spec   PTR_FIELD
-        limit      PTR_FIELD
-        bufLimit   PTR_FIELD
-        lc2       dd ?
-        lpMask    dd ?
-        pbMask    dd ?
-        checkDicSize   dd ?
-        _pad_     dd ?
-        remainLen dd ?
-        dicPos_Spec     PTR_FIELD
-        rep0      dd ?
-        rep1      dd ?
-        rep2      dd ?
-        rep3      dd ?
-CLzmaDec_Asm_Loc ends
-GLOB_2  equ [sym_R].CLzmaDec_Asm.
-GLOB    equ [r1].CLzmaDec_Asm.
-LOC_0   equ [r0].CLzmaDec_Asm_Loc.
-LOC     equ [RSP].CLzmaDec_Asm_Loc.
-COPY_VAR macro name
-        mov     t0, GLOB_2 name
-        mov     LOC_0 name, t0
-endm
-RESTORE_VAR macro name
-        mov     t0, LOC name
-        mov     GLOB name, t0
-endm
-IsMatchBranch_Pre macro reg
-        ; prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
-        mov     pbPos, LOC pbMask
-        and     pbPos, processedPos
-        shl     pbPos, (kLenNumLowBits + 1 + PSHIFT)
-        lea     probs_state_R, [probs + state_R]
-endm
-IsMatchBranch macro reg
-        IsMatchBranch_Pre
-        IF_BIT_1 probs_state_R, pbPos_R, IsMatch, IsMatch_label
-endm
-CheckLimits macro reg
-        cmp     buf, LOC bufLimit
-        jae     fin_OK
-        cmp     dicPos, LOC limit
-        jae     fin_OK
-endm
-; RSP is (16x + 8) bytes aligned in WIN64-x64
-; LocalSize equ ((((SIZEOF CLzmaDec_Asm_Loc) + 7) / 16 * 16) + 8)
-PARAM_lzma      equ REG_PARAM_0
-PARAM_limit     equ REG_PARAM_1
-PARAM_bufLimit  equ REG_PARAM_2
-; MY_ALIGN_64
-MY_PROC LzmaDec_DecodeReal_3, 3
-MY_PUSH_PRESERVED_REGS
-        lea     r0, [RSP - (SIZEOF CLzmaDec_Asm_Loc)]
-        and     r0, -128
-        mov     r5, RSP
-        mov     RSP, r0
-        mov     LOC_0 Old_RSP, r5
-        mov     LOC_0 lzmaPtr, PARAM_lzma
-        mov     LOC_0 remainLen, 0  ; remainLen must be ZERO
-        mov     LOC_0 bufLimit, PARAM_bufLimit
-        mov     sym_R, PARAM_lzma  ;  CLzmaDec_Asm_Loc pointer for GLOB_2
-        mov     dic, GLOB_2 dic_Spec
-        add     PARAM_limit, dic
-        mov     LOC_0 limit, PARAM_limit
-        COPY_VAR(rep0)
-        COPY_VAR(rep1)
-        COPY_VAR(rep2)
-        COPY_VAR(rep3)
-        mov     dicPos, GLOB_2 dicPos_Spec
-        add     dicPos, dic
-        mov     LOC_0 dicPos_Spec, dicPos
-        mov     LOC_0 dic_Spec, dic
-        mov     x1_L, GLOB_2 pb
-        mov     t0, 1
-        shl     t0, x1_L
-        dec     t0
-        mov     LOC_0 pbMask, t0
-        ; unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
-        ; unsigned lc = p->prop.lc;
-        ; unsigned lpMask = ((unsigned)0x100 << p->prop.lp) - ((unsigned)0x100 >> lc);
-        mov     x1_L, GLOB_2 lc
-        mov     x2, 100h
-        mov     t0, x2
-        shr     x2, x1_L
-        ; inc     x1
-        add     x1_L, PSHIFT
-        mov     LOC_0 lc2, x1
-        mov     x1_L, GLOB_2 lp
-        shl     t0, x1_L
-        sub     t0, x2
-        mov     LOC_0 lpMask, t0
-        mov     lpMask_reg, t0
-        ; mov     probs, GLOB_2 probs_Spec
-        ; add     probs, kStartOffset SHL PSHIFT
-        mov     probs, GLOB_2 probs_1664
-        mov     LOC_0 probs_Spec, probs
-        mov     t0_R, GLOB_2 dicBufSize
-        mov     LOC_0 dicBufSize, t0_R
-        mov     x1, GLOB_2 checkDicSize
-        mov     LOC_0 checkDicSize, x1
-        mov     processedPos, GLOB_2 processedPos_Spec
-        mov     state, GLOB_2 state_Spec
-        shl     state, PSHIFT
-        mov     buf,   GLOB_2 buf_Spec
-        mov     range, GLOB_2 range_Spec
-        mov     cod,   GLOB_2 code_Spec
-        mov     kBitModelTotal_reg, kBitModelTotal
-        xor     sym, sym
-        ; if (processedPos != 0 || checkDicSize != 0)
-        or      x1, processedPos
-        jz      @f
-        add     t0_R, dic
-        cmp     dicPos, dic
-        cmovnz  t0_R, dicPos
-        movzx   sym, byte ptr[t0_R - 1]
-@@:
-        IsMatchBranch_Pre
-        cmp     state, 4 * PMULT
-        jb      lit_end
-        cmp     state, kNumLitStates * PMULT
-        jb      lit_matched_end
-        jmp     lz_end
-; ---------- LITERAL ----------
-MY_ALIGN_64
-lit_start:
-        xor     state, state
-lit_start_2:
-        LIT_PROBS lpMask_reg
-    ifdef _LZMA_SIZE_OPT
-        PLOAD   x1, probs + 1 * PMULT
-        mov     sym, 1
-MY_ALIGN_16
-lit_loop:
-        BIT_1   x1, x2
-        mov     x1, x2
-        cmp     sym, 127
-        jbe     lit_loop
-    else
-        BIT_0   x1, x2
-        BIT_1   x2, x1
-        BIT_1   x1, x2
-        BIT_1   x2, x1
-        BIT_1   x1, x2
-        BIT_1   x2, x1
-        BIT_1   x1, x2
-    endif
-        BIT_2   x2, 256 - 1
-        ; mov     dic, LOC dic_Spec
-        mov     probs, LOC probs_Spec
-        IsMatchBranch_Pre
-        mov     byte ptr[dicPos], sym_L
-        inc     dicPos
-        CheckLimits
-lit_end:
-        IF_BIT_0_NOUP probs_state_R, pbPos_R, IsMatch, lit_start
-        ; jmp     IsMatch_label
-; ---------- MATCHES ----------
-; MY_ALIGN_32
-IsMatch_label:
-        UPDATE_1 probs_state_R, pbPos_R, IsMatch
-        IF_BIT_1 probs_state_R, 0, IsRep, IsRep_label
-        add     probs, LenCoder * PMULT
-        add     state, kNumStates * PMULT
-; ---------- LEN DECODE ----------
-len_decode:
-        mov     len_temp, 8 - 1 - kMatchMinLen
-        IF_BIT_0_NOUP probs, 0, 0, len_mid_0
-        UPDATE_1 probs, 0, 0
-        add     probs, (1 SHL (kLenNumLowBits + PSHIFT))
-        mov     len_temp, -1 - kMatchMinLen
-        IF_BIT_0_NOUP probs, 0, 0, len_mid_0
-        UPDATE_1 probs, 0, 0
-        add     probs, LenHigh * PMULT - (1 SHL (kLenNumLowBits + PSHIFT))
-        mov     sym, 1
-        PLOAD   x1, probs + 1 * PMULT
-MY_ALIGN_32
-len8_loop:
-        BIT_1   x1, x2
-        mov     x1, x2
-        cmp     sym, 64
-        jb      len8_loop
-        mov     len_temp, (kLenNumHighSymbols - kLenNumLowSymbols * 2) - 1 - kMatchMinLen
-        jmp     len_mid_2
-MY_ALIGN_32
-len_mid_0:
-        UPDATE_0 probs, 0, 0
-        add     probs, pbPos_R
-        BIT_0   x2, x1
-len_mid_2:
-        BIT_1   x1, x2
-        BIT_2   x2, len_temp
-        mov     probs, LOC probs_Spec
-        cmp     state, kNumStates * PMULT
-        jb      copy_match
-; ---------- DECODE DISTANCE ----------
-        ; probs + PosSlot + ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
-        mov     t0, 3 + kMatchMinLen
-        cmp     sym, 3 + kMatchMinLen
-        cmovb   t0, sym
-        add     probs, PosSlot * PMULT - (kMatchMinLen SHL (kNumPosSlotBits + PSHIFT))
-        shl     t0, (kNumPosSlotBits + PSHIFT)
-        add     probs, t0_R
-        ; sym = Len
-        ; mov     LOC remainLen, sym
-        mov     len_temp, sym
-    ifdef _LZMA_SIZE_OPT
-        PLOAD   x1, probs + 1 * PMULT
-        mov     sym, 1
-MY_ALIGN_16
-slot_loop:
-        BIT_1   x1, x2
-        mov     x1, x2
-        cmp     sym, 32
-        jb      slot_loop
-    else
-        BIT_0   x1, x2
-        BIT_1   x2, x1
-        BIT_1   x1, x2
-        BIT_1   x2, x1
-        BIT_1   x1, x2
-    endif
-        mov     x1, sym
-        BIT_2   x2, 64-1
-        and     sym, 3
-        mov     probs, LOC probs_Spec
-        cmp     x1, 32 + kEndPosModelIndex / 2
-        jb      short_dist
-        ;  unsigned numDirectBits = (unsigned)(((distance >> 1) - 1));
-        sub     x1, (32 + 1 + kNumAlignBits)
-        ;  distance = (2 | (distance & 1));
-        or      sym, 2
-        PLOAD   x2, probs + 1 * PMULT
-        shl     sym, kNumAlignBits + 1
-        lea     sym2_R, [probs + 2 * PMULT]
-        jmp     direct_norm
-        ; lea     t1, [sym_R + (1 SHL kNumAlignBits)]
-        ; cmp     range, kTopValue
-        ; jb      direct_norm
-; ---------- DIRECT DISTANCE ----------
-MY_ALIGN_32
-direct_loop:
-        shr     range, 1
-        mov     t0, cod
-        sub     cod, range
-        cmovs   cod, t0
-        cmovns  sym, t1
-        comment ~
-        sub     cod, range
-        mov     x2, cod
-        sar     x2, 31
-        lea     sym, dword ptr [r2 + sym_R * 2 + 1]
-        and     x2, range
-        add     cod, x2
-        ~
-        dec     x1
-        je      direct_end
-        add     sym, sym
-direct_norm:
-        lea     t1, [sym_R + (1 SHL kNumAlignBits)]
-        cmp     range, kTopValue
-        jae     near ptr direct_loop
-        ; we align for 32 here with "near ptr" command above
-        NORM_2
-        jmp     direct_loop
-MY_ALIGN_32
-direct_end:
-        ;  prob =  + kAlign;
-        ;  distance <<= kNumAlignBits;
-        REV_0   x2, x1
-        REV_1   x1, x2, 2
-        REV_1   x2, x1, 4
-        REV_2   x1, 8
-decode_dist_end:
-        ; if (distance >= (checkDicSize == 0 ? processedPos: checkDicSize))
-        mov     t0, LOC checkDicSize
-        test    t0, t0
-        cmove   t0, processedPos
-        cmp     sym, t0
-        jae     end_of_payload
-        ; rep3 = rep2;
-        ; rep2 = rep1;
-        ; rep1 = rep0;
-        ; rep0 = distance + 1;
-        inc     sym
-        mov     t0, LOC rep0
-        mov     t1, LOC rep1
-        mov     x1, LOC rep2
-        mov     LOC rep0, sym
-        ; mov     sym, LOC remainLen
-        mov     sym, len_temp
-        mov     LOC rep1, t0
-        mov     LOC rep2, t1
-        mov     LOC rep3, x1
-        ; state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
-        cmp     state, (kNumStates + kNumLitStates) * PMULT
-        mov     state, kNumLitStates * PMULT
-        mov     t0, (kNumLitStates + 3) * PMULT
-        cmovae  state, t0
-; ---------- COPY MATCH ----------
-copy_match:
-        ; len += kMatchMinLen;
-        ; add     sym, kMatchMinLen
-        ; if ((rem = limit - dicPos) == 0)
-        ; {
-        ;   p->dicPos = dicPos;
-        ;   return SZ_ERROR_DATA;
-        ; }
-        mov     cnt_R, LOC limit
-        sub     cnt_R, dicPos
-        jz      fin_ERROR
-        ; curLen = ((rem < len) ? (unsigned)rem : len);
-        cmp     cnt_R, sym_R
-        ; cmovae  cnt_R, sym_R ; 64-bit
-        cmovae  cnt, sym ; 32-bit
-        mov     dic, LOC dic_Spec
-        mov     x1, LOC rep0
-        mov     t0_R, dicPos
-        add     dicPos, cnt_R
-        ; processedPos += curLen;
-        add     processedPos, cnt
-        ; len -= curLen;
-        sub     sym, cnt
-        mov     LOC remainLen, sym
-        sub     t0_R, dic
-        ; pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0);
-        sub     t0_R, r1
-        jae     @f
-        mov     r1, LOC dicBufSize
-        add     t0_R, r1
-        sub     r1, t0_R
-        cmp     cnt_R, r1
-        ja      copy_match_cross
-@@:
-        ; if (curLen <= dicBufSize - pos)
-; ---------- COPY MATCH FAST ----------
-        ; Byte *dest = dic + dicPos;
-        ; mov     r1, dic
-        ; ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;
-        ; sub   t0_R, dicPos
-        ; dicPos += curLen;
-        ; const Byte *lim = dest + curLen;
-        add     t0_R, dic
-        movzx   sym, byte ptr[t0_R]
-        add     t0_R, cnt_R
-        neg     cnt_R
-        ; lea     r1, [dicPos - 1]
-copy_common:
-        dec     dicPos
-        ; cmp   LOC rep0, 1
-        ; je    rep0Label
-        ; t0_R - src_lim
-        ; r1 - dest_lim - 1
-        ; cnt_R - (-cnt)
-        IsMatchBranch_Pre
-        inc     cnt_R
-        jz      copy_end
-MY_ALIGN_16
-@@:
-        mov     byte ptr[cnt_R * 1 + dicPos], sym_L
-        movzx   sym, byte ptr[cnt_R * 1 + t0_R]
-        inc     cnt_R
-        jnz     @b
-copy_end:
-lz_end_match:
-        mov     byte ptr[dicPos], sym_L
-        inc     dicPos
-        ; IsMatchBranch_Pre
-        CheckLimits
-lz_end:
-        IF_BIT_1_NOUP probs_state_R, pbPos_R, IsMatch, IsMatch_label
-; ---------- LITERAL MATCHED ----------
-        LIT_PROBS LOC lpMask
-        ; matchByte = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
-        mov     x1, LOC rep0
-        ; mov     dic, LOC dic_Spec
-        mov     LOC dicPos_Spec, dicPos
-        ; state -= (state < 10) ? 3 : 6;
-        lea     t0, [state_R - 6 * PMULT]
-        sub     state, 3 * PMULT
-        cmp     state, 7 * PMULT
-        cmovae  state, t0
-        sub     dicPos, dic
-        sub     dicPos, r1
-        jae     @f
-        add     dicPos, LOC dicBufSize
-@@:
-        comment ~
-        xor     t0, t0
-        sub     dicPos, r1
-        cmovb   t0_R, LOC dicBufSize
-        ~
-        movzx   match, byte ptr[dic + dicPos * 1]
-    ifdef _LZMA_SIZE_OPT
-        mov     offs, 256 * PMULT
-        shl     match, (PSHIFT + 1)
-        mov     bit, match
-        mov     sym, 1
-MY_ALIGN_16
-litm_loop:
-        LITM
-        cmp     sym, 256
-        jb      litm_loop
-        sub     sym, 256
-    else
-        LITM_0
-        LITM
-        LITM
-        LITM
-        LITM
-        LITM
-        LITM
-        LITM_2
-    endif
-        mov     probs, LOC probs_Spec
-        IsMatchBranch_Pre
-        ; mov     dic, LOC dic_Spec
-        mov     dicPos, LOC dicPos_Spec
-        mov     byte ptr[dicPos], sym_L
-        inc     dicPos
-        CheckLimits
-lit_matched_end:
-        IF_BIT_1_NOUP probs_state_R, pbPos_R, IsMatch, IsMatch_label
-        ; IsMatchBranch
-        mov     lpMask_reg, LOC lpMask
-        sub     state, 3 * PMULT
-        jmp     lit_start_2
-; ---------- REP 0 LITERAL ----------
-MY_ALIGN_32
-IsRep0Short_label:
-        UPDATE_0 probs_state_R, pbPos_R, IsRep0Long
-        ; dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
-        mov     dic, LOC dic_Spec
-        mov     t0_R, dicPos
-        mov     probBranch, LOC rep0
-        sub     t0_R, dic
-        sub     probs, RepLenCoder * PMULT
-        inc     processedPos
-        ; state = state < kNumLitStates ? 9 : 11;
-        or      state, 1 * PMULT
-        IsMatchBranch_Pre
-        sub     t0_R, probBranch_R
-        jae     @f
-        add     t0_R, LOC dicBufSize
-@@:
-        movzx   sym, byte ptr[dic + t0_R * 1]
-        jmp     lz_end_match
-MY_ALIGN_32
-IsRep_label:
-        UPDATE_1 probs_state_R, 0, IsRep
-        ; The (checkDicSize == 0 && processedPos == 0) case was checked before in LzmaDec.c with kBadRepCode.
-        ; So we don't check it here.
-        ; mov     t0, processedPos
-        ; or      t0, LOC checkDicSize
-        ; jz      fin_ERROR_2
-        ; state = state < kNumLitStates ? 8 : 11;
-        cmp     state, kNumLitStates * PMULT
-        mov     state, 8 * PMULT
-        mov     probBranch, 11 * PMULT
-        cmovae  state, probBranch
-        ; prob = probs + RepLenCoder;
-        add     probs, RepLenCoder * PMULT
-        IF_BIT_1 probs_state_R, 0, IsRepG0, IsRepG0_label
-        IF_BIT_0_NOUP probs_state_R, pbPos_R, IsRep0Long, IsRep0Short_label
-        UPDATE_1 probs_state_R, pbPos_R, IsRep0Long
-        jmp     len_decode
-MY_ALIGN_32
-IsRepG0_label:
-        UPDATE_1 probs_state_R, 0, IsRepG0
-        mov     dist2, LOC rep0
-        mov     dist, LOC rep1
-        mov     LOC rep1, dist2
-        IF_BIT_1 probs_state_R, 0, IsRepG1, IsRepG1_label
-        mov     LOC rep0, dist
-        jmp     len_decode
-; MY_ALIGN_32
-IsRepG1_label:
-        UPDATE_1 probs_state_R, 0, IsRepG1
-        mov     dist2, LOC rep2
-        mov     LOC rep2, dist
-        IF_BIT_1 probs_state_R, 0, IsRepG2, IsRepG2_label
-        mov     LOC rep0, dist2
-        jmp     len_decode
-; MY_ALIGN_32
-IsRepG2_label:
-        UPDATE_1 probs_state_R, 0, IsRepG2
-        mov     dist, LOC rep3
-        mov     LOC rep3, dist2
-        mov     LOC rep0, dist
-        jmp     len_decode
-; ---------- SPEC SHORT DISTANCE ----------
-MY_ALIGN_32
-short_dist:
-        sub     x1, 32 + 1
-        jbe     decode_dist_end
-        or      sym, 2
-        shl     sym, x1_L
-        lea     sym_R, [probs + sym_R * PMULT + SpecPos * PMULT + 1 * PMULT]
-        mov     sym2, PMULT ; step
-MY_ALIGN_32
-spec_loop:
-        REV_1_VAR x2
-        dec     x1
-        jnz     spec_loop
-        mov     probs, LOC probs_Spec
-        sub     sym, sym2
-        sub     sym, SpecPos * PMULT
-        sub     sym_R, probs
-        shr     sym, PSHIFT
-        jmp     decode_dist_end
-; ---------- COPY MATCH CROSS ----------
-copy_match_cross:
-        ; t0_R - src pos
-        ; r1 - len to dicBufSize
-        ; cnt_R - total copy len
-        mov     t1_R, t0_R         ; srcPos
-        mov     t0_R, dic
-        mov     r1, LOC dicBufSize   ;
-        neg     cnt_R
-@@:
-        movzx   sym, byte ptr[t1_R * 1 + t0_R]
-        inc     t1_R
-        mov     byte ptr[cnt_R * 1 + dicPos], sym_L
-        inc     cnt_R
-        cmp     t1_R, r1
-        jne     @b
-        movzx   sym, byte ptr[t0_R]
-        sub     t0_R, cnt_R
-        jmp     copy_common
-fin_ERROR:
-        mov     LOC remainLen, len_temp
-; fin_ERROR_2:
-        mov     sym, 1
-        jmp     fin
-end_of_payload:
-        cmp     sym, 0FFFFFFFFh ; -1
-        jne     fin_ERROR
-        mov     LOC remainLen, kMatchSpecLenStart
-        sub     state, kNumStates * PMULT
-fin_OK:
-        xor     sym, sym
-fin:
-        NORM
-        mov     r1, LOC lzmaPtr
-        sub     dicPos, LOC dic_Spec
-        mov     GLOB dicPos_Spec, dicPos
-        mov     GLOB buf_Spec, buf
-        mov     GLOB range_Spec, range
-        mov     GLOB code_Spec, cod
-        shr     state, PSHIFT
-        mov     GLOB state_Spec, state
-        mov     GLOB processedPos_Spec, processedPos
-        RESTORE_VAR(remainLen)
-        RESTORE_VAR(rep0)
-        RESTORE_VAR(rep1)
-        RESTORE_VAR(rep2)
-        RESTORE_VAR(rep3)
-        mov     x0, sym
-        mov     RSP, LOC Old_RSP
-MY_POP_PRESERVED_REGS
-MY_ENDP
-_TEXT$LZMADECOPT ENDS
-end