223 files changed, 11244 insertions, 4282 deletions

diff --git a/Asm/x86/Sort.asm b/Asm/x86/Sort.asm
new file mode 100644
index 0000000..517c615
--- /dev/null
+++ b/Asm/x86/Sort.asm
@@ -0,0 +1,860 @@
+; SortTest.asm -- ASM version of HeapSort() function
+; Igor Pavlov : Public domain
+
+include ../../../../Asm/x86/7zAsm.asm
+
+MY_ASM_START
+
+ifndef Z7_SORT_ASM_USE_SEGMENT
+if (IS_LINUX gt 0)
+  ; Z7_SORT_ASM_USE_SEGMENT equ 1
+else
+  ; Z7_SORT_ASM_USE_SEGMENT equ 1
+endif
+endif
+
+ifdef Z7_SORT_ASM_USE_SEGMENT
+_TEXT$Z7_SORT SEGMENT ALIGN(64) 'CODE'
+MY_ALIGN macro num:req
+        align  num
+endm
+else
+MY_ALIGN macro num:req
+        ; We expect that ".text" is aligned for 16-bytes.
+        ; So we don't need large alignment inside our function.
+        align  16
+endm
+endif
+
+
+MY_ALIGN_16 macro
+        MY_ALIGN 16
+endm
+
+MY_ALIGN_32 macro
+        MY_ALIGN 32
+endm
+
+MY_ALIGN_64 macro
+        MY_ALIGN 64
+endm
+
+ifdef x64
+
+NUM_PREFETCH_LEVELS     equ 3 ; to prefetch 1x 64-bytes line (is good for most cases)
+; NUM_PREFETCH_LEVELS     equ 4 ; to prefetch 2x 64-bytes lines (better for big arrays)
+
+acc           equ x0
+k             equ r0
+k_x           equ x0
+
+p             equ r1
+
+s             equ r2
+s_x           equ x2
+
+a0            equ x3
+t0            equ a0
+
+a3            equ x5
+qq            equ a3
+
+a1            equ x6
+t1            equ a1
+t1_r          equ r6
+
+a2            equ x7
+t2            equ a2
+
+i             equ r8
+e0            equ x8
+
+e1            equ x9
+
+num_last      equ r10
+num_last_x    equ x10
+
+next4_lim     equ r11
+pref_lim      equ r12
+
+
+
+SORT_2_WITH_TEMP_REG macro b0, b1, temp_reg
+        mov     temp_reg, b0
+        cmp     b0, b1
+        cmovae  b0, b1 ; min
+        cmovae  b1, temp_reg ; max
+endm
+
+SORT macro b0, b1
+        SORT_2_WITH_TEMP_REG b0, b1, acc
+endm
+
+LOAD macro dest:req, index:req
+        mov     dest, [p + 4 * index]
+endm
+
+STORE macro reg:req, index:req
+        mov     [p + 4 * index], reg
+endm
+
+
+if (NUM_PREFETCH_LEVELS gt 3)
+   num_prefetches equ (1 SHL (NUM_PREFETCH_LEVELS - 3))
+else
+   num_prefetches equ 1
+endif
+
+PREFETCH_OP macro offs
+  cur_offset = 7 * 4    ; it's average offset in 64-bytes cache line.
+  ; cur_offset = 0      ; we can use zero offset, if we are sure that array is aligned for 64-bytes.
+  rept num_prefetches
+    if 1
+        prefetcht0 byte ptr [p + offs + cur_offset]
+    else
+        mov     pref_x, dword ptr [p + offs + cur_offset]
+    endif
+        cur_offset = cur_offset + 64
+  endm
+endm
+
+PREFETCH_MY macro
+if 1
+    if 1
+        shl     k, NUM_PREFETCH_LEVELS + 3
+    else
+        ; we delay prefetch instruction to improve main loads
+        shl     k, NUM_PREFETCH_LEVELS
+        shl     k, 3
+        ; shl     k, 0
+    endif
+        PREFETCH_OP k
+elseif 1
+        shl     k, 3
+        PREFETCH_OP k * (1 SHL NUM_PREFETCH_LEVELS) ; change it
+endif
+endm
+
+
+STEP_1 macro exit_label, prefetch_macro
+use_cmov_1 equ 1  ; set 1 for cmov, but it's slower in some cases
+                  ; set 0 for LOAD after adc s, 0
+        cmp     t0, t1
+    if use_cmov_1
+        cmovb   t0, t1
+        ; STORE   t0, k
+    endif
+        adc     s, 0
+    if use_cmov_1 eq 0
+        LOAD    t0, s
+    endif
+        cmp     qq, t0
+        jae     exit_label
+    if 1 ; use_cmov_1 eq 0
+        STORE   t0, k
+    endif
+        prefetch_macro
+        mov     t0, [p + s * 8]
+        mov     t1, [p + s * 8 + 4]
+        mov     k, s
+        add     s, s                 ; slower  for some cpus
+        ; lea     s, dword ptr [s + s] ; slower for some cpus
+        ; shl     s, 1               ; faster for some cpus
+        ; lea     s, dword ptr [s * 2] ; faster for some cpus
+    rept 0 ; 1000 for debug : 0 for normal
+        ; number of calls in generate_stage : ~0.6 of number of items
+        shl     k, 0
+    endm
+endm
+
+
+STEP_2 macro exit_label, prefetch_macro
+use_cmov_2 equ 0  ; set 1 for cmov, but it's slower in some cases
+                  ; set 0 for LOAD after adc s, 0
+        cmp     t0, t1
+    if use_cmov_2
+        mov     t2, t0
+        cmovb   t2, t1
+        ; STORE   t2, k
+    endif
+        mov     t0, [p + s * 8]
+        mov     t1, [p + s * 8 + 4]
+        cmovb   t0, [p + s * 8 + 8]
+        cmovb   t1, [p + s * 8 + 12]
+        adc     s, 0
+    if use_cmov_2 eq 0
+        LOAD    t2, s
+    endif
+        cmp     qq, t2
+        jae     exit_label
+    if 1 ; use_cmov_2 eq 0
+        STORE   t2, k
+    endif
+        prefetch_macro
+        mov     k, s
+        ; add     s, s
+        ; lea     s, [s + s]
+        shl     s, 1
+        ; lea     s, [s * 2]
+endm
+
+
+MOVE_SMALLEST_UP macro STEP, use_prefetch, num_unrolls
+        LOCAL exit_1, exit_2, leaves, opt_loop, last_nodes
+
+        ; s == k * 2
+        ; t0 == (p)[s]
+        ; t1 == (p)[s + 1]
+        cmp     k, next4_lim
+        jae     leaves
+
+    rept num_unrolls
+        STEP    exit_2
+        cmp     k, next4_lim
+        jae     leaves
+    endm
+  
+    if use_prefetch
+        prefetch_macro  equ PREFETCH_MY
+        pref_lim_2      equ pref_lim
+        ; lea     pref_lim, dword ptr [num_last + 1]
+        ; shr     pref_lim, NUM_PREFETCH_LEVELS + 1
+        cmp     k, pref_lim_2
+        jae     last_nodes
+    else
+        prefetch_macro  equ
+        pref_lim_2      equ next4_lim
+    endif
+  
+MY_ALIGN_16
+opt_loop:
+        STEP    exit_2, prefetch_macro
+        cmp     k, pref_lim_2
+        jb      opt_loop
+
+last_nodes:
+        ; k >= pref_lim_2
+        ; 2 cases are possible:
+        ;   case-1: num_after_prefetch_levels == 0 && next4_lim = pref_lim_2
+        ;   case-2: num_after_prefetch_levels == NUM_PREFETCH_LEVELS - 1 &&
+        ;        next4_lim = pref_lim_2 / (NUM_PREFETCH_LEVELS - 1)
+  if use_prefetch
+    yyy = NUM_PREFETCH_LEVELS - 1
+    while yyy
+        yyy = yyy - 1
+        STEP    exit_2
+      if yyy
+        cmp     k, next4_lim
+        jae     leaves
+      endif
+    endm
+  endif
+
+leaves:
+        ; k >= next4_lim == (num_last + 1) / 4 must be provided by previous code.
+        ;   we     have    2 nodes in (s)     level :  always
+        ;   we can have some nodes in (s * 2) level :  low probability case
+        ;   we     have   no nodes in (s * 4) level
+        ; s == k * 2
+        ; t0 == (p)[s]
+        ; t1 == (p)[s + 1]
+        cmp     t0, t1
+        cmovb   t0, t1
+        adc     s, 0
+        STORE   t0, k
+
+        ; t0 == (p)[s]
+        ; s / 2 == k  : (s) is index of max item from (p)[k * 2], (p)[k * 2 + 1]
+        ; we have 3 possible cases here:
+        ;   s * 2 >  num_last : (s) node has no childs
+        ;   s * 2 == num_last : (s) node has 1 leaf child that is last item of array
+        ;   s * 2 <  num_last : (s) node has 2 leaf childs. We provide (s * 4 > num_last)
+        ; we check for (s * 2 > num_last) before "cmp qq, t0" check, because
+        ; we will replace conditional jump with cmov instruction later.
+        lea     t1_r, dword ptr [s + s]
+        cmp     t1_r, num_last
+        ja      exit_1 ; if (s * 2 > num_last), we have no childs : it's high probability branch
+        
+        ; it's low probability branch
+        ; s * 2 <= num_last
+        cmp     qq, t0
+        jae     exit_2
+
+        ; qq < t0, so we go to next level
+        ; we check 1 or 2 childs in next level
+        mov     t0, [p + s * 8]
+        mov     k, s
+        mov     s, t1_r
+        cmp     t1_r, num_last
+        je      @F ; (s == num_last) means that we have single child in tree
+
+        ; (s < num_last) : so we must read both childs and select max of them.
+        mov     t1, [p + k * 8 + 4]
+        cmp     t0, t1
+        cmovb   t0, t1
+        adc     s, 0
+@@:
+        STORE   t0, k
+exit_1:
+        ; t0 == (p)[s],  s / 2 == k  : (s) is index of max item from (p)[k * 2], (p)[k * 2 + 1]
+        cmp     qq, t0
+        cmovb   k, s
+exit_2:
+        STORE   qq, k
+endm
+
+
+
+
+ifdef Z7_SORT_ASM_USE_SEGMENT
+; MY_ALIGN_64
+else
+  MY_ALIGN_16
+endif
+
+MY_PROC HeapSort, 2
+
+if (IS_LINUX gt 0)
+        mov     p, REG_ABI_PARAM_0    ; r1 <- r7 : linux
+endif
+        mov     num_last, REG_ABI_PARAM_1  ; r10 <- r6 : linux
+                                      ; r10 <- r2 : win64
+        cmp     num_last, 2
+        jb      end_1
+        
+        ; MY_PUSH_PRESERVED_ABI_REGS
+        MY_PUSH_PRESERVED_ABI_REGS_UP_TO_INCLUDING_R11
+        push    r12
+        
+        cmp     num_last, 4
+        ja      sort_5
+        
+        LOAD    a0, 0
+        LOAD    a1, 1
+        SORT    a0, a1
+        cmp     num_last, 3
+        jb      end_2
+        
+        LOAD    a2, 2
+        je      sort_3
+        
+        LOAD    a3, 3
+        SORT    a2, a3
+        SORT    a1, a3
+        STORE   a3, 3
+sort_3:
+        SORT    a0, a2
+        SORT    a1, a2
+        STORE   a2, 2
+        jmp     end_2
+        
+sort_5:
+        ; (num_last > 4) is required here
+        ; if (num_last >= 6) : we will use optimized loop for leaf nodes loop_down_1
+        mov     next4_lim, num_last
+        shr     next4_lim, 2
+        
+        dec     num_last
+        mov     k, num_last
+        shr     k, 1
+        mov     i, num_last
+        shr     i, 2
+        test    num_last, 1
+        jnz     size_even
+
+        ; ODD number of items. So we compare parent with single child
+        LOAD    t1, num_last
+        LOAD    t0, k
+        SORT_2_WITH_TEMP_REG  t1, t0, t2
+        STORE   t1, num_last
+        STORE   t0, k
+        dec     k
+
+size_even:
+        cmp     k, i
+        jbe     loop_down ; jump for num_last == 4 case
+
+if 0 ; 1 for debug
+        mov     r15, k
+        mov     r14d, 1 ; 100
+loop_benchmark:
+endif
+        ; optimized loop for leaf nodes:
+        mov     t0, [p + k * 8]
+        mov     t1, [p + k * 8 + 4]
+
+MY_ALIGN_16
+loop_down_1:
+        ; we compare parent with max of childs:
+        ; lea     s, dword ptr [2 * k]
+        mov     s, k
+        cmp     t0, t1
+        cmovb   t0, t1
+        adc     s, s
+        LOAD    t2, k
+        STORE   t0, k
+        cmp     t2, t0
+        cmovae  s, k
+        dec     k
+        ; we preload next items before STORE operation for calculated address
+        mov     t0, [p + k * 8]
+        mov     t1, [p + k * 8 + 4]
+        STORE   t2, s
+        cmp     k, i
+        jne     loop_down_1
+
+if 0 ; 1 for debug
+        mov     k, r15
+        dec     r14d
+        jnz     loop_benchmark
+        ; jmp end_debug
+endif
+       
+MY_ALIGN_16
+loop_down:
+        mov     t0, [p + i * 8]
+        mov     t1, [p + i * 8 + 4]
+        LOAD    qq, i
+        mov     k, i
+        lea     s, dword ptr [i + i]
+        ; jmp end_debug
+    DOWN_use_prefetch  equ 0
+    DOWN_num_unrolls   equ 0
+        MOVE_SMALLEST_UP  STEP_1, DOWN_use_prefetch, DOWN_num_unrolls
+        sub     i, 1
+        jnb     loop_down
+
+        ; jmp end_debug
+        LOAD    e0, 0
+        LOAD    e1, 1
+
+   LEVEL_3_LIMIT equ 8   ; 8 is default, but 7 also can work
+
+        cmp     num_last, LEVEL_3_LIMIT + 1
+        jb      main_loop_sort_5
+
+MY_ALIGN_16
+main_loop_sort:
+        ; num_last > LEVEL_3_LIMIT
+        ; p[size--] = p[0];
+        LOAD    qq, num_last
+        STORE   e0, num_last
+        mov     e0, e1
+        
+        mov     next4_lim, num_last
+        shr     next4_lim, 2
+        mov     pref_lim, num_last
+        shr     pref_lim, NUM_PREFETCH_LEVELS + 1
+        
+        dec     num_last
+if 0    ; 1 for debug
+        ; that optional optimization can improve the performance, if there are identical items in array
+        ;    3 times improvement : if all items in array are identical
+        ;   20%  improvement : if items are different for 1 bit only
+        ; 1-10%  improvement : if items are different for (2+) bits
+        ; no gain : if items are different
+        cmp     qq, e1
+        jae     next_iter_main
+endif
+        LOAD    e1, 2
+        LOAD    t0, 3
+        mov     k_x, 2
+        cmp     e1, t0
+        cmovb   e1, t0
+        mov     t0, [p + 4 * (4 + 0)]
+        mov     t1, [p + 4 * (4 + 1)]
+        cmovb   t0, [p + 4 * (4 + 2)]
+        cmovb   t1, [p + 4 * (4 + 3)]
+        adc     k_x, 0
+        ; (qq <= e1), because the tree is correctly sorted
+        ; also here we could check (qq >= e1) or (qq == e1) for faster exit
+        lea     s, dword ptr [k + k]
+    MAIN_use_prefetch  equ 1
+    MAIN_num_unrolls   equ 0
+        MOVE_SMALLEST_UP  STEP_2, MAIN_use_prefetch, MAIN_num_unrolls
+
+next_iter_main:
+        cmp     num_last, LEVEL_3_LIMIT
+        jne     main_loop_sort
+
+        ; num_last == LEVEL_3_LIMIT
+main_loop_sort_5:
+        ; 4 <= num_last <= LEVEL_3_LIMIT
+        ; p[size--] = p[0];
+        LOAD    qq, num_last
+        STORE   e0, num_last
+        mov     e0, e1
+        dec     num_last_x
+        
+        LOAD    e1, 2
+        LOAD    t0, 3
+        mov     k_x, 2
+        cmp     e1, t0
+        cmovb   e1, t0
+        adc     k_x, 0
+
+        lea     s_x, dword ptr [k * 2]
+        cmp     s_x, num_last_x
+        ja      exit_2
+
+        mov     t0, [p + k * 8]
+        je      exit_1
+
+        ; s < num_last
+        mov     t1, [p + k * 8 + 4]
+        cmp     t0, t1
+        cmovb   t0, t1
+        adc     s_x, 0
+exit_1:
+        STORE   t0, k
+        cmp     qq, t0
+        cmovb   k_x, s_x
+exit_2:
+        STORE   qq, k
+        cmp     num_last_x, 3
+        jne     main_loop_sort_5
+
+        ; num_last == 3 (real_size == 4)
+        LOAD    a0, 2
+        LOAD    a1, 3
+        STORE   e1, 2
+        STORE   e0, 3
+        SORT    a0, a1
+end_2:
+        STORE   a0, 0
+        STORE   a1, 1
+; end_debug:
+        ; MY_POP_PRESERVED_ABI_REGS
+        pop     r12
+        MY_POP_PRESERVED_ABI_REGS_UP_TO_INCLUDING_R11
+end_1:
+MY_ENDP
+
+
+
+else
+; ------------ x86 32-bit ------------
+
+ifdef x64
+IS_CDECL = 0
+endif
+
+acc           equ x0
+k             equ r0
+k_x           equ acc
+
+p             equ r1
+
+num_last      equ r2
+num_last_x    equ x2
+
+a0            equ x3
+t0            equ a0
+
+a3            equ x5
+i             equ r5
+e0            equ a3
+
+a1            equ x6
+qq            equ a1
+ 
+a2            equ x7
+s             equ r7
+s_x           equ a2
+
+
+SORT macro b0, b1
+        cmp     b1, b0
+        jae     @F
+    if 1
+        xchg    b0, b1
+    else
+        mov     acc, b0
+        mov     b0, b1 ; min
+        mov     b1, acc ; max
+    endif
+@@:
+endm
+
+LOAD macro dest:req, index:req
+        mov     dest, [p + 4 * index]
+endm
+
+STORE macro reg:req, index:req
+        mov     [p + 4 * index], reg
+endm
+
+
+STEP_1 macro exit_label
+        mov     t0, [p + k * 8]
+        cmp     t0, [p + k * 8 + 4]
+        adc     s, 0
+        LOAD    t0, s
+        STORE   t0, k ; we lookahed stooring for most expected branch
+        cmp     qq, t0
+        jae     exit_label
+        ; STORE   t0, k  ; use if
+        mov     k, s
+        add     s, s
+        ; lea     s, dword ptr [s + s]
+        ; shl     s, 1
+        ; lea     s, dword ptr [s * 2]
+endm
+
+STEP_BRANCH macro exit_label
+        mov     t0, [p + k * 8]
+        cmp     t0, [p + k * 8 + 4]
+        jae     @F
+        inc     s
+        mov     t0, [p + k * 8 + 4]
+@@:
+        cmp     qq, t0
+        jae     exit_label
+        STORE   t0, k
+        mov     k, s
+        add     s, s
+endm
+
+
+
+MOVE_SMALLEST_UP macro STEP, num_unrolls, exit_2
+        LOCAL leaves, opt_loop, single
+
+        ; s == k * 2
+    rept num_unrolls
+        cmp     s, num_last
+        jae     leaves
+        STEP_1  exit_2
+    endm
+        cmp     s, num_last
+        jb      opt_loop
+
+leaves:
+        ; (s >= num_last)
+        jne     exit_2
+single:
+        ; (s == num_last)
+        mov     t0, [p + k * 8]
+        cmp     qq, t0
+        jae     exit_2
+        STORE   t0, k
+        mov     k, s
+        jmp     exit_2
+ 
+MY_ALIGN_16
+opt_loop:
+        STEP    exit_2
+        cmp     s, num_last
+        jb      opt_loop
+        je      single
+exit_2:
+        STORE   qq, k
+endm
+
+
+
+
+ifdef Z7_SORT_ASM_USE_SEGMENT
+; MY_ALIGN_64
+else
+  MY_ALIGN_16
+endif
+
+MY_PROC HeapSort, 2
+  ifdef x64
+    if (IS_LINUX gt 0)
+        mov     num_last, REG_ABI_PARAM_1  ; r2 <- r6 : linux
+        mov     p,        REG_ABI_PARAM_0  ; r1 <- r7 : linux
+    endif
+  elseif (IS_CDECL gt 0)
+        mov     num_last, [r4 + REG_SIZE * 2]
+        mov     p,        [r4 + REG_SIZE * 1]
+  endif
+        cmp     num_last, 2
+        jb      end_1
+        MY_PUSH_PRESERVED_ABI_REGS_UP_TO_INCLUDING_R11
+        
+        cmp     num_last, 4
+        ja      sort_5
+        
+        LOAD    a0, 0
+        LOAD    a1, 1
+        SORT    a0, a1
+        cmp     num_last, 3
+        jb      end_2
+        
+        LOAD    a2, 2
+        je      sort_3
+        
+        LOAD    a3, 3
+        SORT    a2, a3
+        SORT    a1, a3
+        STORE   a3, 3
+sort_3:
+        SORT    a0, a2
+        SORT    a1, a2
+        STORE   a2, 2
+        jmp     end_2
+        
+sort_5:
+        ; num_last > 4
+        lea     i, dword ptr [num_last - 2]
+        dec     num_last
+        test    i, 1
+        jz      loop_down
+
+        ; single child
+        mov     t0, [p + num_last * 4]
+        mov     qq, [p + num_last * 2]
+        dec     i
+        cmp     qq, t0
+        jae     loop_down
+
+        mov     [p + num_last * 2], t0
+        mov     [p + num_last * 4], qq
+       
+MY_ALIGN_16
+loop_down:
+        mov     t0, [p + i * 4]
+        cmp     t0, [p + i * 4 + 4]
+        mov     k, i
+        mov     qq, [p + i * 2]
+        adc     k, 0
+        LOAD    t0, k
+        cmp     qq, t0
+        jae     down_next
+        mov     [p + i * 2], t0
+        lea     s, dword ptr [k + k]
+        
+        DOWN_num_unrolls   equ 0
+        MOVE_SMALLEST_UP  STEP_1, DOWN_num_unrolls, down_exit_label
+down_next:
+        sub     i, 2
+        jnb     loop_down
+        ; jmp end_debug
+
+        LOAD    e0, 0
+
+MY_ALIGN_16
+main_loop_sort:
+        ; num_last > 3
+        mov     t0, [p + 2 * 4]
+        cmp     t0, [p + 3 * 4]
+        LOAD    qq, num_last
+        STORE   e0, num_last
+        LOAD    e0, 1
+        mov     s_x, 2
+        mov     k_x, 1
+        adc     s, 0
+        LOAD    t0, s
+        dec     num_last
+        cmp     qq, t0
+        jae     main_exit_label
+        STORE   t0, 1
+        mov     k, s
+        add     s, s
+    if 1
+        ; for branch data prefetch mode :
+        ; it's faster for large arrays : larger than (1 << 13) items.
+        MAIN_num_unrolls   equ 10
+        STEP_LOOP          equ STEP_BRANCH
+    else
+        MAIN_num_unrolls   equ 0
+        STEP_LOOP          equ STEP_1
+    endif
+        
+        MOVE_SMALLEST_UP  STEP_LOOP, MAIN_num_unrolls, main_exit_label
+        
+        ; jmp end_debug
+        cmp     num_last, 3
+        jne     main_loop_sort
+
+        ; num_last == 3 (real_size == 4)
+        LOAD    a0, 2
+        LOAD    a1, 3
+        LOAD    a2, 1
+        STORE   e0, 3  ; e0 is alias for a3
+        STORE   a2, 2
+        SORT    a0, a1
+end_2:
+        STORE   a0, 0
+        STORE   a1, 1
+; end_debug:
+        MY_POP_PRESERVED_ABI_REGS_UP_TO_INCLUDING_R11
+end_1:
+MY_ENDP
+
+endif
+
+ifdef Z7_SORT_ASM_USE_SEGMENT
+_TEXT$Z7_SORT ENDS
+endif
+
+if 0
+LEA_IS_D8 (R64) [R2 * 4 + 16]
+ Lat : TP
+   2 :  1 :      adl-e
+   2 :  3   p056 adl-p
+   1 :  2 : p15  hsw-rocket
+   1 :  2 : p01  snb-ivb
+   1 :  1 : p1   conroe-wsm
+   1 :  4 : zen3,zen4
+   2 :  4 : zen1,zen2
+
+LEA_B_IS (R64) [R2 + R3 * 4]
+ Lat : TP
+   1 :  1 :      adl-e
+   2 :  3   p056 adl-p
+   1 :  2 : p15  hsw-rocket
+   1 :  2 : p01  snb-ivb
+   1 :  1 : p1   nhm-wsm
+   1 :  1 : p0   conroe-wsm
+   1 :  4 : zen3,zen4
+   2 :2,4 : zen1,zen2
+   
+LEA_B_IS_D8 (R64) [R2 + R3 * 4 + 16]
+ Lat : TP
+   2 :  1 :      adl-e
+   2 :  3   p056 adl-p
+   1 :  2 : p15  ice-rocket
+   3 :  1 : p1/p15 hsw-rocket
+   3 :  1 : p01  snb-ivb
+   1 :  1 : p1   nhm-wsm
+   1 :  1 : p0   conroe-wsm
+ 2,1 :  2 : zen3,zen4
+   2 :  2 : zen1,zen2
+   
+CMOVB (R64, R64)
+ Lat : TP
+ 1,2 :  2 :      adl-e
+   1 :  2   p06  adl-p
+   1 :  2 : p06  bwd-rocket
+ 1,2 :  2 : p0156+p06 hsw
+ 1,2 :1.5 : p015+p05  snb-ivb
+ 1,2 :  1 : p015+p05  nhm
+   1 :  1 : 2*p015  conroe
+   1 :  2 : zen3,zen4
+   1 :  4 : zen1,zen2
+
+ADC (R64, 0)
+ Lat : TP
+ 1,2 :  2 :      adl-e
+   1 :  2   p06  adl-p
+   1 :  2 : p06  bwd-rocket
+   1 :1.5 : p0156+p06 hsw
+   1 :1.5 : p015+p05  snb-ivb
+   2 :  1 : 2*p015    conroe-wstm
+   1 :  2 : zen1,zen2,zen3,zen4
+   
+PREFETCHNTA : fetch data into non-temporal cache close to the processor, minimizing cache pollution.
+  L1 : Pentium3
+  L2 : NetBurst
+  L1, not L2: Core duo, Core 2, Atom processors
+  L1, not L2, may fetch into L3 with fast replacement: Nehalem, Westmere, Sandy Bridge, ...
+      NEHALEM: Fills L1/L3, L1 LRU is not updated
+  L3 with fast replacement: Xeon Processors based on Nehalem, Westmere, Sandy Bridge, ...
+PREFETCHT0 : fetch data into all cache levels.
+PREFETCHT1 : fetch data into L2 and L3
+endif
+
+end
diff --git a/C/7zDec.c b/C/7zDec.c
index c9b4064..520cbfd 100644
--- a/C/7zDec.c
+++ b/C/7zDec.c
@@ -1,5 +1,5 @@
 /* 7zDec.c -- Decoding from 7z folder
-2024-03-01 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -312,8 +312,9 @@ static BoolInt IS_MAIN_METHOD(UInt32 m)
     case k_PPMD:
   #endif
       return True;
+    default:
+      return False;
   }
-  return False;
 }
 
 static BoolInt IS_SUPPORTED_CODER(const CSzCoderInfo *c)
diff --git a/C/7zVersion.h b/C/7zVersion.h
index 1ddef80..b6142e9 100644
--- a/C/7zVersion.h
+++ b/C/7zVersion.h
@@ -1,7 +1,7 @@
-#define MY_VER_MAJOR 24
-#define MY_VER_MINOR 8
+#define MY_VER_MAJOR 25
+#define MY_VER_MINOR 1
 #define MY_VER_BUILD 0
-#define MY_VERSION_NUMBERS "24.08"
+#define MY_VERSION_NUMBERS "25.01"
 #define MY_VERSION MY_VERSION_NUMBERS
 
 #ifdef MY_CPU_NAME
@@ -10,12 +10,12 @@
   #define MY_VERSION_CPU MY_VERSION
 #endif
 
-#define MY_DATE "2024-08-11"
+#define MY_DATE "2025-08-03"
 #undef MY_COPYRIGHT
 #undef MY_VERSION_COPYRIGHT_DATE
 #define MY_AUTHOR_NAME "Igor Pavlov"
 #define MY_COPYRIGHT_PD "Igor Pavlov : Public domain"
-#define MY_COPYRIGHT_CR "Copyright (c) 1999-2024 Igor Pavlov"
+#define MY_COPYRIGHT_CR "Copyright (c) 1999-2025 Igor Pavlov"
 
 #ifdef USE_COPYRIGHT_CR
   #define MY_COPYRIGHT MY_COPYRIGHT_CR
diff --git a/C/AesOpt.c b/C/AesOpt.c
index 58769ea..b281807 100644
--- a/C/AesOpt.c
+++ b/C/AesOpt.c
@@ -1,5 +1,5 @@
 /* AesOpt.c -- AES optimized code for x86 AES hardware instructions
-2024-03-01 : Igor Pavlov : Public domain */
+Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -80,19 +80,39 @@ AES_FUNC_START (name)
 
 #define MM_XOR( dest, src)    MM_OP(_mm_xor_si128,    dest, src)
 
+#if 1
+// use aligned SSE load/store for data.
+// It is required for our Aes functions, that data is aligned for 16-bytes.
+// So we can use this branch of code.
+// and compiler can use fused load-op SSE instructions:
+//   xorps xmm0, XMMWORD PTR [rdx]
+#define LOAD_128(pp)        (*(__m128i *)(void *)(pp))
+#define STORE_128(pp, _v)    *(__m128i *)(void *)(pp) = _v
+// use aligned SSE load/store for data. Alternative code with direct access
+// #define LOAD_128(pp)        _mm_load_si128(pp)
+// #define STORE_128(pp, _v)   _mm_store_si128(pp, _v)
+#else
+// use unaligned load/store for data: movdqu XMMWORD PTR [rdx]
+#define LOAD_128(pp)        _mm_loadu_si128(pp)
+#define STORE_128(pp, _v)   _mm_storeu_si128(pp, _v)
+#endif
+
 AES_FUNC_START2 (AesCbc_Encode_HW)
 {
+  if (numBlocks == 0)
+    return;
+  {
   __m128i *p = (__m128i *)(void *)ivAes;
   __m128i *data = (__m128i *)(void *)data8;
   __m128i m = *p;
   const __m128i k0 = p[2];
   const __m128i k1 = p[3];
   const UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
-  for (; numBlocks != 0; numBlocks--, data++)
+  do
   {
     UInt32 r = numRounds2;
     const __m128i *w = p + 4;
-    __m128i temp = *data;
+    __m128i temp = LOAD_128(data);
     MM_XOR (temp, k0)
     MM_XOR (m, temp)
     MM_OP_m (_mm_aesenc_si128, k1)
@@ -104,9 +124,12 @@ AES_FUNC_START2 (AesCbc_Encode_HW)
     }
     while (--r);
     MM_OP_m (_mm_aesenclast_si128, w[0])
-    *data = m;
+    STORE_128(data, m);
+    data++;
   }
+  while (--numBlocks);
   *p = m;
+  }
 }
 
 
@@ -139,12 +162,12 @@ AES_FUNC_START2 (AesCbc_Encode_HW)
 
 #define WOP(op)  op (m0, 0)  WOP_M1(op)
 
-
 #define DECLARE_VAR(reg, ii)  __m128i reg;
-#define LOAD_data(  reg, ii)  reg = data[ii];
-#define STORE_data( reg, ii)  data[ii] = reg;
+#define LOAD_data_ii(ii)      LOAD_128(data + (ii))
+#define LOAD_data(  reg, ii)  reg = LOAD_data_ii(ii);
+#define STORE_data( reg, ii)  STORE_128(data + (ii), reg);
 #if (NUM_WAYS > 1)
-#define XOR_data_M1(reg, ii)  MM_XOR (reg, data[ii- 1])
+#define XOR_data_M1(reg, ii)  MM_XOR (reg, LOAD_128(data + (ii- 1)))
 #endif
 
 #define MM_OP_key(op, reg)  MM_OP(op, reg, key);
@@ -156,25 +179,22 @@ AES_FUNC_START2 (AesCbc_Encode_HW)
 #define AES_XOR(      reg, ii)   MM_OP_key (_mm_xor_si128,        reg)
 
 #define CTR_START(reg, ii)  MM_OP (_mm_add_epi64, ctr, one)  reg = ctr;
-#define CTR_END(  reg, ii)  MM_XOR (data[ii], reg)
-
+#define CTR_END(  reg, ii)  STORE_128(data + (ii), _mm_xor_si128(reg, \
+                            LOAD_128 (data + (ii))));
 #define WOP_KEY(op, n) { \
     const __m128i key = w[n]; \
-    WOP(op); }
-
+    WOP(op) }
 
 #define WIDE_LOOP_START  \
     dataEnd = data + numBlocks;  \
     if (numBlocks >= NUM_WAYS)  \
     { dataEnd -= NUM_WAYS; do {  \
 
-
 #define WIDE_LOOP_END  \
     data += NUM_WAYS;  \
     } while (data <= dataEnd);  \
     dataEnd += NUM_WAYS; }  \
 
-
 #define SINGLE_LOOP  \
     for (; data < dataEnd; data++)
 
@@ -184,54 +204,73 @@ AES_FUNC_START2 (AesCbc_Encode_HW)
 
 #define AVX_XOR(dest, src)    MM_OP(_mm256_xor_si256, dest, src)
 #define AVX_DECLARE_VAR(reg, ii)  __m256i reg;
-#define AVX_LOAD_data(  reg, ii)  reg = ((const __m256i *)(const void *)data)[ii];
-#define AVX_STORE_data( reg, ii)  ((__m256i *)(void *)data)[ii] = reg;
+
+#if 1
+// use unaligned AVX load/store for data.
+// It is required for our Aes functions, that data is aligned for 16-bytes.
+// But we need 32-bytes reading.
+// So we use intrinsics for unaligned AVX load/store.
+// notes for _mm256_storeu_si256:
+// msvc2022: uses vmovdqu and keeps the order of instruction sequence.
+// new gcc11 uses vmovdqu
+// old gcc9 could use pair of instructions:
+//   vmovups        %xmm7, -224(%rax)
+//   vextracti128   $0x1, %ymm7, -208(%rax)
+#define AVX_LOAD(p)         _mm256_loadu_si256((const __m256i *)(const void *)(p))
+#define AVX_STORE(p, _v)    _mm256_storeu_si256((__m256i *)(void *)(p), _v);
+#else
+// use aligned AVX load/store for data.
+// for debug: we can use this branch, if we are sure that data is aligned for 32-bytes.
+// msvc2022 uses vmovdqu still
+// gcc      uses vmovdqa (that requires 32-bytes alignment)
+#define AVX_LOAD(p)         (*(const __m256i *)(const void *)(p))
+#define AVX_STORE(p, _v)    (*(__m256i *)(void *)(p)) = _v;
+#endif
+
+#define AVX_LOAD_data(  reg, ii)  reg = AVX_LOAD((const __m256i *)(const void *)data + (ii));
+#define AVX_STORE_data( reg, ii)  AVX_STORE((__m256i *)(void *)data + (ii), reg)
 /*
-AVX_XOR_data_M1() needs unaligned memory load
-if (we don't use _mm256_loadu_si256() here)
-{
-  Most compilers with enabled optimizations generate fused AVX (LOAD + OP)
-  instruction that can load unaligned data.
-  But GCC and CLANG without -O2 or -O1 optimizations can generate separated
-  LOAD-ALIGNED (vmovdqa) instruction that will fail on execution.
-}
-Note: some compilers generate more instructions, if we use _mm256_loadu_si256() here.
-v23.02: we use _mm256_loadu_si256() here, because we need compatibility with any compiler.
+AVX_XOR_data_M1() needs unaligned memory load, even if (data)
+is aligned for 256-bits, because we read 32-bytes chunk that
+crosses (data) position: from (data - 16bytes) to (data + 16bytes).
 */
-#define AVX_XOR_data_M1(reg, ii)  AVX_XOR (reg, _mm256_loadu_si256(&(((const __m256i *)(const void *)(data - 1))[ii])))
-// for debug only: the following code will fail on execution, if compiled by some compilers:
-// #define AVX_XOR_data_M1(reg, ii)  AVX_XOR (reg, (((const __m256i *)(const void *)(data - 1))[ii]))
+#define AVX_XOR_data_M1(reg, ii)  AVX_XOR (reg, _mm256_loadu_si256((const __m256i *)(const void *)(data - 1) + (ii)))
 
 #define AVX_AES_DEC(      reg, ii)   MM_OP_key (_mm256_aesdec_epi128,     reg)
 #define AVX_AES_DEC_LAST( reg, ii)   MM_OP_key (_mm256_aesdeclast_epi128, reg)
 #define AVX_AES_ENC(      reg, ii)   MM_OP_key (_mm256_aesenc_epi128,     reg)
 #define AVX_AES_ENC_LAST( reg, ii)   MM_OP_key (_mm256_aesenclast_epi128, reg)
 #define AVX_AES_XOR(      reg, ii)   MM_OP_key (_mm256_xor_si256,         reg)
-#define AVX_CTR_START(reg, ii)  MM_OP (_mm256_add_epi64, ctr2, two)  reg = _mm256_xor_si256(ctr2, key);
-#define AVX_CTR_END(  reg, ii)  AVX_XOR (((__m256i *)(void *)data)[ii], reg)
+#define AVX_CTR_START(reg, ii)  \
+    MM_OP (_mm256_add_epi64, ctr2, two) \
+    reg = _mm256_xor_si256(ctr2, key);
+
+#define AVX_CTR_END(reg, ii)  \
+    AVX_STORE((__m256i *)(void *)data + (ii), _mm256_xor_si256(reg, \
+    AVX_LOAD ((__m256i *)(void *)data + (ii))));
+
 #define AVX_WOP_KEY(op, n) { \
     const __m256i key = w[n]; \
-    WOP(op); }
+    WOP(op) }
 
 #define NUM_AES_KEYS_MAX 15
 
 #define WIDE_LOOP_START_AVX(OP)  \
     dataEnd = data + numBlocks;  \
     if (numBlocks >= NUM_WAYS * 2)  \
-    { __m256i keys[NUM_AES_KEYS_MAX]; \
-    UInt32 ii; \
-    OP \
-    for (ii = 0; ii < numRounds; ii++) \
-      keys[ii] = _mm256_broadcastsi128_si256(p[ii]); \
-    dataEnd -= NUM_WAYS * 2; do {  \
-
+    { __m256i keys[NUM_AES_KEYS_MAX];  \
+      OP  \
+      { UInt32 ii; for (ii = 0; ii < numRounds; ii++)  \
+        keys[ii] = _mm256_broadcastsi128_si256(p[ii]); }  \
+      dataEnd -= NUM_WAYS * 2; \
+      do {  \
 
 #define WIDE_LOOP_END_AVX(OP)  \
-    data += NUM_WAYS * 2;  \
-    } while (data <= dataEnd);  \
-    dataEnd += NUM_WAYS * 2;  \
-    OP  \
-    _mm256_zeroupper();  \
+        data += NUM_WAYS * 2;  \
+      } while (data <= dataEnd);  \
+      dataEnd += NUM_WAYS * 2;  \
+      OP  \
+      _mm256_zeroupper();  \
     }  \
 
 /* MSVC for x86: If we don't call _mm256_zeroupper(), and -arch:IA32 is not specified,
@@ -246,21 +285,20 @@ AES_FUNC_START2 (AesCbc_Decode_HW)
   __m128i *p = (__m128i *)(void *)ivAes;
   __m128i *data = (__m128i *)(void *)data8;
   __m128i iv = *p;
-  const __m128i *wStart = p + *(const UInt32 *)(p + 1) * 2 + 2 - 1;
+  const __m128i * const wStart = p + (size_t)*(const UInt32 *)(p + 1) * 2 + 2 - 1;
   const __m128i *dataEnd;
   p += 2;
   
   WIDE_LOOP_START
   {
     const __m128i *w = wStart;
-    
     WOP (DECLARE_VAR)
     WOP (LOAD_data)
     WOP_KEY (AES_XOR, 1)
-
     do
     {
       WOP_KEY (AES_DEC, 0)
+
       w--;
     }
     while (w != p);
@@ -268,7 +306,7 @@ AES_FUNC_START2 (AesCbc_Decode_HW)
 
     MM_XOR (m0, iv)
     WOP_M1 (XOR_data_M1)
-    iv = data[NUM_WAYS - 1];
+    LOAD_data(iv, NUM_WAYS - 1)
     WOP (STORE_data)
   }
   WIDE_LOOP_END
@@ -276,7 +314,8 @@ AES_FUNC_START2 (AesCbc_Decode_HW)
   SINGLE_LOOP
   {
     const __m128i *w = wStart - 1;
-    __m128i m = _mm_xor_si128 (w[2], *data);
+    __m128i m = _mm_xor_si128 (w[2], LOAD_data_ii(0));
+    
     do
     {
       MM_OP_m (_mm_aesdec_si128, w[1])
@@ -286,10 +325,9 @@ AES_FUNC_START2 (AesCbc_Decode_HW)
     while (w != p);
     MM_OP_m (_mm_aesdec_si128,     w[1])
     MM_OP_m (_mm_aesdeclast_si128, w[0])
-
     MM_XOR (m, iv)
-    iv = *data;
-    *data = m;
+    LOAD_data(iv, 0)
+    STORE_data(m, 0)
   }
   
   p[-2] = iv;
@@ -301,9 +339,9 @@ AES_FUNC_START2 (AesCtr_Code_HW)
   __m128i *p = (__m128i *)(void *)ivAes;
   __m128i *data = (__m128i *)(void *)data8;
   __m128i ctr = *p;
-  UInt32 numRoundsMinus2 = *(const UInt32 *)(p + 1) * 2 - 1;
+  const UInt32 numRoundsMinus2 = *(const UInt32 *)(p + 1) * 2 - 1;
   const __m128i *dataEnd;
-  __m128i one = _mm_cvtsi32_si128(1);
+  const __m128i one = _mm_cvtsi32_si128(1);
 
   p += 2;
   
@@ -322,7 +360,6 @@ AES_FUNC_START2 (AesCtr_Code_HW)
     }
     while (--r);
     WOP_KEY (AES_ENC_LAST, 0)
-   
     WOP (CTR_END)
   }
   WIDE_LOOP_END
@@ -344,7 +381,7 @@ AES_FUNC_START2 (AesCtr_Code_HW)
     while (--numRounds2);
     MM_OP_m (_mm_aesenc_si128,     w[0])
     MM_OP_m (_mm_aesenclast_si128, w[1])
-    MM_XOR (*data, m)
+    CTR_END (m, 0)
   }
   
   p[-2] = ctr;
@@ -421,7 +458,7 @@ VAES_FUNC_START2 (AesCbc_Decode_HW_256)
   __m128i *data = (__m128i *)(void *)data8;
   __m128i iv = *p;
   const __m128i *dataEnd;
-  UInt32 numRounds = *(const UInt32 *)(p + 1) * 2 + 1;
+  const UInt32 numRounds = *(const UInt32 *)(p + 1) * 2 + 1;
   p += 2;
   
   WIDE_LOOP_START_AVX(;)
@@ -440,17 +477,17 @@ VAES_FUNC_START2 (AesCbc_Decode_HW_256)
     while (w != keys);
     AVX_WOP_KEY (AVX_AES_DEC_LAST, 0)
 
-    AVX_XOR (m0, _mm256_setr_m128i(iv, data[0]))
+    AVX_XOR (m0, _mm256_setr_m128i(iv, LOAD_data_ii(0)))
     WOP_M1 (AVX_XOR_data_M1)
-    iv = data[NUM_WAYS * 2 - 1];
+    LOAD_data (iv, NUM_WAYS * 2 - 1)
     WOP (AVX_STORE_data)
   }
   WIDE_LOOP_END_AVX(;)
 
   SINGLE_LOOP
   {
-    const __m128i *w = p + *(const UInt32 *)(p + 1 - 2) * 2 + 1 - 3;
-    __m128i m = _mm_xor_si128 (w[2], *data);
+    const __m128i *w = p - 2 + (size_t)*(const UInt32 *)(p + 1 - 2) * 2;
+    __m128i m = _mm_xor_si128 (w[2], LOAD_data_ii(0));
     do
     {
       MM_OP_m (_mm_aesdec_si128, w[1])
@@ -462,8 +499,8 @@ VAES_FUNC_START2 (AesCbc_Decode_HW_256)
     MM_OP_m (_mm_aesdeclast_si128, w[0])
 
     MM_XOR (m, iv)
-    iv = *data;
-    *data = m;
+    LOAD_data(iv, 0)
+    STORE_data(m, 0)
   }
   
   p[-2] = iv;
@@ -493,9 +530,9 @@ VAES_FUNC_START2 (AesCtr_Code_HW_256)
   __m128i *p = (__m128i *)(void *)ivAes;
   __m128i *data = (__m128i *)(void *)data8;
   __m128i ctr = *p;
-  UInt32 numRounds = *(const UInt32 *)(p + 1) * 2 + 1;
+  const UInt32 numRounds = *(const UInt32 *)(p + 1) * 2 + 1;
   const __m128i *dataEnd;
-  __m128i one = _mm_cvtsi32_si128(1);
+  const __m128i one = _mm_cvtsi32_si128(1);
   __m256i ctr2, two;
   p += 2;
   
@@ -536,7 +573,7 @@ VAES_FUNC_START2 (AesCtr_Code_HW_256)
     while (--numRounds2);
     MM_OP_m (_mm_aesenc_si128,     w[0])
     MM_OP_m (_mm_aesenclast_si128, w[1])
-    MM_XOR (*data, m)
+    CTR_END (m, 0)
   }
 
   p[-2] = ctr;
@@ -731,9 +768,14 @@ AES_FUNC_START (name)
 
 AES_FUNC_START2 (AesCbc_Encode_HW)
 {
-  v128 * const p = (v128*)(void*)ivAes;
-  v128 *data = (v128*)(void*)data8;
+  if (numBlocks == 0)
+    return;
+  {
+  v128 * const p = (v128 *)(void *)ivAes;
+  v128 *data = (v128 *)(void *)data8;
   v128 m = *p;
+  const UInt32 numRounds2 = *(const UInt32 *)(p + 1);
+  const v128 *w = p + (size_t)numRounds2 * 2;
   const v128 k0 = p[2];
   const v128 k1 = p[3];
   const v128 k2 = p[4];
@@ -744,11 +786,14 @@ AES_FUNC_START2 (AesCbc_Encode_HW)
   const v128 k7 = p[9];
   const v128 k8 = p[10];
   const v128 k9 = p[11];
-  const UInt32 numRounds2 = *(const UInt32 *)(p + 1);
-  const v128 *w = p + ((size_t)numRounds2 * 2);
+  const v128 k_z4 = w[-2];
+  const v128 k_z3 = w[-1];
+  const v128 k_z2 = w[0];
   const v128 k_z1 = w[1];
   const v128 k_z0 = w[2];
-  for (; numBlocks != 0; numBlocks--, data++)
+  // we don't use optimization veorq_u8(*data, k_z0) that can reduce one cycle,
+  // because gcc/clang compilers are not good for that optimization.
+  do
   {
     MM_XOR_m (*data)
     AES_E_MC_m (k0)
@@ -757,24 +802,26 @@ AES_FUNC_START2 (AesCbc_Encode_HW)
     AES_E_MC_m (k3)
     AES_E_MC_m (k4)
     AES_E_MC_m (k5)
-    AES_E_MC_m (k6)
-    AES_E_MC_m (k7)
-    AES_E_MC_m (k8)
     if (numRounds2 >= 6)
     {
-      AES_E_MC_m (k9)
-      AES_E_MC_m (p[12])
+      AES_E_MC_m (k6)
+      AES_E_MC_m (k7)
       if (numRounds2 != 6)
       {
-        AES_E_MC_m (p[13])
-        AES_E_MC_m (p[14])
+        AES_E_MC_m (k8)
+        AES_E_MC_m (k9)
       }
     }
-    AES_E_m  (k_z1)
-    MM_XOR_m (k_z0)
-    *data = m;
+    AES_E_MC_m (k_z4)
+    AES_E_MC_m (k_z3)
+    AES_E_MC_m (k_z2)
+    AES_E_m    (k_z1)
+    MM_XOR_m   (k_z0)
+    *data++ = m;
   }
+  while (--numBlocks);
   *p = m;
+  }
 }
 
 
@@ -834,10 +881,10 @@ AES_FUNC_START2 (AesCbc_Encode_HW)
 
 AES_FUNC_START2 (AesCbc_Decode_HW)
 {
-  v128 *p = (v128*)(void*)ivAes;
-  v128 *data = (v128*)(void*)data8;
+  v128 *p = (v128 *)(void *)ivAes;
+  v128 *data = (v128 *)(void *)data8;
   v128 iv = *p;
-  const v128 *wStart = p + ((size_t)*(const UInt32 *)(p + 1)) * 2;
+  const v128 * const wStart = p + (size_t)*(const UInt32 *)(p + 1) * 2;
   const v128 *dataEnd;
   p += 2;
   
@@ -858,7 +905,7 @@ AES_FUNC_START2 (AesCbc_Decode_HW)
     WOP_KEY (AES_XOR, 0)
     MM_XOR (m0, iv)
     WOP_M1 (XOR_data_M1)
-    iv = data[NUM_WAYS - 1];
+    LOAD_data(iv, NUM_WAYS - 1)
     WOP (STORE_data)
   }
   WIDE_LOOP_END
@@ -866,7 +913,7 @@ AES_FUNC_START2 (AesCbc_Decode_HW)
   SINGLE_LOOP
   {
     const v128 *w = wStart;
-    v128 m = *data;
+    v128 m;  LOAD_data(m, 0)
     AES_D_IMC_m (w[2])
     do
     {
@@ -878,8 +925,8 @@ AES_FUNC_START2 (AesCbc_Decode_HW)
     AES_D_m  (w[1])
     MM_XOR_m (w[0])
     MM_XOR_m (iv)
-    iv = *data;
-    *data = m;
+    LOAD_data(iv, 0)
+    STORE_data(m, 0)
   }
   
   p[-2] = iv;
@@ -888,19 +935,17 @@ AES_FUNC_START2 (AesCbc_Decode_HW)
 
 AES_FUNC_START2 (AesCtr_Code_HW)
 {
-  v128 *p = (v128*)(void*)ivAes;
-  v128 *data = (v128*)(void*)data8;
+  v128 *p = (v128 *)(void *)ivAes;
+  v128 *data = (v128 *)(void *)data8;
   uint64x2_t ctr = vreinterpretq_u64_u8(*p);
-  const v128 *wEnd = p + ((size_t)*(const UInt32 *)(p + 1)) * 2;
+  const v128 * const wEnd = p + (size_t)*(const UInt32 *)(p + 1) * 2;
   const v128 *dataEnd;
-  uint64x2_t one = vdupq_n_u64(0);
-
 // the bug in clang:
 // __builtin_neon_vsetq_lane_i64(__s0, (int8x16_t)__s1, __p2);
 #if defined(__clang__) && (__clang_major__ <= 9)
 #pragma GCC diagnostic ignored "-Wvector-conversion"
 #endif
-  one = vsetq_lane_u64(1, one, 0);
+  const uint64x2_t one = vsetq_lane_u64(1, vdupq_n_u64(0), 0);
   p += 2;
   
   WIDE_LOOP_START
diff --git a/C/BwtSort.c b/C/BwtSort.c
index 05ad6de..8f64f9d 100644
--- a/C/BwtSort.c
+++ b/C/BwtSort.c
@@ -1,5 +1,5 @@
 /* BwtSort.c -- BWT block sorting
-2023-04-02 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -7,6 +7,44 @@
 #include "Sort.h"
 
 /* #define BLOCK_SORT_USE_HEAP_SORT */
+// #define BLOCK_SORT_USE_HEAP_SORT
+
+#ifdef BLOCK_SORT_USE_HEAP_SORT
+
+#define HeapSortRefDown(p, vals, n, size, temp) \
+  { size_t k = n; UInt32 val = vals[temp]; for (;;) { \
+    size_t s = k << 1; \
+    if (s > size) break; \
+    if (s < size && vals[p[s + 1]] > vals[p[s]]) s++; \
+    if (val >= vals[p[s]]) break; \
+    p[k] = p[s]; k = s; \
+  } p[k] = temp; }
+
+void HeapSortRef(UInt32 *p, UInt32 *vals, size_t size)
+{
+  if (size <= 1)
+    return;
+  p--;
+  {
+    size_t i = size / 2;
+    do
+    {
+      UInt32 temp = p[i];
+      HeapSortRefDown(p, vals, i, size, temp);
+    }
+    while (--i != 0);
+  }
+  do
+  {
+    UInt32 temp = p[size];
+    p[size--] = p[1];
+    HeapSortRefDown(p, vals, 1, size, temp);
+  }
+  while (size > 1);
+}
+
+#endif // BLOCK_SORT_USE_HEAP_SORT
+
 
 /* Don't change it !!! */
 #define kNumHashBytes 2
@@ -27,26 +65,27 @@
 
 #else
 
-#define kNumBitsMax 20
-#define kIndexMask ((1 << kNumBitsMax) - 1)
-#define kNumExtraBits (32 - kNumBitsMax)
-#define kNumExtra0Bits (kNumExtraBits - 2)
-#define kNumExtra0Mask ((1 << kNumExtra0Bits) - 1)
+#define kNumBitsMax     20
+#define kIndexMask      (((UInt32)1 << kNumBitsMax) - 1)
+#define kNumExtraBits   (32 - kNumBitsMax)
+#define kNumExtra0Bits  (kNumExtraBits - 2)
+#define kNumExtra0Mask  ((1 << kNumExtra0Bits) - 1)
 
 #define SetFinishedGroupSize(p, size) \
-  {  *(p) |= ((((size) - 1) & kNumExtra0Mask) << kNumBitsMax); \
+  {  *(p) |= ((((UInt32)(size) - 1) & kNumExtra0Mask) << kNumBitsMax); \
     if ((size) > (1 << kNumExtra0Bits)) { \
-    *(p) |= 0x40000000;  *((p) + 1) |= ((((size) - 1)>> kNumExtra0Bits) << kNumBitsMax); } } \
+      *(p) |= 0x40000000; \
+      *((p) + 1) |= (((UInt32)(size) - 1) >> kNumExtra0Bits) << kNumBitsMax; } } \
 
-static void SetGroupSize(UInt32 *p, UInt32 size)
+static void SetGroupSize(UInt32 *p, size_t size)
 {
   if (--size == 0)
     return;
-  *p |= 0x80000000 | ((size & kNumExtra0Mask) << kNumBitsMax);
+  *p |= 0x80000000 | (((UInt32)size & kNumExtra0Mask) << kNumBitsMax);
   if (size >= (1 << kNumExtra0Bits))
   {
     *p |= 0x40000000;
-    p[1] |= ((size >> kNumExtra0Bits) << kNumBitsMax);
+    p[1] |= (((UInt32)size >> kNumExtra0Bits) << kNumBitsMax);
   }
 }
 
@@ -59,12 +98,14 @@ returns: 1 - if there are groups, 0 - no more groups
 */
 
 static
-UInt32
+unsigned
 Z7_FASTCALL
-SortGroup(UInt32 BlockSize, UInt32 NumSortedBytes, UInt32 groupOffset, UInt32 groupSize, int NumRefBits, UInt32 *Indices
-  #ifndef BLOCK_SORT_USE_HEAP_SORT
-  , UInt32 left, UInt32 range
-  #endif
+SortGroup(size_t BlockSize, size_t NumSortedBytes,
+    size_t groupOffset, size_t groupSize,
+    unsigned NumRefBits, UInt32 *Indices
+#ifndef BLOCK_SORT_USE_HEAP_SORT
+    , size_t left, size_t range
+#endif
   )
 {
   UInt32 *ind2 = Indices + groupOffset;
@@ -79,90 +120,93 @@ SortGroup(UInt32 BlockSize, UInt32 NumSortedBytes, UInt32 groupOffset, UInt32 gr
     return 0;
   }
   Groups = Indices + BlockSize + BS_TEMP_SIZE;
-  if (groupSize <= ((UInt32)1 << NumRefBits)
-      #ifndef BLOCK_SORT_USE_HEAP_SORT
+  if (groupSize <= ((size_t)1 << NumRefBits)
+#ifndef BLOCK_SORT_USE_HEAP_SORT
       && groupSize <= range
-      #endif
+#endif
       )
   {
     UInt32 *temp = Indices + BlockSize;
-    UInt32 j;
-    UInt32 mask, thereAreGroups, group, cg;
+    size_t j, group;
+    UInt32 mask, cg;
+    unsigned thereAreGroups;
     {
       UInt32 gPrev;
       UInt32 gRes = 0;
       {
-        UInt32 sp = ind2[0] + NumSortedBytes;
-        if (sp >= BlockSize) sp -= BlockSize;
+        size_t sp = ind2[0] + NumSortedBytes;
+        if (sp >= BlockSize)
+            sp -= BlockSize;
         gPrev = Groups[sp];
-        temp[0] = (gPrev << NumRefBits);
+        temp[0] = gPrev << NumRefBits;
       }
       
       for (j = 1; j < groupSize; j++)
       {
-        UInt32 sp = ind2[j] + NumSortedBytes;
+        size_t sp = ind2[j] + NumSortedBytes;
         UInt32 g;
-        if (sp >= BlockSize) sp -= BlockSize;
+        if (sp >= BlockSize)
+            sp -= BlockSize;
         g = Groups[sp];
-        temp[j] = (g << NumRefBits) | j;
+        temp[j] = (g << NumRefBits) | (UInt32)j;
         gRes |= (gPrev ^ g);
       }
       if (gRes == 0)
       {
-        #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+#ifndef BLOCK_SORT_EXTERNAL_FLAGS
         SetGroupSize(ind2, groupSize);
-        #endif
+#endif
         return 1;
       }
     }
     
     HeapSort(temp, groupSize);
-    mask = (((UInt32)1 << NumRefBits) - 1);
+    mask = ((UInt32)1 << NumRefBits) - 1;
     thereAreGroups = 0;
     
     group = groupOffset;
-    cg = (temp[0] >> NumRefBits);
+    cg = temp[0] >> NumRefBits;
     temp[0] = ind2[temp[0] & mask];
 
     {
-    #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+#ifdef BLOCK_SORT_EXTERNAL_FLAGS
     UInt32 *Flags = Groups + BlockSize;
-    #else
-    UInt32 prevGroupStart = 0;
-    #endif
+#else
+    size_t prevGroupStart = 0;
+#endif
     
     for (j = 1; j < groupSize; j++)
     {
-      UInt32 val = temp[j];
-      UInt32 cgCur = (val >> NumRefBits);
+      const UInt32 val = temp[j];
+      const UInt32 cgCur = val >> NumRefBits;
       
       if (cgCur != cg)
       {
         cg = cgCur;
         group = groupOffset + j;
 
-        #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+#ifdef BLOCK_SORT_EXTERNAL_FLAGS
         {
-        UInt32 t = group - 1;
-        Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask));
+          const size_t t = group - 1;
+          Flags[t >> kNumFlagsBits] &= ~((UInt32)1 << (t & kFlagsMask));
         }
-        #else
+#else
         SetGroupSize(temp + prevGroupStart, j - prevGroupStart);
         prevGroupStart = j;
-        #endif
+#endif
       }
       else
         thereAreGroups = 1;
       {
-      UInt32 ind = ind2[val & mask];
-      temp[j] = ind;
-      Groups[ind] = group;
+        const UInt32 ind = ind2[val & mask];
+        temp[j] = ind;
+        Groups[ind] = (UInt32)group;
       }
     }
 
-    #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+#ifndef BLOCK_SORT_EXTERNAL_FLAGS
     SetGroupSize(temp + prevGroupStart, j - prevGroupStart);
-    #endif
+#endif
     }
 
     for (j = 0; j < groupSize; j++)
@@ -172,37 +216,42 @@ SortGroup(UInt32 BlockSize, UInt32 NumSortedBytes, UInt32 groupOffset, UInt32 gr
 
   /* Check that all strings are in one group (cannot sort) */
   {
-    UInt32 group, j;
-    UInt32 sp = ind2[0] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
+    UInt32 group;
+    size_t j;
+    size_t sp = ind2[0] + NumSortedBytes;
+    if (sp >= BlockSize)
+        sp -= BlockSize;
     group = Groups[sp];
     for (j = 1; j < groupSize; j++)
     {
-      sp = ind2[j] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
+      sp = ind2[j] + NumSortedBytes;
+      if (sp >= BlockSize)
+          sp -= BlockSize;
       if (Groups[sp] != group)
         break;
     }
     if (j == groupSize)
     {
-      #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+#ifndef BLOCK_SORT_EXTERNAL_FLAGS
       SetGroupSize(ind2, groupSize);
-      #endif
+#endif
       return 1;
     }
   }
 
-  #ifndef BLOCK_SORT_USE_HEAP_SORT
+#ifndef BLOCK_SORT_USE_HEAP_SORT
   {
   /* ---------- Range Sort ---------- */
-  UInt32 i;
-  UInt32 mid;
+  size_t i;
+  size_t mid;
   for (;;)
   {
-    UInt32 j;
+    size_t j;
     if (range <= 1)
     {
-      #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+#ifndef BLOCK_SORT_EXTERNAL_FLAGS
       SetGroupSize(ind2, groupSize);
-      #endif
+#endif
       return 1;
     }
     mid = left + ((range + 1) >> 1);
@@ -210,7 +259,7 @@ SortGroup(UInt32 BlockSize, UInt32 NumSortedBytes, UInt32 groupOffset, UInt32 gr
     i = 0;
     do
     {
-      UInt32 sp = ind2[i] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
+      size_t sp = ind2[i] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
       if (Groups[sp] >= mid)
       {
         for (j--; j > i; j--)
@@ -238,51 +287,53 @@ SortGroup(UInt32 BlockSize, UInt32 NumSortedBytes, UInt32 groupOffset, UInt32 gr
       break;
   }
 
-  #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+#ifdef BLOCK_SORT_EXTERNAL_FLAGS
   {
-    UInt32 t = (groupOffset + i - 1);
+    const size_t t = groupOffset + i - 1;
     UInt32 *Flags = Groups + BlockSize;
-    Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask));
+    Flags[t >> kNumFlagsBits] &= ~((UInt32)1 << (t & kFlagsMask));
   }
-  #endif
+#endif
 
   {
-    UInt32 j;
+    size_t j;
     for (j = i; j < groupSize; j++)
-      Groups[ind2[j]] = groupOffset + i;
+      Groups[ind2[j]] = (UInt32)(groupOffset + i);
   }
 
   {
-  UInt32 res = SortGroup(BlockSize, NumSortedBytes, groupOffset, i, NumRefBits, Indices, left, mid - left);
-  return res | SortGroup(BlockSize, NumSortedBytes, groupOffset + i, groupSize - i, NumRefBits, Indices, mid, range - (mid - left));
+    unsigned res = SortGroup(BlockSize, NumSortedBytes, groupOffset, i, NumRefBits, Indices, left, mid - left);
+    return   res | SortGroup(BlockSize, NumSortedBytes, groupOffset + i, groupSize - i, NumRefBits, Indices, mid, range - (mid - left));
   }
 
   }
 
-  #else
+#else // BLOCK_SORT_USE_HEAP_SORT
 
   /* ---------- Heap Sort ---------- */
 
   {
-    UInt32 j;
+    size_t j;
     for (j = 0; j < groupSize; j++)
     {
-      UInt32 sp = ind2[j] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
-      ind2[j] = sp;
+      size_t sp = ind2[j] + NumSortedBytes;
+      if (sp >= BlockSize)
+          sp -= BlockSize;
+      ind2[j] = (UInt32)sp;
     }
 
     HeapSortRef(ind2, Groups, groupSize);
 
     /* Write Flags */
     {
-    UInt32 sp = ind2[0];
+    size_t sp = ind2[0];
     UInt32 group = Groups[sp];
 
-    #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+#ifdef BLOCK_SORT_EXTERNAL_FLAGS
     UInt32 *Flags = Groups + BlockSize;
-    #else
-    UInt32 prevGroupStart = 0;
-    #endif
+#else
+    size_t prevGroupStart = 0;
+#endif
 
     for (j = 1; j < groupSize; j++)
     {
@@ -290,149 +341,210 @@ SortGroup(UInt32 BlockSize, UInt32 NumSortedBytes, UInt32 groupOffset, UInt32 gr
       if (Groups[sp] != group)
       {
         group = Groups[sp];
-        #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+#ifdef BLOCK_SORT_EXTERNAL_FLAGS
         {
-        UInt32 t = groupOffset + j - 1;
+        const size_t t = groupOffset + j - 1;
         Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask));
         }
-        #else
+#else
         SetGroupSize(ind2 + prevGroupStart, j - prevGroupStart);
         prevGroupStart = j;
-        #endif
+#endif
       }
     }
 
-    #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+#ifndef BLOCK_SORT_EXTERNAL_FLAGS
     SetGroupSize(ind2 + prevGroupStart, j - prevGroupStart);
-    #endif
+#endif
     }
     {
     /* Write new Groups values and Check that there are groups */
-    UInt32 thereAreGroups = 0;
+    unsigned thereAreGroups = 0;
     for (j = 0; j < groupSize; j++)
     {
-      UInt32 group = groupOffset + j;
-      #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+      size_t group = groupOffset + j;
+#ifndef BLOCK_SORT_EXTERNAL_FLAGS
       UInt32 subGroupSize = ((ind2[j] & ~0xC0000000) >> kNumBitsMax);
-      if ((ind2[j] & 0x40000000) != 0)
+      if (ind2[j] & 0x40000000)
         subGroupSize += ((ind2[(size_t)j + 1] >> kNumBitsMax) << kNumExtra0Bits);
       subGroupSize++;
       for (;;)
       {
-        UInt32 original = ind2[j];
-        UInt32 sp = original & kIndexMask;
-        if (sp < NumSortedBytes) sp += BlockSize; sp -= NumSortedBytes;
-        ind2[j] = sp | (original & ~kIndexMask);
-        Groups[sp] = group;
+        const UInt32 original = ind2[j];
+        size_t sp = original & kIndexMask;
+        if (sp < NumSortedBytes)
+          sp += BlockSize;
+        sp -= NumSortedBytes;
+        ind2[j] = (UInt32)sp | (original & ~kIndexMask);
+        Groups[sp] = (UInt32)group;
         if (--subGroupSize == 0)
           break;
         j++;
         thereAreGroups = 1;
       }
-      #else
+#else
       UInt32 *Flags = Groups + BlockSize;
       for (;;)
       {
-        UInt32 sp = ind2[j]; if (sp < NumSortedBytes) sp += BlockSize; sp -= NumSortedBytes;
-        ind2[j] = sp;
-        Groups[sp] = group;
+        size_t sp = ind2[j];
+        if (sp < NumSortedBytes)
+          sp += BlockSize;
+        sp -= NumSortedBytes;
+        ind2[j] = (UInt32)sp;
+        Groups[sp] = (UInt32)group;
         if ((Flags[(groupOffset + j) >> kNumFlagsBits] & (1 << ((groupOffset + j) & kFlagsMask))) == 0)
           break;
         j++;
         thereAreGroups = 1;
       }
-      #endif
+#endif
     }
     return thereAreGroups;
     }
   }
-  #endif
+#endif // BLOCK_SORT_USE_HEAP_SORT
 }
 
+
 /* conditions: blockSize > 0 */
-UInt32 BlockSort(UInt32 *Indices, const Byte *data, UInt32 blockSize)
+UInt32 BlockSort(UInt32 *Indices, const Byte *data, size_t blockSize)
 {
   UInt32 *counters = Indices + blockSize;
-  UInt32 i;
+  size_t i;
   UInt32 *Groups;
-  #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+#ifdef BLOCK_SORT_EXTERNAL_FLAGS
   UInt32 *Flags;
-  #endif
+#endif
 
-  /* Radix-Sort for 2 bytes */
+/* Radix-Sort for 2 bytes */
+// { UInt32 yyy; for (yyy = 0; yyy < 100; yyy++) {
   for (i = 0; i < kNumHashValues; i++)
     counters[i] = 0;
-  for (i = 0; i < blockSize - 1; i++)
-    counters[((UInt32)data[i] << 8) | data[(size_t)i + 1]]++;
-  counters[((UInt32)data[i] << 8) | data[0]]++;
+  {
+    const Byte *data2 = data;
+    size_t a = data[(size_t)blockSize - 1];
+    const Byte *data_lim = data + blockSize;
+    if (blockSize >= 4)
+    {
+      data_lim -= 3;
+      do
+      {
+        size_t b;
+        b = data2[0]; counters[(a << 8) | b]++;
+        a = data2[1]; counters[(b << 8) | a]++;
+        b = data2[2]; counters[(a << 8) | b]++;
+        a = data2[3]; counters[(b << 8) | a]++;
+        data2 += 4;
+      }
+      while (data2 < data_lim);
+      data_lim += 3;
+    }
+    while (data2 != data_lim)
+    {
+      size_t b = *data2++;
+      counters[(a << 8) | b]++;
+      a = b;
+    }
+  }
+// }}
 
   Groups = counters + BS_TEMP_SIZE;
-  #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+#ifdef BLOCK_SORT_EXTERNAL_FLAGS
   Flags = Groups + blockSize;
-    {
-      UInt32 numWords = (blockSize + kFlagsMask) >> kNumFlagsBits;
-      for (i = 0; i < numWords; i++)
-        Flags[i] = kAllFlags;
-    }
-  #endif
+  {
+    const size_t numWords = (blockSize + kFlagsMask) >> kNumFlagsBits;
+    for (i = 0; i < numWords; i++)
+      Flags[i] = kAllFlags;
+  }
+#endif
 
   {
     UInt32 sum = 0;
     for (i = 0; i < kNumHashValues; i++)
     {
-      UInt32 groupSize = counters[i];
-      if (groupSize > 0)
+      const UInt32 groupSize = counters[i];
+      counters[i] = sum;
+      sum += groupSize;
+#ifdef BLOCK_SORT_EXTERNAL_FLAGS
+      if (groupSize)
       {
-        #ifdef BLOCK_SORT_EXTERNAL_FLAGS
-        UInt32 t = sum + groupSize - 1;
-        Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask));
-        #endif
-        sum += groupSize;
+        const UInt32 t = sum - 1;
+        Flags[t >> kNumFlagsBits] &= ~((UInt32)1 << (t & kFlagsMask));
       }
-      counters[i] = sum - groupSize;
+#endif
     }
+  }
 
-    for (i = 0; i < blockSize - 1; i++)
-      Groups[i] = counters[((UInt32)data[i] << 8) | data[(size_t)i + 1]];
-    Groups[i] = counters[((UInt32)data[i] << 8) | data[0]];
+  for (i = 0; i < blockSize - 1; i++)
+    Groups[i] = counters[((unsigned)data[i] << 8) | data[(size_t)i + 1]];
+  Groups[i] = counters[((unsigned)data[i] << 8) | data[0]];
+  
+  {
+#define SET_Indices(a, b, i)  \
+    { UInt32 c; \
+      a = (a << 8) | (b); \
+      c = counters[a]; \
+      Indices[c] = (UInt32)i++; \
+      counters[a] = c + 1; \
+    }
 
-    for (i = 0; i < blockSize - 1; i++)
-      Indices[counters[((UInt32)data[i] << 8) | data[(size_t)i + 1]]++] = i;
-    Indices[counters[((UInt32)data[i] << 8) | data[0]]++] = i;
-    
-    #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+    size_t a = data[0];
+    const Byte *data_ptr = data + 1;
+    i = 0;
+    if (blockSize >= 3)
+    {
+      blockSize -= 2;
+      do
+      {
+        size_t b;
+        b = data_ptr[0];  SET_Indices(a, b, i)
+        a = data_ptr[1];  SET_Indices(b, a, i)
+        data_ptr += 2;
+      }
+      while (i < blockSize);
+      blockSize += 2;
+    }
+    if (i < blockSize - 1)
     {
+      SET_Indices(a, data[(size_t)i + 1], i)
+      a = (Byte)a;
+    }
+    SET_Indices(a, data[0], i)
+  }
+  
+#ifndef BLOCK_SORT_EXTERNAL_FLAGS
+  {
     UInt32 prev = 0;
     for (i = 0; i < kNumHashValues; i++)
     {
-      UInt32 prevGroupSize = counters[i] - prev;
+      const UInt32 prevGroupSize = counters[i] - prev;
       if (prevGroupSize == 0)
         continue;
       SetGroupSize(Indices + prev, prevGroupSize);
       prev = counters[i];
     }
-    }
-    #endif
   }
+#endif
 
   {
-  int NumRefBits;
-  UInt32 NumSortedBytes;
-  for (NumRefBits = 0; ((blockSize - 1) >> NumRefBits) != 0; NumRefBits++);
+  unsigned NumRefBits;
+  size_t NumSortedBytes;
+  for (NumRefBits = 0; ((blockSize - 1) >> NumRefBits) != 0; NumRefBits++)
+  {}
   NumRefBits = 32 - NumRefBits;
   if (NumRefBits > kNumRefBitsMax)
-    NumRefBits = kNumRefBitsMax;
+      NumRefBits = kNumRefBitsMax;
 
   for (NumSortedBytes = kNumHashBytes; ; NumSortedBytes <<= 1)
   {
-    #ifndef BLOCK_SORT_EXTERNAL_FLAGS
-    UInt32 finishedGroupSize = 0;
-    #endif
-    UInt32 newLimit = 0;
+#ifndef BLOCK_SORT_EXTERNAL_FLAGS
+    size_t finishedGroupSize = 0;
+#endif
+    size_t newLimit = 0;
     for (i = 0; i < blockSize;)
     {
-      UInt32 groupSize;
-      #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+      size_t groupSize;
+#ifdef BLOCK_SORT_EXTERNAL_FLAGS
 
       if ((Flags[i >> kNumFlagsBits] & (1 << (i & kFlagsMask))) == 0)
       {
@@ -441,56 +553,56 @@ UInt32 BlockSort(UInt32 *Indices, const Byte *data, UInt32 blockSize)
       }
       for (groupSize = 1;
         (Flags[(i + groupSize) >> kNumFlagsBits] & (1 << ((i + groupSize) & kFlagsMask))) != 0;
-        groupSize++);
-      
+        groupSize++)
+        {}
       groupSize++;
 
-      #else
+#else
 
-      groupSize = ((Indices[i] & ~0xC0000000) >> kNumBitsMax);
+      groupSize = (Indices[i] & ~0xC0000000) >> kNumBitsMax;
       {
-      BoolInt finishedGroup = ((Indices[i] & 0x80000000) == 0);
-      if ((Indices[i] & 0x40000000) != 0)
-      {
-        groupSize += ((Indices[(size_t)i + 1] >> kNumBitsMax) << kNumExtra0Bits);
-        Indices[(size_t)i + 1] &= kIndexMask;
-      }
-      Indices[i] &= kIndexMask;
-      groupSize++;
-      if (finishedGroup || groupSize == 1)
-      {
-        Indices[i - finishedGroupSize] &= kIndexMask;
-        if (finishedGroupSize > 1)
-          Indices[(size_t)(i - finishedGroupSize) + 1] &= kIndexMask;
+        const BoolInt finishedGroup = ((Indices[i] & 0x80000000) == 0);
+        if (Indices[i] & 0x40000000)
         {
-        UInt32 newGroupSize = groupSize + finishedGroupSize;
-        SetFinishedGroupSize(Indices + i - finishedGroupSize, newGroupSize)
-        finishedGroupSize = newGroupSize;
+          groupSize += ((Indices[(size_t)i + 1] >> kNumBitsMax) << kNumExtra0Bits);
+          Indices[(size_t)i + 1] &= kIndexMask;
         }
-        i += groupSize;
-        continue;
-      }
-      finishedGroupSize = 0;
+        Indices[i] &= kIndexMask;
+        groupSize++;
+        if (finishedGroup || groupSize == 1)
+        {
+          Indices[i - finishedGroupSize] &= kIndexMask;
+          if (finishedGroupSize > 1)
+            Indices[(size_t)(i - finishedGroupSize) + 1] &= kIndexMask;
+          {
+            const size_t newGroupSize = groupSize + finishedGroupSize;
+            SetFinishedGroupSize(Indices + i - finishedGroupSize, newGroupSize)
+            finishedGroupSize = newGroupSize;
+          }
+          i += groupSize;
+          continue;
+        }
+        finishedGroupSize = 0;
       }
 
-      #endif
+#endif
       
       if (NumSortedBytes >= blockSize)
       {
-        UInt32 j;
+        size_t j;
         for (j = 0; j < groupSize; j++)
         {
-          UInt32 t = (i + j);
+          size_t t = i + j;
           /* Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask)); */
-          Groups[Indices[t]] = t;
+          Groups[Indices[t]] = (UInt32)t;
         }
       }
       else
         if (SortGroup(blockSize, NumSortedBytes, i, groupSize, NumRefBits, Indices
-          #ifndef BLOCK_SORT_USE_HEAP_SORT
-          , 0, blockSize
-          #endif
-          ) != 0)
+            #ifndef BLOCK_SORT_USE_HEAP_SORT
+              , 0, blockSize
+            #endif
+            ))
           newLimit = i + groupSize;
       i += groupSize;
     }
@@ -498,19 +610,19 @@ UInt32 BlockSort(UInt32 *Indices, const Byte *data, UInt32 blockSize)
       break;
   }
   }
-  #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+#ifndef BLOCK_SORT_EXTERNAL_FLAGS
   for (i = 0; i < blockSize;)
   {
-    UInt32 groupSize = ((Indices[i] & ~0xC0000000) >> kNumBitsMax);
-    if ((Indices[i] & 0x40000000) != 0)
+    size_t groupSize = (Indices[i] & ~0xC0000000) >> kNumBitsMax;
+    if (Indices[i] & 0x40000000)
     {
-      groupSize += ((Indices[(size_t)i + 1] >> kNumBitsMax) << kNumExtra0Bits);
+      groupSize += (Indices[(size_t)i + 1] >> kNumBitsMax) << kNumExtra0Bits;
       Indices[(size_t)i + 1] &= kIndexMask;
     }
     Indices[i] &= kIndexMask;
     groupSize++;
     i += groupSize;
   }
-  #endif
+#endif
   return Groups[0];
 }
diff --git a/C/BwtSort.h b/C/BwtSort.h
index a34b243..1bd2316 100644
--- a/C/BwtSort.h
+++ b/C/BwtSort.h
@@ -1,5 +1,5 @@
 /* BwtSort.h -- BWT block sorting
-2023-03-03 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_BWT_SORT_H
 #define ZIP7_INC_BWT_SORT_H
@@ -10,16 +10,17 @@ EXTERN_C_BEGIN
 
 /* use BLOCK_SORT_EXTERNAL_FLAGS if blockSize can be > 1M */
 /* #define BLOCK_SORT_EXTERNAL_FLAGS */
+// #define BLOCK_SORT_EXTERNAL_FLAGS
 
 #ifdef BLOCK_SORT_EXTERNAL_FLAGS
-#define BLOCK_SORT_EXTERNAL_SIZE(blockSize) ((((blockSize) + 31) >> 5))
+#define BLOCK_SORT_EXTERNAL_SIZE(blockSize) (((blockSize) + 31) >> 5)
 #else
 #define BLOCK_SORT_EXTERNAL_SIZE(blockSize) 0
 #endif
 
 #define BLOCK_SORT_BUF_SIZE(blockSize) ((blockSize) * 2 + BLOCK_SORT_EXTERNAL_SIZE(blockSize) + (1 << 16))
 
-UInt32 BlockSort(UInt32 *indices, const Byte *data, UInt32 blockSize);
+UInt32 BlockSort(UInt32 *indices, const Byte *data, size_t blockSize);
 
 EXTERN_C_END
 
diff --git a/C/Compiler.h b/C/Compiler.h
index 2a9c2b7..b266b27 100644
--- a/C/Compiler.h
+++ b/C/Compiler.h
@@ -1,5 +1,5 @@
 /* Compiler.h : Compiler specific defines and pragmas
-2024-01-22 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_COMPILER_H
 #define ZIP7_INC_COMPILER_H
@@ -183,6 +183,16 @@ typedef void (*Z7_void_Function)(void);
   #define Z7_ATTRIB_NO_VECTORIZE
 #endif
 
+#if defined(Z7_MSC_VER_ORIGINAL) && (Z7_MSC_VER_ORIGINAL >= 1920)
+  #define Z7_PRAGMA_OPTIMIZE_FOR_CODE_SIZE _Pragma("optimize ( \"s\", on )")
+  #define Z7_PRAGMA_OPTIMIZE_DEFAULT       _Pragma("optimize ( \"\", on )")
+#else
+  #define Z7_PRAGMA_OPTIMIZE_FOR_CODE_SIZE
+  #define Z7_PRAGMA_OPTIMIZE_DEFAULT
+#endif
+
+
+
 #if defined(MY_CPU_X86_OR_AMD64) && ( \
        defined(__clang__) && (__clang_major__ >= 4) \
     || defined(__GNUC__) && (__GNUC__ >= 5))
diff --git a/C/CpuArch.c b/C/CpuArch.c
index e792f39..6e02551 100644
--- a/C/CpuArch.c
+++ b/C/CpuArch.c
@@ -1,5 +1,5 @@
 /* CpuArch.c -- CPU specific code
-2024-07-04 : Igor Pavlov : Public domain */
+Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -17,7 +17,7 @@
 /*
   cpuid instruction supports (subFunction) parameter in ECX,
   that is used only with some specific (function) parameter values.
-  But we always use only (subFunction==0).
+  most functions use only (subFunction==0).
 */
 /*
   __cpuid(): MSVC and GCC/CLANG use same function/macro name
@@ -49,43 +49,49 @@
 #if defined(MY_CPU_AMD64) && defined(__PIC__) \
     && ((defined (__GNUC__) && (__GNUC__ < 5)) || defined(__clang__))
 
-#define x86_cpuid_MACRO(p, func) { \
+  /* "=&r" selects free register. It can select even rbx, if that register is free.
+     "=&D" for (RDI) also works, but the code can be larger with "=&D"
+     "2"(subFun) : 2 is (zero-based) index in the output constraint list "=c" (ECX). */
+
+#define x86_cpuid_MACRO_2(p, func, subFunc) { \
   __asm__ __volatile__ ( \
     ASM_LN   "mov     %%rbx, %q1"  \
     ASM_LN   "cpuid"               \
     ASM_LN   "xchg    %%rbx, %q1"  \
-    : "=a" ((p)[0]), "=&r" ((p)[1]), "=c" ((p)[2]), "=d" ((p)[3]) : "0" (func), "2"(0)); }
-
-  /* "=&r" selects free register. It can select even rbx, if that register is free.
-     "=&D" for (RDI) also works, but the code can be larger with "=&D"
-     "2"(0) means (subFunction = 0),
-     2 is (zero-based) index in the output constraint list "=c" (ECX). */
+    : "=a" ((p)[0]), "=&r" ((p)[1]), "=c" ((p)[2]), "=d" ((p)[3]) : "0" (func), "2"(subFunc)); }
 
 #elif defined(MY_CPU_X86) && defined(__PIC__) \
     && ((defined (__GNUC__) && (__GNUC__ < 5)) || defined(__clang__))
 
-#define x86_cpuid_MACRO(p, func) { \
+#define x86_cpuid_MACRO_2(p, func, subFunc) { \
   __asm__ __volatile__ ( \
     ASM_LN   "mov     %%ebx, %k1"  \
     ASM_LN   "cpuid"               \
     ASM_LN   "xchg    %%ebx, %k1"  \
-    : "=a" ((p)[0]), "=&r" ((p)[1]), "=c" ((p)[2]), "=d" ((p)[3]) : "0" (func), "2"(0)); }
+    : "=a" ((p)[0]), "=&r" ((p)[1]), "=c" ((p)[2]), "=d" ((p)[3]) : "0" (func), "2"(subFunc)); }
 
 #else
 
-#define x86_cpuid_MACRO(p, func) { \
+#define x86_cpuid_MACRO_2(p, func, subFunc) { \
   __asm__ __volatile__ ( \
     ASM_LN   "cpuid"               \
-    : "=a" ((p)[0]), "=b" ((p)[1]), "=c" ((p)[2]), "=d" ((p)[3]) : "0" (func), "2"(0)); }
+    : "=a" ((p)[0]), "=b" ((p)[1]), "=c" ((p)[2]), "=d" ((p)[3]) : "0" (func), "2"(subFunc)); }
 
 #endif
 
+#define x86_cpuid_MACRO(p, func)  x86_cpuid_MACRO_2(p, func, 0)
 
 void Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)
 {
   x86_cpuid_MACRO(p, func)
 }
 
+static
+void Z7_FASTCALL z7_x86_cpuid_subFunc(UInt32 p[4], UInt32 func, UInt32 subFunc)
+{
+  x86_cpuid_MACRO_2(p, func, subFunc)
+}
+
 
 Z7_NO_INLINE
 UInt32 Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void)
@@ -205,11 +211,39 @@ void __declspec(naked) Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)
   __asm   ret     0
 }
 
+static
+void __declspec(naked) Z7_FASTCALL z7_x86_cpuid_subFunc(UInt32 p[4], UInt32 func, UInt32 subFunc)
+{
+  UNUSED_VAR(p)
+  UNUSED_VAR(func)
+  UNUSED_VAR(subFunc)
+  __asm   push    ebx
+  __asm   push    edi
+  __asm   mov     edi, ecx    // p
+  __asm   mov     eax, edx    // func
+  __asm   mov     ecx, [esp + 12]  // subFunc
+  __asm   cpuid
+  __asm   mov     [edi     ], eax
+  __asm   mov     [edi +  4], ebx
+  __asm   mov     [edi +  8], ecx
+  __asm   mov     [edi + 12], edx
+  __asm   pop     edi
+  __asm   pop     ebx
+  __asm   ret     4
+}
+
 #else // MY_CPU_AMD64
 
     #if _MSC_VER >= 1600
       #include <intrin.h>
       #define MY_cpuidex  __cpuidex
+
+static
+void Z7_FASTCALL z7_x86_cpuid_subFunc(UInt32 p[4], UInt32 func, UInt32 subFunc)
+{
+  __cpuidex((int *)p, func, subFunc);
+}
+
     #else
 /*
  __cpuid (func == (0 or 7)) requires subfunction number in ECX.
@@ -219,7 +253,7 @@ void __declspec(naked) Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)
  We still can use __cpuid for low (func) values that don't require ECX,
  but __cpuid() in old MSVC will be incorrect for some func values: (func == 7).
  So here we use the hack for old MSVC to send (subFunction) in ECX register to cpuid instruction,
- where ECX value is first parameter for FASTCALL / NO_INLINE func,
+ where ECX value is first parameter for FASTCALL / NO_INLINE func.
  So the caller of MY_cpuidex_HACK() sets ECX as subFunction, and
  old MSVC for __cpuid() doesn't change ECX and cpuid instruction gets (subFunction) value.
  
@@ -233,6 +267,11 @@ Z7_NO_INLINE void Z7_FASTCALL MY_cpuidex_HACK(Int32 subFunction, Int32 func, Int
 }
       #define MY_cpuidex(info, func, func2)  MY_cpuidex_HACK(func2, func, info)
       #pragma message("======== MY_cpuidex_HACK WAS USED ========")
+static
+void Z7_FASTCALL z7_x86_cpuid_subFunc(UInt32 p[4], UInt32 func, UInt32 subFunc)
+{
+  MY_cpuidex_HACK(subFunc, func, (Int32 *)p);
+}
     #endif // _MSC_VER >= 1600
 
 #if !defined(MY_CPU_AMD64)
@@ -445,6 +484,23 @@ BoolInt CPU_IsSupported_SHA(void)
   }
 }
 
+
+BoolInt CPU_IsSupported_SHA512(void)
+{
+  if (!CPU_IsSupported_AVX2()) return False; // maybe CPU_IsSupported_AVX() is enough here
+
+  if (z7_x86_cpuid_GetMaxFunc() < 7)
+    return False;
+  {
+    UInt32 d[4];
+    z7_x86_cpuid_subFunc(d, 7, 0);
+    if (d[0] < 1) // d[0] - is max supported subleaf value
+      return False;
+    z7_x86_cpuid_subFunc(d, 7, 1);
+    return (BoolInt)(d[0]) & 1;
+  }
+}
+
 /*
 MSVC: _xgetbv() intrinsic is available since VS2010SP1.
    MSVC also defines (_XCR_XFEATURE_ENABLED_MASK) macro in
@@ -776,6 +832,18 @@ BoolInt CPU_IsSupported_NEON(void)
   return z7_sysctlbyname_Get_BoolInt("hw.optional.neon");
 }
 
+BoolInt CPU_IsSupported_SHA512(void)
+{
+  return z7_sysctlbyname_Get_BoolInt("hw.optional.armv8_2_sha512");
+}
+
+/*
+BoolInt CPU_IsSupported_SHA3(void)
+{
+  return z7_sysctlbyname_Get_BoolInt("hw.optional.armv8_2_sha3");
+}
+*/
+
 #ifdef MY_CPU_ARM64
 #define APPLE_CRYPTO_SUPPORT_VAL 1
 #else
@@ -860,6 +928,19 @@ MY_HWCAP_CHECK_FUNC (CRC32)
 MY_HWCAP_CHECK_FUNC (SHA1)
 MY_HWCAP_CHECK_FUNC (SHA2)
 MY_HWCAP_CHECK_FUNC (AES)
+#ifdef MY_CPU_ARM64
+// <hwcap.h> supports HWCAP_SHA512 and HWCAP_SHA3 since 2017.
+// we define them here, if they are not defined
+#ifndef HWCAP_SHA3
+// #define HWCAP_SHA3    (1 << 17)
+#endif
+#ifndef HWCAP_SHA512
+// #pragma message("=== HWCAP_SHA512 define === ")
+#define HWCAP_SHA512  (1 << 21)
+#endif
+MY_HWCAP_CHECK_FUNC (SHA512)
+// MY_HWCAP_CHECK_FUNC (SHA3)
+#endif
 
 #endif // __APPLE__
 #endif // _WIN32
diff --git a/C/CpuArch.h b/C/CpuArch.h
index 683cfaa..1690a5b 100644
--- a/C/CpuArch.h
+++ b/C/CpuArch.h
@@ -1,5 +1,5 @@
 /* CpuArch.h -- CPU specific code
-2024-06-17 : Igor Pavlov : Public domain */
+Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_CPU_ARCH_H
 #define ZIP7_INC_CPU_ARCH_H
@@ -47,6 +47,12 @@ MY_CPU_64BIT means that processor can work with 64-bit registers.
   #define MY_CPU_SIZEOF_POINTER 4
 #endif
 
+#if defined(__SSE2__) \
+    || defined(MY_CPU_AMD64) \
+    || defined(_M_IX86_FP) && (_M_IX86_FP >= 2)
+#define MY_CPU_SSE2
+#endif
+
 
 #if  defined(_M_ARM64) \
   || defined(_M_ARM64EC) \
@@ -509,11 +515,19 @@ problem-4 : performace:
 
 #if defined(MY_CPU_LE_UNALIGN) && defined(Z7_CPU_FAST_BSWAP_SUPPORTED)
 
+#if 0
+// Z7_BSWAP16 can be slow for x86-msvc
+#define GetBe16_to32(p)  (Z7_BSWAP16 (*(const UInt16 *)(const void *)(p)))
+#else
+#define GetBe16_to32(p)  (Z7_BSWAP32 (*(const UInt16 *)(const void *)(p)) >> 16)
+#endif
+
 #define GetBe32(p)  Z7_BSWAP32 (*(const UInt32 *)(const void *)(p))
 #define SetBe32(p, v) { (*(UInt32 *)(void *)(p)) = Z7_BSWAP32(v); }
 
 #if defined(MY_CPU_LE_UNALIGN_64)
 #define GetBe64(p)  Z7_BSWAP64 (*(const UInt64 *)(const void *)(p))
+#define SetBe64(p, v) { (*(UInt64 *)(void *)(p)) = Z7_BSWAP64(v); }
 #endif
 
 #else
@@ -536,21 +550,39 @@ problem-4 : performace:
 #define GetBe64(p) (((UInt64)GetBe32(p) << 32) | GetBe32(((const Byte *)(p)) + 4))
 #endif
 
+#ifndef SetBe64
+#define SetBe64(p, v) { Byte *_ppp_ = (Byte *)(p); UInt64 _vvv_ = (v); \
+    _ppp_[0] = (Byte)(_vvv_ >> 56); \
+    _ppp_[1] = (Byte)(_vvv_ >> 48); \
+    _ppp_[2] = (Byte)(_vvv_ >> 40); \
+    _ppp_[3] = (Byte)(_vvv_ >> 32); \
+    _ppp_[4] = (Byte)(_vvv_ >> 24); \
+    _ppp_[5] = (Byte)(_vvv_ >> 16); \
+    _ppp_[6] = (Byte)(_vvv_ >> 8); \
+    _ppp_[7] = (Byte)_vvv_; }
+#endif
+
 #ifndef GetBe16
+#ifdef GetBe16_to32
+#define GetBe16(p) ( (UInt16) GetBe16_to32(p))
+#else
 #define GetBe16(p) ( (UInt16) ( \
     ((UInt16)((const Byte *)(p))[0] << 8) | \
              ((const Byte *)(p))[1] ))
 #endif
+#endif
 
 
 #if defined(MY_CPU_BE)
 #define Z7_CONV_BE_TO_NATIVE_CONST32(v)  (v)
 #define Z7_CONV_LE_TO_NATIVE_CONST32(v)  Z7_BSWAP32_CONST(v)
 #define Z7_CONV_NATIVE_TO_BE_32(v)       (v)
+// #define Z7_GET_NATIVE16_FROM_2_BYTES(b0, b1)  ((b1) | ((b0) << 8))
 #elif defined(MY_CPU_LE)
 #define Z7_CONV_BE_TO_NATIVE_CONST32(v)  Z7_BSWAP32_CONST(v)
 #define Z7_CONV_LE_TO_NATIVE_CONST32(v)  (v)
 #define Z7_CONV_NATIVE_TO_BE_32(v)       Z7_BSWAP32(v)
+// #define Z7_GET_NATIVE16_FROM_2_BYTES(b0, b1)  ((b0) | ((b1) << 8))
 #else
 #error Stop_Compiling_Unknown_Endian_CONV
 #endif
@@ -589,6 +621,11 @@ problem-4 : performace:
 #endif
 
 
+#ifndef GetBe16_to32
+#define GetBe16_to32(p) GetBe16(p)
+#endif
+
+
 #if defined(MY_CPU_X86_OR_AMD64) \
   || defined(MY_CPU_ARM_OR_ARM64) \
   || defined(MY_CPU_PPC_OR_PPC64)
@@ -617,6 +654,7 @@ BoolInt CPU_IsSupported_SSE2(void);
 BoolInt CPU_IsSupported_SSSE3(void);
 BoolInt CPU_IsSupported_SSE41(void);
 BoolInt CPU_IsSupported_SHA(void);
+BoolInt CPU_IsSupported_SHA512(void);
 BoolInt CPU_IsSupported_PageGB(void);
 
 #elif defined(MY_CPU_ARM_OR_ARM64)
@@ -634,6 +672,7 @@ BoolInt CPU_IsSupported_SHA1(void);
 BoolInt CPU_IsSupported_SHA2(void);
 BoolInt CPU_IsSupported_AES(void);
 #endif
+BoolInt CPU_IsSupported_SHA512(void);
 
 #endif
 
diff --git a/C/HuffEnc.c b/C/HuffEnc.c
index 996da30..cbf8c22 100644
--- a/C/HuffEnc.c
+++ b/C/HuffEnc.c
@@ -1,60 +1,125 @@
 /* HuffEnc.c -- functions for Huffman encoding
-2023-09-07 : Igor Pavlov : Public domain */
+Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
+#include <string.h>
+
 #include "HuffEnc.h"
 #include "Sort.h"
+#include "CpuArch.h"
 
-#define kMaxLen 16
-#define NUM_BITS 10
-#define MASK ((1u << NUM_BITS) - 1)
-
-#define NUM_COUNTERS 64
+#define kMaxLen       Z7_HUFFMAN_LEN_MAX
+#define NUM_BITS      10
+#define MASK          ((1u << NUM_BITS) - 1)
+#define FREQ_MASK     (~(UInt32)MASK)
+#define NUM_COUNTERS  (48 * 2)
 
-#define HUFFMAN_SPEED_OPT
+#if 1 && (defined(MY_CPU_LE) || defined(MY_CPU_BE))
+#if defined(MY_CPU_LE)
+  #define HI_HALF_OFFSET 1
+#else
+  #define HI_HALF_OFFSET 0
+#endif
+#define LOAD_PARENT(p)                  ((unsigned)*((const UInt16 *)(p) + HI_HALF_OFFSET))
+#define STORE_PARENT(p, fb, val)         *((UInt16 *)(p) + HI_HALF_OFFSET) = (UInt16)(val);
+#define STORE_PARENT_DIRECT(p, fb, hi)  STORE_PARENT(p, fb, hi)
+#define UPDATE_E(eHi)                   eHi++;
+#else
+#define LOAD_PARENT(p)                  ((unsigned)(*(p) >> NUM_BITS))
+#define STORE_PARENT_DIRECT(p, fb, hi)  *(p) = ((fb) & MASK) | (hi); // set parent field
+#define STORE_PARENT(p, fb, val)        STORE_PARENT_DIRECT(p, fb, ((UInt32)(val) << NUM_BITS))
+#define UPDATE_E(eHi)                   eHi += 1 << NUM_BITS;
+#endif
 
-void Huffman_Generate(const UInt32 *freqs, UInt32 *p, Byte *lens, UInt32 numSymbols, UInt32 maxLen)
+void Huffman_Generate(const UInt32 *freqs, UInt32 *p, Byte *lens, unsigned numSymbols, unsigned maxLen)
 {
-  UInt32 num = 0;
-  /* if (maxLen > 10) maxLen = 10; */
+#if NUM_COUNTERS > 2
+  unsigned counters[NUM_COUNTERS];
+#endif
+#if 1 && NUM_COUNTERS > (kMaxLen + 4) * 2
+  #define lenCounters   (counters)
+  #define codes         (counters + kMaxLen + 4)
+#else
+  unsigned lenCounters[kMaxLen + 1];
+  UInt32 codes[kMaxLen + 1];
+#endif
+
+  unsigned num;
   {
-    UInt32 i;
-    
-    #ifdef HUFFMAN_SPEED_OPT
+    unsigned i;
+    // UInt32 sum = 0;
+
+#if NUM_COUNTERS > 2
     
-    UInt32 counters[NUM_COUNTERS];
+#define CTR_ITEM_FOR_FREQ(freq) \
+    counters[(freq) >= NUM_COUNTERS - 1 ? NUM_COUNTERS - 1 : (unsigned)(freq)]
+
     for (i = 0; i < NUM_COUNTERS; i++)
       counters[i] = 0;
-    for (i = 0; i < numSymbols; i++)
+    memset(lens, 0, numSymbols);
     {
-      UInt32 freq = freqs[i];
-      counters[(freq < NUM_COUNTERS - 1) ? freq : NUM_COUNTERS - 1]++;
+      const UInt32 *fp = freqs + numSymbols;
+#define NUM_UNROLLS 1
+#if NUM_UNROLLS > 1 // use 1 if odd (numSymbols) is possisble
+      if (numSymbols & 1)
+      {
+        UInt32 f;
+        f = *--fp;  CTR_ITEM_FOR_FREQ(f)++;
+        // sum += f;
+      }
+#endif
+      do
+      {
+        UInt32 f;
+        fp -= NUM_UNROLLS;
+        f = fp[0];  CTR_ITEM_FOR_FREQ(f)++;
+        // sum += f;
+#if NUM_UNROLLS > 1
+        f = fp[1];  CTR_ITEM_FOR_FREQ(f)++;
+        // sum += f;
+#endif
+      }
+      while (fp != freqs);
     }
- 
-    for (i = 1; i < NUM_COUNTERS; i++)
+#if 0
+    printf("\nsum=%8u numSymbols =%3u ctrs:", sum, numSymbols);
     {
-      UInt32 temp = counters[i];
-      counters[i] = num;
-      num += temp;
+      unsigned k = 0;
+      for (k = 0; k < NUM_COUNTERS; k++)
+        printf(" %u", counters[k]);
     }
-
-    for (i = 0; i < numSymbols; i++)
+#endif
+        
+    num = counters[1];
+    counters[1] = 0;
+    for (i = 2; i != NUM_COUNTERS; i += 2)
     {
-      UInt32 freq = freqs[i];
-      if (freq == 0)
-        lens[i] = 0;
-      else
-        p[counters[((freq < NUM_COUNTERS - 1) ? freq : NUM_COUNTERS - 1)]++] = i | (freq << NUM_BITS);
+      unsigned c;
+      c = (counters    )[i];  (counters    )[i] = num;  num += c;
+      c = (counters + 1)[i];  (counters + 1)[i] = num;  num += c;
+    }
+    counters[0] = num; // we want to write (freq==0) symbols to the end of (p) array
+    {
+      i = 0;
+      do
+      {
+        const UInt32 f = freqs[i];
+#if 0
+        if (f == 0) lens[i] = 0; else
+#endif
+          p[CTR_ITEM_FOR_FREQ(f)++] = i | (f << NUM_BITS);
+      }
+      while (++i != numSymbols);
     }
-    counters[0] = 0;
     HeapSort(p + counters[NUM_COUNTERS - 2], counters[NUM_COUNTERS - 1] - counters[NUM_COUNTERS - 2]);
     
-    #else
-
+#else // NUM_COUNTERS <= 2
+    
+    num = 0;
     for (i = 0; i < numSymbols; i++)
     {
-      UInt32 freq = freqs[i];
+      const UInt32 freq = freqs[i];
       if (freq == 0)
         lens[i] = 0;
       else
@@ -62,17 +127,27 @@ void Huffman_Generate(const UInt32 *freqs, UInt32 *p, Byte *lens, UInt32 numSymb
     }
     HeapSort(p, num);
 
-    #endif
+#endif
   }
 
-  if (num < 2)
+  if (num <= 2)
   {
     unsigned minCode = 0;
     unsigned maxCode = 1;
-    if (num == 1)
+    if (num)
     {
-      maxCode = (unsigned)p[0] & MASK;
-      if (maxCode == 0)
+      maxCode = (unsigned)p[(size_t)num - 1] & MASK;
+      if (num == 2)
+      {
+        minCode = (unsigned)p[0] & MASK;
+        if (minCode > maxCode)
+        {
+          const unsigned temp = minCode;
+          minCode = maxCode;
+          maxCode = temp;
+        }
+      }
+      else if (maxCode == 0)
         maxCode++;
     }
     p[minCode] = 0;
@@ -80,69 +155,191 @@ void Huffman_Generate(const UInt32 *freqs, UInt32 *p, Byte *lens, UInt32 numSymb
     lens[minCode] = lens[maxCode] = 1;
     return;
   }
-  
   {
-    UInt32 b, e, i;
-  
-    i = b = e = 0;
-    do
+    unsigned i;
+    for (i = 0; i <= kMaxLen; i++)
+      lenCounters[i] = 0;
+    lenCounters[1] = 2;  // by default root node has 2 child leaves at level 1.
+  }
+  // if (num != 2)
+  {
+    // num > 2
+    // the binary tree will contain (num - 1) internal nodes.
+    // p[num - 2] will be root node of binary tree.
+    UInt32 *b;
+    UInt32 *n;
+    // first node will have two leaf childs: p[0] and p[1]:
+    // p[0] += p[1] & FREQ_MASK; // set frequency sum of child leafs
+    // if (pi == n) exit(0);
+    // if (pi != n)
     {
-      UInt32 n, m, freq;
-      n = (i != num && (b == e || (p[i] >> NUM_BITS) <= (p[b] >> NUM_BITS))) ? i++ : b++;
-      freq = (p[n] & ~MASK);
-      p[n] = (p[n] & MASK) | (e << NUM_BITS);
-      m = (i != num && (b == e || (p[i] >> NUM_BITS) <= (p[b] >> NUM_BITS))) ? i++ : b++;
-      freq += (p[m] & ~MASK);
-      p[m] = (p[m] & MASK) | (e << NUM_BITS);
-      p[e] = (p[e] & MASK) | freq;
-      e++;
+      UInt32 fb = (p[1] & FREQ_MASK) + p[0];
+      UInt32 f = p[2] & FREQ_MASK;
+      const UInt32 *pi = p + 2;
+      UInt32 *e = p;
+      UInt32 eHi = 0;
+      n = p + num;
+      b = p;
+      // p[0] = fb;
+      for (;;)
+      {
+        // (b <= e)
+        UInt32 sum;
+        e++;
+        UPDATE_E(eHi)
+
+        // (b < e)
+
+        // p range : high bits
+        // [0, b)  : parent :     processed nodes that have parent and childs
+        // [b, e)  : FREQ   : non-processed nodes that have no parent but have childs
+        // [e, pi) : FREQ   :     processed leaves for which parent node was     created
+        // [pi, n) : FREQ   : non-processed leaves for which parent node was not created
+
+        // first child
+        // note : (*b < f) is same result as ((*b & FREQ_MASK) < f)
+        if (fb < f)
+        {
+          // node freq is smaller
+          sum = fb & FREQ_MASK;
+          STORE_PARENT_DIRECT (b, fb, eHi)
+          b++;
+          fb = *b;
+          if (b == e)
+          {
+            if (++pi == n)
+              break;
+            sum += f;
+            fb &= MASK;
+            fb |= sum;
+            *e = fb;
+            f = *pi & FREQ_MASK;
+            continue;
+          }
+        }
+        else if (++pi == n)
+        {
+          STORE_PARENT_DIRECT (b, fb, eHi)
+          b++;
+          break;
+        }
+        else
+        {
+          sum = f;
+          f = *pi & FREQ_MASK;
+        }
+
+        // (b < e)
+
+        // second child
+        if (fb < f)
+        {
+          sum += fb;
+          sum &= FREQ_MASK;
+          STORE_PARENT_DIRECT (b, fb, eHi)
+          b++;
+          *e = (*e & MASK) | sum; // set frequency sum
+          // (b <= e) is possible here
+          fb = *b;
+        }
+        else if (++pi == n)
+          break;
+        else
+        {
+          sum += f;
+          f = *pi & FREQ_MASK;
+          *e = (*e & MASK) | sum; // set frequency sum
+        }
+      }
     }
-    while (num - e > 1);
     
+    // printf("\nnum-e=%3u, numSymbols=%3u, num=%3u, b=%3u", n - e, numSymbols, n - p, b - p);
     {
-      UInt32 lenCounters[kMaxLen + 1];
-      for (i = 0; i <= kMaxLen; i++)
-        lenCounters[i] = 0;
-      
-      p[--e] &= MASK;
-      lenCounters[1] = 2;
-      while (e != 0)
-      {
-        UInt32 len = (p[p[--e] >> NUM_BITS] >> NUM_BITS) + 1;
-        p[e] = (p[e] & MASK) | (len << NUM_BITS);
-        if (len >= maxLen)
-          for (len = maxLen - 1; lenCounters[len] == 0; len--);
-        lenCounters[len]--;
-        lenCounters[(size_t)len + 1] += 2;
-      }
-      
+      n -= 2;
+      *n &= MASK; // root node : we clear high bits (zero bits mean level == 0)
+      if (n != b)
       {
-        UInt32 len;
-        i = 0;
-        for (len = maxLen; len != 0; len--)
+        // We go here, if we have some number of non-created nodes up to root.
+        // We process them in simplified code:
+        // position of parent for each pair of nodes is known.
+        // n[-2], n[-1] : current pair of child nodes
+        // (p1) : parent node for current pair.
+        UInt32 *p1 = n;
+        do
         {
-          UInt32 k;
-          for (k = lenCounters[len]; k != 0; k--)
-            lens[p[i++] & MASK] = (Byte)len;
+          const unsigned len = LOAD_PARENT(p1) + 1;
+          p1--;
+          (lenCounters    )[len] -= 2;                  // we remove 2 leaves from level (len)
+          (lenCounters + 1)[len] += 2 * 2;  // we add 4 leaves at level (len + 1)
+          n -= 2;
+          STORE_PARENT (n    , n[0], len)
+          STORE_PARENT (n + 1, n[1], len)
         }
+        while (n != b);
       }
-      
+    }
+    
+    if (b != p)
+    {
+      // we detect level of each node (realtive to root),
+      // and update lenCounters[].
+      // We process only intermediate nodes and we don't process leaves.
+      do
       {
-        UInt32 nextCodes[kMaxLen + 1];
-        {
-          UInt32 code = 0;
-          UInt32 len;
-          for (len = 1; len <= kMaxLen; len++)
-            nextCodes[len] = code = (code + lenCounters[(size_t)len - 1]) << 1;
-        }
-        /* if (code + lenCounters[kMaxLen] - 1 != (1 << kMaxLen) - 1) throw 1; */
-
+        // if (ii <  b) : parent_bits_of (p[ii]) == index of parent node : ii < (p[ii])
+        // if (ii >= b) : parent_bits_of (p[ii]) == level of this (ii) node in tree
+        unsigned len;
+        b--;
+        len = (unsigned)LOAD_PARENT(p + LOAD_PARENT(b)) + 1;
+        STORE_PARENT (b, *b, len)
+        if (len >= maxLen)
         {
-          UInt32 k;
-          for (k = 0; k < numSymbols; k++)
-            p[k] = nextCodes[lens[k]]++;
+          // We are not allowed to create node at level (maxLen) and higher,
+          // because all leaves must be placed to level (maxLen) or lower.
+          // We find nearest allowed leaf and place current node to level of that leaf:
+          for (len = maxLen - 1; lenCounters[len] == 0; len--) {}
         }
+        lenCounters[len]--;                 // we remove 1 leaf from level (len)
+        (lenCounters + 1)[len] += 2;  // we add 2 leaves at level (len + 1)
+      }
+      while (b != p);
+    }
+  }
+  {
+    {
+      unsigned len = maxLen;
+      const UInt32 *p2 = p;
+      do
+      {
+        unsigned k = lenCounters[len];
+        if (k)
+          do
+            lens[(unsigned)*p2++ & MASK] = (Byte)len;
+          while (--k);
+      }
+      while (--len);
+    }
+    codes[0] = 0; // we don't want garbage values to be written to p[] array.
+    // codes[1] = 0;
+    {
+      UInt32 code = 0;
+      unsigned len;
+      for (len = 0; len < kMaxLen; len++)
+        (codes + 1)[len] = code = (code + lenCounters[len]) << 1;
+    }
+    /* if (code + lenCounters[kMaxLen] - 1 != (1 << kMaxLen) - 1) throw 1; */
+    {
+      const Byte * const limit = lens + numSymbols;
+      do
+      {
+        unsigned len;
+        UInt32 c;
+        len = lens[0];  c = codes[len];  p[0] = c;  codes[len] = c + 1;
+        // len = lens[1];  c = codes[len];  p[1] = c;  codes[len] = c + 1;
+        p += 1;
+        lens += 1;
       }
+      while (lens != limit);
     }
   }
 }
@@ -150,5 +347,14 @@ void Huffman_Generate(const UInt32 *freqs, UInt32 *p, Byte *lens, UInt32 numSymb
 #undef kMaxLen
 #undef NUM_BITS
 #undef MASK
+#undef FREQ_MASK
 #undef NUM_COUNTERS
-#undef HUFFMAN_SPEED_OPT
+#undef CTR_ITEM_FOR_FREQ
+#undef LOAD_PARENT
+#undef STORE_PARENT
+#undef STORE_PARENT_DIRECT
+#undef UPDATE_E
+#undef HI_HALF_OFFSET
+#undef NUM_UNROLLS
+#undef lenCounters
+#undef codes
diff --git a/C/HuffEnc.h b/C/HuffEnc.h
index cbc5d11..2217f55 100644
--- a/C/HuffEnc.h
+++ b/C/HuffEnc.h
@@ -1,5 +1,5 @@
 /* HuffEnc.h -- Huffman encoding
-2023-03-05 : Igor Pavlov : Public domain */
+Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_HUFF_ENC_H
 #define ZIP7_INC_HUFF_ENC_H
@@ -8,14 +8,14 @@
 
 EXTERN_C_BEGIN
 
+#define Z7_HUFFMAN_LEN_MAX 16
 /*
 Conditions:
-  num <= 1024 = 2 ^ NUM_BITS
+  2 <= num <= 1024 = 2 ^ NUM_BITS
   Sum(freqs) < 4M = 2 ^ (32 - NUM_BITS)
-  maxLen <= 16 = kMaxLen
+  1 <= maxLen <= 16 = Z7_HUFFMAN_LEN_MAX
   Num_Items(p) >= HUFFMAN_TEMP_SIZE(num)
 */
- 
 void Huffman_Generate(const UInt32 *freqs, UInt32 *p, Byte *lens, UInt32 num, UInt32 maxLen);
 
 EXTERN_C_END
diff --git a/C/LzFind.c b/C/LzFind.c
index 1ce4046..330bc17 100644
--- a/C/LzFind.c
+++ b/C/LzFind.c
@@ -1,5 +1,5 @@
 /* LzFind.c -- Match finder for LZ algorithms
-2024-03-01 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -404,7 +404,7 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
         const unsigned nbMax =
             (p->numHashBytes == 2 ? 16 :
             (p->numHashBytes == 3 ? 24 : 32));
-        if (numBits > nbMax)
+        if (numBits >= nbMax)
           numBits = nbMax;
         if (numBits >= 32)
           hs = (UInt32)0 - 1;
@@ -416,14 +416,14 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
           hs |= (256 << kLzHash_CrcShift_2) - 1;
         {
           const UInt32 hs2 = MatchFinder_GetHashMask2(p, historySize);
-          if (hs > hs2)
+          if (hs >= hs2)
             hs = hs2;
         }
         hsCur = hs;
         if (p->expectedDataSize < historySize)
         {
           const UInt32 hs2 = MatchFinder_GetHashMask2(p, (UInt32)p->expectedDataSize);
-          if (hsCur > hs2)
+          if (hsCur >= hs2)
             hsCur = hs2;
         }
       }
@@ -434,7 +434,7 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
         if (p->expectedDataSize < historySize)
         {
           hsCur = MatchFinder_GetHashMask(p, (UInt32)p->expectedDataSize);
-          if (hsCur > hs) // is it possible?
+          if (hsCur >= hs) // is it possible?
             hsCur = hs;
         }
       }
@@ -598,7 +598,7 @@ void MatchFinder_Init(void *_p)
 
 #ifdef MY_CPU_X86_OR_AMD64
   #if defined(__clang__) && (__clang_major__ >= 4) \
-    || defined(Z7_GCC_VERSION) && (Z7_GCC_VERSION >= 40701)
+    || defined(Z7_GCC_VERSION) && (Z7_GCC_VERSION >= 40900)
     // || defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1900)
 
       #define USE_LZFIND_SATUR_SUB_128
@@ -890,7 +890,7 @@ static UInt32 * Hc_GetMatchesSpec(size_t lenLimit, UInt32 curMatch, UInt32 pos,
       return d;
     {
       const Byte *pb = cur - delta;
-      curMatch = son[_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)];
+      curMatch = son[_cyclicBufferPos - delta + (_cyclicBufferPos < delta ? _cyclicBufferSize : 0)];
       if (pb[maxLen] == cur[maxLen] && *pb == *cur)
       {
         UInt32 len = 0;
@@ -925,7 +925,7 @@ static UInt32 * Hc_GetMatchesSpec(size_t lenLimit, UInt32 curMatch, UInt32 pos,
       break;
     {
       ptrdiff_t diff;
-      curMatch = son[_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)];
+      curMatch = son[_cyclicBufferPos - delta + (_cyclicBufferPos < delta ? _cyclicBufferSize : 0)];
       diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
       if (cur[maxLen] == cur[(ptrdiff_t)maxLen + diff])
       {
@@ -972,7 +972,7 @@ UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byt
   // if (curMatch >= pos) { *ptr0 = *ptr1 = kEmptyHashValue; return NULL; }
 
   cmCheck = (UInt32)(pos - _cyclicBufferSize);
-  if ((UInt32)pos <= _cyclicBufferSize)
+  if ((UInt32)pos < _cyclicBufferSize)
     cmCheck = 0;
 
   if (cmCheck < curMatch)
@@ -980,7 +980,7 @@ UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byt
   {
     const UInt32 delta = pos - curMatch;
     {
-      CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1);
+      CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + (_cyclicBufferPos < delta ? _cyclicBufferSize : 0)) << 1);
       const Byte *pb = cur - delta;
       unsigned len = (len0 < len1 ? len0 : len1);
       const UInt32 pair0 = pair[0];
@@ -1039,7 +1039,7 @@ static void SkipMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const
   UInt32 cmCheck;
 
   cmCheck = (UInt32)(pos - _cyclicBufferSize);
-  if ((UInt32)pos <= _cyclicBufferSize)
+  if ((UInt32)pos < _cyclicBufferSize)
     cmCheck = 0;
 
   if (// curMatch >= pos ||  // failure
@@ -1048,7 +1048,7 @@ static void SkipMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const
   {
     const UInt32 delta = pos - curMatch;
     {
-      CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1);
+      CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + (_cyclicBufferPos < delta ? _cyclicBufferSize : 0)) << 1);
       const Byte *pb = cur - delta;
       unsigned len = (len0 < len1 ? len0 : len1);
       if (pb[len] == cur[len])
@@ -1595,7 +1595,7 @@ static void Bt5_MatchFinder_Skip(void *_p, UInt32 num)
     UInt32 pos = p->pos; \
     UInt32 num2 = num; \
     /* (p->pos == p->posLimit) is not allowed here !!! */ \
-    { const UInt32 rem = p->posLimit - pos; if (num2 > rem) num2 = rem; } \
+    { const UInt32 rem = p->posLimit - pos; if (num2 >= rem) num2 = rem; } \
     num -= num2; \
     { const UInt32 cycPos = p->cyclicBufferPos; \
       son = p->son + cycPos; \
diff --git a/C/LzFindMt.c b/C/LzFindMt.c
index ac9d59d..25fcc46 100644
--- a/C/LzFindMt.c
+++ b/C/LzFindMt.c
@@ -1,5 +1,5 @@
 /* LzFindMt.c -- multithreaded Match finder for LZ algorithms
-2024-01-22 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -82,6 +82,8 @@ extern UInt64 g_NumIters_Bytes;
 Z7_NO_INLINE
 static void MtSync_Construct(CMtSync *p)
 {
+  p->affinityGroup = -1;
+  p->affinityInGroup = 0;
   p->affinity = 0;
   p->wasCreated = False;
   p->csWasInitialized = False;
@@ -259,6 +261,12 @@ static WRes MtSync_Create_WRes(CMtSync *p, THREAD_FUNC_TYPE startAddress, void *
   // return ERROR_TOO_MANY_POSTS; // for debug
   // return EINVAL; // for debug
 
+#ifdef _WIN32
+  if (p->affinityGroup >= 0)
+    wres = Thread_Create_With_Group(&p->thread, startAddress, obj,
+        (unsigned)(UInt32)p->affinityGroup, (CAffinityMask)p->affinityInGroup);
+  else
+#endif
   if (p->affinity != 0)
     wres = Thread_Create_With_Affinity(&p->thread, startAddress, obj, (CAffinityMask)p->affinity);
   else
diff --git a/C/LzFindMt.h b/C/LzFindMt.h
index fcb479d..89984f5 100644
--- a/C/LzFindMt.h
+++ b/C/LzFindMt.h
@@ -1,5 +1,5 @@
 /* LzFindMt.h -- multithreaded Match finder for LZ algorithms
-2024-01-22 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_LZ_FIND_MT_H
 #define ZIP7_INC_LZ_FIND_MT_H
@@ -12,8 +12,10 @@ EXTERN_C_BEGIN
 typedef struct
 {
   UInt32 numProcessedBlocks;
-  CThread thread;
+  Int32 affinityGroup;
+  UInt64 affinityInGroup;
   UInt64 affinity;
+  CThread thread;
 
   BoolInt wasCreated;
   BoolInt needStart;
diff --git a/C/Lzma2Enc.c b/C/Lzma2Enc.c
index 703e146..72aec69 100644
--- a/C/Lzma2Enc.c
+++ b/C/Lzma2Enc.c
@@ -1,5 +1,5 @@
 /* Lzma2Enc.c -- LZMA2 Encoder
-2023-04-13 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -235,6 +235,7 @@ void Lzma2EncProps_Init(CLzma2EncProps *p)
   p->numBlockThreads_Reduced = -1;
   p->numBlockThreads_Max = -1;
   p->numTotalThreads = -1;
+  p->numThreadGroups = 0;
 }
 
 void Lzma2EncProps_Normalize(CLzma2EncProps *p)
@@ -781,6 +782,7 @@ SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
     }
 
     p->mtCoder.numThreadsMax = (unsigned)p->props.numBlockThreads_Max;
+    p->mtCoder.numThreadGroups = p->props.numThreadGroups;
     p->mtCoder.expectedDataSize = p->expectedDataSize;
     
     {
diff --git a/C/Lzma2Enc.h b/C/Lzma2Enc.h
index cb25275..1e6b50c 100644
--- a/C/Lzma2Enc.h
+++ b/C/Lzma2Enc.h
@@ -18,6 +18,7 @@ typedef struct
   int numBlockThreads_Reduced;
   int numBlockThreads_Max;
   int numTotalThreads;
+  unsigned numThreadGroups; // 0 : no groups
 } CLzma2EncProps;
 
 void Lzma2EncProps_Init(CLzma2EncProps *p);
diff --git a/C/LzmaEnc.c b/C/LzmaEnc.c
index 37b2787..84a29a5 100644
--- a/C/LzmaEnc.c
+++ b/C/LzmaEnc.c
@@ -1,5 +1,5 @@
 /* LzmaEnc.c -- LZMA Encoder
-2024-01-24: Igor Pavlov : Public domain */
+Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -62,7 +62,9 @@ void LzmaEncProps_Init(CLzmaEncProps *p)
   p->lc = p->lp = p->pb = p->algo = p->fb = p->btMode = p->numHashBytes = p->numThreads = -1;
   p->numHashOutBits = 0;
   p->writeEndMark = 0;
+  p->affinityGroup = -1;
   p->affinity = 0;
+  p->affinityInGroup = 0;
 }
 
 void LzmaEncProps_Normalize(CLzmaEncProps *p)
@@ -72,11 +74,11 @@ void LzmaEncProps_Normalize(CLzmaEncProps *p)
   p->level = level;
   
   if (p->dictSize == 0)
-    p->dictSize =
-      ( level <= 3 ? ((UInt32)1 << (level * 2 + 16)) :
-      ( level <= 6 ? ((UInt32)1 << (level + 19)) :
-      ( level <= 7 ? ((UInt32)1 << 25) : ((UInt32)1 << 26)
-      )));
+    p->dictSize = (unsigned)level <= 4 ?
+        (UInt32)1 << (level * 2 + 16) :
+        (unsigned)level <= sizeof(size_t) / 2 + 4 ?
+          (UInt32)1 << (level + 20) :
+          (UInt32)1 << (sizeof(size_t) / 2 + 24);
 
   if (p->dictSize > p->reduceSize)
   {
@@ -92,8 +94,8 @@ void LzmaEncProps_Normalize(CLzmaEncProps *p)
   if (p->lp < 0) p->lp = 0;
   if (p->pb < 0) p->pb = 2;
 
-  if (p->algo < 0) p->algo = (level < 5 ? 0 : 1);
-  if (p->fb < 0) p->fb = (level < 7 ? 32 : 64);
+  if (p->algo < 0) p->algo = (unsigned)level < 5 ? 0 : 1;
+  if (p->fb < 0) p->fb = (unsigned)level < 7 ? 32 : 64;
   if (p->btMode < 0) p->btMode = (p->algo == 0 ? 0 : 1);
   if (p->numHashBytes < 0) p->numHashBytes = (p->btMode ? 4 : 5);
   if (p->mc == 0) p->mc = (16 + ((unsigned)p->fb >> 1)) >> (p->btMode ? 0 : 1);
@@ -598,6 +600,10 @@ SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props2)
   p->multiThread = (props.numThreads > 1);
   p->matchFinderMt.btSync.affinity =
   p->matchFinderMt.hashSync.affinity = props.affinity;
+  p->matchFinderMt.btSync.affinityGroup =
+  p->matchFinderMt.hashSync.affinityGroup = props.affinityGroup;
+  p->matchFinderMt.btSync.affinityInGroup =
+  p->matchFinderMt.hashSync.affinityInGroup = props.affinityInGroup;
   #endif
 
   return SZ_OK;
diff --git a/C/LzmaEnc.h b/C/LzmaEnc.h
index 9f8039a..3feb5b4 100644
--- a/C/LzmaEnc.h
+++ b/C/LzmaEnc.h
@@ -1,5 +1,5 @@
 /*  LzmaEnc.h -- LZMA Encoder
-2023-04-13 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_LZMA_ENC_H
 #define ZIP7_INC_LZMA_ENC_H
@@ -29,11 +29,13 @@ typedef struct
   int numThreads;  /* 1 or 2, default = 2 */
 
   // int _pad;
+  Int32 affinityGroup;
 
   UInt64 reduceSize; /* estimated size of data that will be compressed. default = (UInt64)(Int64)-1.
                         Encoder uses this value to reduce dictionary size */
 
   UInt64 affinity;
+  UInt64 affinityInGroup;
 } CLzmaEncProps;
 
 void LzmaEncProps_Init(CLzmaEncProps *p);
diff --git a/C/Md5.c b/C/Md5.c
new file mode 100644
index 0000000..1b745d7
--- /dev/null
+++ b/C/Md5.c
@@ -0,0 +1,206 @@
+/* Md5.c -- MD5 Hash
+: Igor Pavlov : Public domain
+This code is based on Colin Plumb's public domain md5.c code */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "Md5.h"
+#include "RotateDefs.h"
+#include "CpuArch.h"
+
+#define MD5_UPDATE_BLOCKS(p) Md5_UpdateBlocks
+
+Z7_NO_INLINE
+void Md5_Init(CMd5 *p)
+{
+  p->count = 0;
+  p->state[0] = 0x67452301;
+  p->state[1] = 0xefcdab89;
+  p->state[2] = 0x98badcfe;
+  p->state[3] = 0x10325476;
+}
+
+#if 0 && !defined(MY_CPU_LE_UNALIGN)
+// optional optimization for Big-endian processors or processors without unaligned access:
+// it is intended to reduce the number of complex LE32 memory reading from 64 to 16.
+// But some compilers (sparc, armt) are better without this optimization.
+#define Z7_MD5_USE_DATA32_ARRAY
+#endif
+
+#define LOAD_DATA(i)  GetUi32((const UInt32 *)(const void *)data + (i))
+
+#ifdef Z7_MD5_USE_DATA32_ARRAY
+#define D(i)  data32[i]
+#else
+#define D(i)  LOAD_DATA(i)
+#endif
+
+#define F1(x, y, z)   (z ^ (x & (y ^ z)))
+#define F2(x, y, z)   F1(z, x, y)
+#define F3(x, y, z)   (x ^ y ^ z)
+#define F4(x, y, z)   (y ^ (x | ~z))
+
+#define R1(i, f, start, step, w, x, y, z, s, k) \
+    w += D((start + step * (i)) % 16) + k; \
+    w += f(x, y, z); \
+    w = rotlFixed(w, s) + x; \
+
+#define R4(i4,  f, start, step, s0,s1,s2,s3, k0,k1,k2,k3) \
+    R1 (i4*4+0, f, start, step, a,b,c,d, s0, k0) \
+    R1 (i4*4+1, f, start, step, d,a,b,c, s1, k1) \
+    R1 (i4*4+2, f, start, step, c,d,a,b, s2, k2) \
+    R1 (i4*4+3, f, start, step, b,c,d,a, s3, k3) \
+
+#define R16(f, start, step, s0,s1,s2,s3, k00,k01,k02,k03, k10,k11,k12,k13, k20,k21,k22,k23, k30,k31,k32,k33)  \
+    R4 (0,  f, start, step, s0,s1,s2,s3, k00,k01,k02,k03) \
+    R4 (1,  f, start, step, s0,s1,s2,s3, k10,k11,k12,k13) \
+    R4 (2,  f, start, step, s0,s1,s2,s3, k20,k21,k22,k23) \
+    R4 (3,  f, start, step, s0,s1,s2,s3, k30,k31,k32,k33) \
+
+static
+Z7_NO_INLINE
+void Z7_FASTCALL Md5_UpdateBlocks(UInt32 state[4], const Byte *data, size_t numBlocks)
+{
+  UInt32 a, b, c, d;
+  // if (numBlocks == 0) return;
+  a = state[0];
+  b = state[1];
+  c = state[2];
+  d = state[3];
+  do
+  {
+#ifdef Z7_MD5_USE_DATA32_ARRAY
+    UInt32 data32[MD5_NUM_BLOCK_WORDS];
+    {
+#define LOAD_data32_x4(i) { \
+      data32[i    ] = LOAD_DATA(i    ); \
+      data32[i + 1] = LOAD_DATA(i + 1); \
+      data32[i + 2] = LOAD_DATA(i + 2); \
+      data32[i + 3] = LOAD_DATA(i + 3); }
+#if 1
+      LOAD_data32_x4 (0 * 4)
+      LOAD_data32_x4 (1 * 4)
+      LOAD_data32_x4 (2 * 4)
+      LOAD_data32_x4 (3 * 4)
+#else
+      unsigned i;
+      for (i = 0; i < MD5_NUM_BLOCK_WORDS; i += 4)
+      {
+        LOAD_data32_x4(i)
+      }
+#endif
+    }
+#endif
+
+    R16 (F1, 0, 1,  7,12,17,22, 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
+                                0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
+                                0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
+                                0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821)
+    R16 (F2, 1, 5,  5, 9,14,20, 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
+                                0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
+                                0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
+                                0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a)
+    R16 (F3, 5, 3,  4,11,16,23, 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
+                                0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
+                                0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
+                                0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665)
+    R16 (F4, 0, 7,  6,10,15,21, 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
+                                0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
+                                0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
+                                0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391)
+
+    a += state[0];
+    b += state[1];
+    c += state[2];
+    d += state[3];
+    
+    state[0] = a;
+    state[1] = b;
+    state[2] = c;
+    state[3] = d;
+    
+    data += MD5_BLOCK_SIZE;
+  }
+  while (--numBlocks);
+}
+
+
+#define Md5_UpdateBlock(p) MD5_UPDATE_BLOCKS(p)(p->state, p->buffer, 1)
+
+void Md5_Update(CMd5 *p, const Byte *data, size_t size)
+{
+  if (size == 0)
+    return;
+  {
+    const unsigned pos = (unsigned)p->count & (MD5_BLOCK_SIZE - 1);
+    const unsigned num = MD5_BLOCK_SIZE - pos;
+    p->count += size;
+    if (num > size)
+    {
+      memcpy(p->buffer + pos, data, size);
+      return;
+    }
+    if (pos != 0)
+    {
+      size -= num;
+      memcpy(p->buffer + pos, data, num);
+      data += num;
+      Md5_UpdateBlock(p);
+    }
+  }
+  {
+    const size_t numBlocks = size >> 6;
+    if (numBlocks)
+    MD5_UPDATE_BLOCKS(p)(p->state, data, numBlocks);
+    size &= MD5_BLOCK_SIZE - 1;
+    if (size == 0)
+      return;
+    data += (numBlocks << 6);
+    memcpy(p->buffer, data, size);
+  }
+}
+
+
+void Md5_Final(CMd5 *p, Byte *digest)
+{
+  unsigned pos = (unsigned)p->count & (MD5_BLOCK_SIZE - 1);
+  p->buffer[pos++] = 0x80;
+  if (pos > (MD5_BLOCK_SIZE - 4 * 2))
+  {
+    while (pos != MD5_BLOCK_SIZE) { p->buffer[pos++] = 0; }
+    // memset(&p->buf.buffer[pos], 0, MD5_BLOCK_SIZE - pos);
+    Md5_UpdateBlock(p);
+    pos = 0;
+  }
+  memset(&p->buffer[pos], 0, (MD5_BLOCK_SIZE - 4 * 2) - pos);
+  {
+    const UInt64 numBits = p->count << 3;
+#if defined(MY_CPU_LE_UNALIGN)
+    SetUi64 (p->buffer + MD5_BLOCK_SIZE - 4 * 2, numBits)
+#else
+    SetUi32a(p->buffer + MD5_BLOCK_SIZE - 4 * 2, (UInt32)(numBits))
+    SetUi32a(p->buffer + MD5_BLOCK_SIZE - 4 * 1, (UInt32)(numBits >> 32))
+#endif
+  }
+  Md5_UpdateBlock(p);
+
+  SetUi32(digest,      p->state[0])
+  SetUi32(digest + 4,  p->state[1])
+  SetUi32(digest + 8,  p->state[2])
+  SetUi32(digest + 12, p->state[3])
+  
+  Md5_Init(p);
+}
+
+#undef R1
+#undef R4
+#undef R16
+#undef D
+#undef LOAD_DATA
+#undef LOAD_data32_x4
+#undef F1
+#undef F2
+#undef F3
+#undef F4
diff --git a/C/Md5.h b/C/Md5.h
new file mode 100644
index 0000000..49c0741
--- /dev/null
+++ b/C/Md5.h
@@ -0,0 +1,34 @@
+/* Md5.h -- MD5 Hash
+: Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_MD5_H
+#define ZIP7_INC_MD5_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define MD5_NUM_BLOCK_WORDS  16
+#define MD5_NUM_DIGEST_WORDS  4
+
+#define MD5_BLOCK_SIZE   (MD5_NUM_BLOCK_WORDS * 4)
+#define MD5_DIGEST_SIZE  (MD5_NUM_DIGEST_WORDS * 4)
+
+typedef struct
+{
+  UInt64 count;
+  UInt64 _pad_1;
+  // we want 16-bytes alignment here
+  UInt32 state[MD5_NUM_DIGEST_WORDS];
+  UInt64 _pad_2[4];
+  // we want 64-bytes alignment here
+  Byte buffer[MD5_BLOCK_SIZE];
+} CMd5;
+
+void Md5_Init(CMd5 *p);
+void Md5_Update(CMd5 *p, const Byte *data, size_t size);
+void Md5_Final(CMd5 *p, Byte *digest);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/MtCoder.c b/C/MtCoder.c
index 03959b6..923b19a 100644
--- a/C/MtCoder.c
+++ b/C/MtCoder.c
@@ -1,5 +1,5 @@
 /* MtCoder.c -- Multi-thread Coder
-2023-09-07 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -39,14 +39,28 @@ void MtProgressThunk_CreateVTable(CMtProgressThunk *p)
 static THREAD_FUNC_DECL ThreadFunc(void *pp);
 
 
-static SRes MtCoderThread_CreateAndStart(CMtCoderThread *t)
+static SRes MtCoderThread_CreateAndStart(CMtCoderThread *t
+#ifdef _WIN32
+    , CMtCoder * const mtc
+#endif
+    )
 {
   WRes wres = AutoResetEvent_OptCreate_And_Reset(&t->startEvent);
+  // printf("\n====== MtCoderThread_CreateAndStart : \n");
   if (wres == 0)
   {
     t->stop = False;
     if (!Thread_WasCreated(&t->thread))
-      wres = Thread_Create(&t->thread, ThreadFunc, t);
+    {
+#ifdef _WIN32
+      if (mtc->numThreadGroups)
+        wres = Thread_Create_With_Group(&t->thread, ThreadFunc, t,
+            ThreadNextGroup_GetNext(&mtc->nextGroup), // group
+            0); // affinityMask
+      else
+#endif
+        wres = Thread_Create(&t->thread, ThreadFunc, t);
+    }
     if (wres == 0)
       wres = Event_Set(&t->startEvent);
   }
@@ -56,6 +70,7 @@ static SRes MtCoderThread_CreateAndStart(CMtCoderThread *t)
 }
 
 
+Z7_FORCE_INLINE
 static void MtCoderThread_Destruct(CMtCoderThread *t)
 {
   if (Thread_WasCreated(&t->thread))
@@ -85,7 +100,7 @@ static void MtCoderThread_Destruct(CMtCoderThread *t)
 
 static SRes ThreadFunc2(CMtCoderThread *t)
 {
-  CMtCoder *mtc = t->mtCoder;
+  CMtCoder * const mtc = t->mtCoder;
 
   for (;;)
   {
@@ -185,7 +200,11 @@ static SRes ThreadFunc2(CMtCoderThread *t)
       if (mtc->numStartedThreads < mtc->numStartedThreadsLimit
           && mtc->expectedDataSize != readProcessed)
       {
-        res = MtCoderThread_CreateAndStart(&mtc->threads[mtc->numStartedThreads]);
+        res = MtCoderThread_CreateAndStart(&mtc->threads[mtc->numStartedThreads]
+#ifdef _WIN32
+            , mtc
+#endif
+            );
         if (res == SZ_OK)
           mtc->numStartedThreads++;
         else
@@ -221,7 +240,7 @@ static SRes ThreadFunc2(CMtCoderThread *t)
     }
 
     {
-      CMtCoderBlock *block = &mtc->blocks[bi];
+      CMtCoderBlock * const block = &mtc->blocks[bi];
       block->res = res;
       block->bufIndex = bufIndex;
       block->finished = finished;
@@ -311,7 +330,7 @@ static SRes ThreadFunc2(CMtCoderThread *t)
 
 static THREAD_FUNC_DECL ThreadFunc(void *pp)
 {
-  CMtCoderThread *t = (CMtCoderThread *)pp;
+  CMtCoderThread * const t = (CMtCoderThread *)pp;
   for (;;)
   {
     if (Event_Wait(&t->startEvent) != 0)
@@ -319,7 +338,7 @@ static THREAD_FUNC_DECL ThreadFunc(void *pp)
     if (t->stop)
       return 0;
     {
-      SRes res = ThreadFunc2(t);
+      const SRes res = ThreadFunc2(t);
       CMtCoder *mtc = t->mtCoder;
       if (res != SZ_OK)
       {
@@ -328,7 +347,7 @@ static THREAD_FUNC_DECL ThreadFunc(void *pp)
       
       #ifndef MTCODER_USE_WRITE_THREAD
       {
-        unsigned numFinished = (unsigned)InterlockedIncrement(&mtc->numFinishedThreads);
+        const unsigned numFinished = (unsigned)InterlockedIncrement(&mtc->numFinishedThreads);
         if (numFinished == mtc->numStartedThreads)
           if (Event_Set(&mtc->finishedEvent) != 0)
             return (THREAD_FUNC_RET_TYPE)SZ_ERROR_THREAD;
@@ -346,6 +365,7 @@ void MtCoder_Construct(CMtCoder *p)
   
   p->blockSize = 0;
   p->numThreadsMax = 0;
+  p->numThreadGroups = 0;
   p->expectedDataSize = (UInt64)(Int64)-1;
 
   p->inStream = NULL;
@@ -429,6 +449,8 @@ SRes MtCoder_Code(CMtCoder *p)
   unsigned i;
   SRes res = SZ_OK;
 
+  // printf("\n====== MtCoder_Code : \n");
+
   if (numThreads > MTCODER_THREADS_MAX)
       numThreads = MTCODER_THREADS_MAX;
   numBlocksMax = MTCODER_GET_NUM_BLOCKS_FROM_THREADS(numThreads);
@@ -492,11 +514,22 @@ SRes MtCoder_Code(CMtCoder *p)
 
   p->numStartedThreadsLimit = numThreads;
   p->numStartedThreads = 0;
+  ThreadNextGroup_Init(&p->nextGroup, p->numThreadGroups, 0); // startGroup
 
   // for (i = 0; i < numThreads; i++)
   {
+    // here we create new thread for first block.
+    // And each new thread will create another new thread after block reading
+    // until numStartedThreadsLimit is reached.
     CMtCoderThread *nextThread = &p->threads[p->numStartedThreads++];
-    RINOK(MtCoderThread_CreateAndStart(nextThread))
+    {
+      const SRes res2 = MtCoderThread_CreateAndStart(nextThread
+#ifdef _WIN32
+            , p
+#endif
+            );
+      RINOK(res2)
+    }
   }
 
   RINOK_THREAD(Event_Set(&p->readEvent))
@@ -513,9 +546,9 @@ SRes MtCoder_Code(CMtCoder *p)
       RINOK_THREAD(Event_Wait(&p->writeEvents[bi]))
 
       {
-        const CMtCoderBlock *block = &p->blocks[bi];
-        unsigned bufIndex = block->bufIndex;
-        BoolInt finished = block->finished;
+        const CMtCoderBlock * const block = &p->blocks[bi];
+        const unsigned bufIndex = block->bufIndex;
+        const BoolInt finished = block->finished;
         if (res == SZ_OK && block->res != SZ_OK)
           res = block->res;
 
@@ -545,7 +578,7 @@ SRes MtCoder_Code(CMtCoder *p)
   }
   #else
   {
-    WRes wres = Event_Wait(&p->finishedEvent);
+    const WRes wres = Event_Wait(&p->finishedEvent);
     res = MY_SRes_HRESULT_FROM_WRes(wres);
   }
   #endif
diff --git a/C/MtCoder.h b/C/MtCoder.h
index 1231d3c..8166cca 100644
--- a/C/MtCoder.h
+++ b/C/MtCoder.h
@@ -1,5 +1,5 @@
 /* MtCoder.h -- Multi-thread Coder
-2023-04-13 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_MT_CODER_H
 #define ZIP7_INC_MT_CODER_H
@@ -16,7 +16,7 @@ EXTERN_C_BEGIN
 
 #ifndef Z7_ST
   #define MTCODER_GET_NUM_BLOCKS_FROM_THREADS(numThreads) ((numThreads) + (numThreads) / 8 + 1)
-  #define MTCODER_THREADS_MAX 64
+  #define MTCODER_THREADS_MAX 256
   #define MTCODER_BLOCKS_MAX (MTCODER_GET_NUM_BLOCKS_FROM_THREADS(MTCODER_THREADS_MAX) + 3)
 #else
   #define MTCODER_THREADS_MAX 1
@@ -77,6 +77,7 @@ typedef struct CMtCoder_
   
   size_t blockSize;        /* size of input block */
   unsigned numThreadsMax;
+  unsigned numThreadGroups;
   UInt64 expectedDataSize;
 
   ISeqInStreamPtr inStream;
@@ -125,6 +126,8 @@ typedef struct CMtCoder_
   CMtProgress mtProgress;
   CMtCoderBlock blocks[MTCODER_BLOCKS_MAX];
   CMtCoderThread threads[MTCODER_THREADS_MAX];
+
+  CThreadNextGroup nextGroup;
 } CMtCoder;
 
 
diff --git a/C/Sha1.c b/C/Sha1.c
index 4c92892..4ca21d7 100644
--- a/C/Sha1.c
+++ b/C/Sha1.c
@@ -1,18 +1,14 @@
 /* Sha1.c -- SHA-1 Hash
-2024-03-01 : Igor Pavlov : Public domain
+: Igor Pavlov : Public domain
 This code is based on public domain code of Steve Reid from Wei Dai's Crypto++ library. */
 
 #include "Precomp.h"
 
 #include <string.h>
 
-#include "CpuArch.h"
-#include "RotateDefs.h"
 #include "Sha1.h"
-
-#if defined(_MSC_VER) && (_MSC_VER < 1900)
-// #define USE_MY_MM
-#endif
+#include "RotateDefs.h"
+#include "CpuArch.h"
 
 #ifdef MY_CPU_X86_OR_AMD64
   #if   defined(Z7_LLVM_CLANG_VERSION)  && (Z7_LLVM_CLANG_VERSION  >= 30800) \
@@ -56,7 +52,7 @@ void Z7_FASTCALL Sha1_UpdateBlocks(UInt32 state[5], const Byte *data, size_t num
   static SHA1_FUNC_UPDATE_BLOCKS g_SHA1_FUNC_UPDATE_BLOCKS = Sha1_UpdateBlocks;
   static SHA1_FUNC_UPDATE_BLOCKS g_SHA1_FUNC_UPDATE_BLOCKS_HW;
 
-  #define SHA1_UPDATE_BLOCKS(p) p->func_UpdateBlocks
+  #define SHA1_UPDATE_BLOCKS(p) p->v.vars.func_UpdateBlocks
 #else
   #define SHA1_UPDATE_BLOCKS(p) Sha1_UpdateBlocks
 #endif
@@ -85,7 +81,7 @@ BoolInt Sha1_SetFunction(CSha1 *p, unsigned algo)
       return False;
   #endif
 
-  p->func_UpdateBlocks = func;
+  p->v.vars.func_UpdateBlocks = func;
   return True;
 }
 
@@ -225,7 +221,7 @@ BoolInt Sha1_SetFunction(CSha1 *p, unsigned algo)
 
 void Sha1_InitState(CSha1 *p)
 {
-  p->count = 0;
+  p->v.vars.count = 0;
   p->state[0] = 0x67452301;
   p->state[1] = 0xEFCDAB89;
   p->state[2] = 0x98BADCFE;
@@ -235,7 +231,7 @@ void Sha1_InitState(CSha1 *p)
 
 void Sha1_Init(CSha1 *p)
 {
-  p->func_UpdateBlocks =
+  p->v.vars.func_UpdateBlocks =
   #ifdef Z7_COMPILER_SHA1_SUPPORTED
       g_SHA1_FUNC_UPDATE_BLOCKS;
   #else
@@ -250,7 +246,7 @@ void Z7_FASTCALL Sha1_UpdateBlocks(UInt32 state[5], const Byte *data, size_t num
 {
   UInt32 a, b, c, d, e;
   UInt32 W[kNumW];
-  // if (numBlocks != 0x1264378347) return;
+
   if (numBlocks == 0)
     return;
 
@@ -283,7 +279,7 @@ void Z7_FASTCALL Sha1_UpdateBlocks(UInt32 state[5], const Byte *data, size_t num
   state[3] = d;
   state[4] = e;
 
-  data += 64;
+  data += SHA1_BLOCK_SIZE;
   }
   while (--numBlocks);
 }
@@ -295,20 +291,15 @@ void Sha1_Update(CSha1 *p, const Byte *data, size_t size)
 {
   if (size == 0)
     return;
-
   {
-    unsigned pos = (unsigned)p->count & 0x3F;
-    unsigned num;
-    
-    p->count += size;
-    
-    num = 64 - pos;
+    const unsigned pos = (unsigned)p->v.vars.count & (SHA1_BLOCK_SIZE - 1);
+    const unsigned num = SHA1_BLOCK_SIZE - pos;
+    p->v.vars.count += size;
     if (num > size)
     {
       memcpy(p->buffer + pos, data, size);
       return;
     }
-    
     if (pos != 0)
     {
       size -= num;
@@ -318,9 +309,10 @@ void Sha1_Update(CSha1 *p, const Byte *data, size_t size)
     }
   }
   {
-    size_t numBlocks = size >> 6;
+    const size_t numBlocks = size >> 6;
+    // if (numBlocks)
     SHA1_UPDATE_BLOCKS(p)(p->state, data, numBlocks);
-    size &= 0x3F;
+    size &= SHA1_BLOCK_SIZE - 1;
     if (size == 0)
       return;
     data += (numBlocks << 6);
@@ -331,42 +323,21 @@ void Sha1_Update(CSha1 *p, const Byte *data, size_t size)
 
 void Sha1_Final(CSha1 *p, Byte *digest)
 {
-  unsigned pos = (unsigned)p->count & 0x3F;
-  
-
+  unsigned pos = (unsigned)p->v.vars.count & (SHA1_BLOCK_SIZE - 1);
   p->buffer[pos++] = 0x80;
-  
-  if (pos > (64 - 8))
+  if (pos > (SHA1_BLOCK_SIZE - 4 * 2))
   {
-    while (pos != 64) { p->buffer[pos++] = 0; }
-    // memset(&p->buf.buffer[pos], 0, 64 - pos);
+    while (pos != SHA1_BLOCK_SIZE) { p->buffer[pos++] = 0; }
+    // memset(&p->buf.buffer[pos], 0, SHA1_BLOCK_SIZE - pos);
     Sha1_UpdateBlock(p);
     pos = 0;
   }
-
-  /*
-  if (pos & 3)
-  {
-    p->buffer[pos] = 0;
-    p->buffer[pos + 1] = 0;
-    p->buffer[pos + 2] = 0;
-    pos += 3;
-    pos &= ~3;
-  }
-  {
-    for (; pos < 64 - 8; pos += 4)
-      *(UInt32 *)(&p->buffer[pos]) = 0;
-  }
-  */
-
-  memset(&p->buffer[pos], 0, (64 - 8) - pos);
-
+  memset(&p->buffer[pos], 0, (SHA1_BLOCK_SIZE - 4 * 2) - pos);
   {
-    const UInt64 numBits = (p->count << 3);
-    SetBe32(p->buffer + 64 - 8, (UInt32)(numBits >> 32))
-    SetBe32(p->buffer + 64 - 4, (UInt32)(numBits))
+    const UInt64 numBits = p->v.vars.count << 3;
+    SetBe32(p->buffer + SHA1_BLOCK_SIZE - 4 * 2, (UInt32)(numBits >> 32))
+    SetBe32(p->buffer + SHA1_BLOCK_SIZE - 4 * 1, (UInt32)(numBits))
   }
-  
   Sha1_UpdateBlock(p);
 
   SetBe32(digest,      p->state[0])
@@ -375,16 +346,13 @@ void Sha1_Final(CSha1 *p, Byte *digest)
   SetBe32(digest + 12, p->state[3])
   SetBe32(digest + 16, p->state[4])
   
-
-
-
   Sha1_InitState(p);
 }
 
 
 void Sha1_PrepareBlock(const CSha1 *p, Byte *block, unsigned size)
 {
-  const UInt64 numBits = (p->count + size) << 3;
+  const UInt64 numBits = (p->v.vars.count + size) << 3;
   SetBe32(&((UInt32 *)(void *)block)[SHA1_NUM_BLOCK_WORDS - 2], (UInt32)(numBits >> 32))
   SetBe32(&((UInt32 *)(void *)block)[SHA1_NUM_BLOCK_WORDS - 1], (UInt32)(numBits))
   // SetBe32((UInt32 *)(block + size), 0x80000000);
@@ -420,57 +388,32 @@ void Sha1_GetBlockDigest(const CSha1 *p, const Byte *data, Byte *destDigest)
 
 void Sha1Prepare(void)
 {
-  #ifdef Z7_COMPILER_SHA1_SUPPORTED
+#ifdef Z7_COMPILER_SHA1_SUPPORTED
   SHA1_FUNC_UPDATE_BLOCKS f, f_hw;
   f = Sha1_UpdateBlocks;
   f_hw = NULL;
-  #ifdef MY_CPU_X86_OR_AMD64
-  #ifndef USE_MY_MM
+#ifdef MY_CPU_X86_OR_AMD64
   if (CPU_IsSupported_SHA()
       && CPU_IsSupported_SSSE3()
-      // && CPU_IsSupported_SSE41()
       )
-  #endif
-  #else
+#else
   if (CPU_IsSupported_SHA1())
-  #endif
+#endif
   {
     // printf("\n========== HW SHA1 ======== \n");
-    #if 0 && defined(MY_CPU_ARM_OR_ARM64) && defined(_MSC_VER)
+#if 1 && defined(MY_CPU_ARM_OR_ARM64) && defined(Z7_MSC_VER_ORIGINAL) && (_MSC_FULL_VER < 192930037)
     /* there was bug in MSVC compiler for ARM64 -O2 before version VS2019 16.10 (19.29.30037).
-       It generated incorrect SHA-1 code.
-       21.03 : we test sha1-hardware code at runtime initialization */
-
-      #pragma message("== SHA1 code: MSC compiler : failure-check code was inserted")
-
-      UInt32 state[5] = { 0, 1, 2, 3, 4 } ;
-      Byte data[64];
-      unsigned i;
-      for (i = 0; i < sizeof(data); i += 2)
-      {
-        data[i    ] = (Byte)(i);
-        data[i + 1] = (Byte)(i + 1);
-      }
-
-      Sha1_UpdateBlocks_HW(state, data, sizeof(data) / 64);
-    
-      if (   state[0] != 0x9acd7297
-          || state[1] != 0x4624d898
-          || state[2] != 0x0bf079f0
-          || state[3] != 0x031e61b3
-          || state[4] != 0x8323fe20)
-      {
-        // printf("\n========== SHA-1 hardware version failure ======== \n");
-      }
-      else
-    #endif
+       It generated incorrect SHA-1 code. */
+      #pragma message("== SHA1 code can work incorrectly with this compiler")
+      #error Stop_Compiling_MSC_Compiler_BUG_SHA1
+#endif
       {
         f = f_hw = Sha1_UpdateBlocks_HW;
       }
   }
   g_SHA1_FUNC_UPDATE_BLOCKS    = f;
   g_SHA1_FUNC_UPDATE_BLOCKS_HW = f_hw;
-  #endif
+#endif
 }
 
 #undef kNumW
diff --git a/C/Sha1.h b/C/Sha1.h
index fecd9d3..529be4d 100644
--- a/C/Sha1.h
+++ b/C/Sha1.h
@@ -1,5 +1,5 @@
 /* Sha1.h -- SHA-1 Hash
-2023-04-02 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_SHA1_H
 #define ZIP7_INC_SHA1_H
@@ -14,6 +14,9 @@ EXTERN_C_BEGIN
 #define SHA1_BLOCK_SIZE   (SHA1_NUM_BLOCK_WORDS * 4)
 #define SHA1_DIGEST_SIZE  (SHA1_NUM_DIGEST_WORDS * 4)
 
+
+
+
 typedef void (Z7_FASTCALL *SHA1_FUNC_UPDATE_BLOCKS)(UInt32 state[5], const Byte *data, size_t numBlocks);
 
 /*
@@ -32,9 +35,16 @@ typedef void (Z7_FASTCALL *SHA1_FUNC_UPDATE_BLOCKS)(UInt32 state[5], const Byte
 
 typedef struct
 {
-  SHA1_FUNC_UPDATE_BLOCKS func_UpdateBlocks;
-  UInt64 count;
-  UInt64 _pad_2[2];
+  union
+  {
+    struct
+    {
+      SHA1_FUNC_UPDATE_BLOCKS func_UpdateBlocks;
+      UInt64 count;
+    } vars;
+    UInt64 _pad_64bit[4];
+    void *_pad_align_ptr[2];
+  } v;
   UInt32 state[SHA1_NUM_DIGEST_WORDS];
   UInt32 _pad_3[3];
   Byte buffer[SHA1_BLOCK_SIZE];
diff --git a/C/Sha1Opt.c b/C/Sha1Opt.c
index 4e835f1..8738b94 100644
--- a/C/Sha1Opt.c
+++ b/C/Sha1Opt.c
@@ -1,18 +1,11 @@
 /* Sha1Opt.c -- SHA-1 optimized code for SHA-1 hardware instructions
-2024-03-01 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 #include "Compiler.h"
 #include "CpuArch.h"
 
-#if defined(_MSC_VER)
-#if (_MSC_VER < 1900) && (_MSC_VER >= 1200)
-// #define USE_MY_MM
-#endif
-#endif
-
 // #define Z7_USE_HW_SHA_STUB // for debug
-
 #ifdef MY_CPU_X86_OR_AMD64
   #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1600) // fix that check
       #define USE_HW_SHA
@@ -20,19 +13,14 @@
      || defined(Z7_APPLE_CLANG_VERSION) && (Z7_APPLE_CLANG_VERSION >= 50100) \
      || defined(Z7_GCC_VERSION)         && (Z7_GCC_VERSION         >= 40900)
       #define USE_HW_SHA
-      #if !defined(_INTEL_COMPILER)
+      #if !defined(__INTEL_COMPILER)
       // icc defines __GNUC__, but icc doesn't support __attribute__(__target__)
       #if !defined(__SHA__) || !defined(__SSSE3__)
         #define ATTRIB_SHA __attribute__((__target__("sha,ssse3")))
       #endif
       #endif
   #elif defined(_MSC_VER)
-    #ifdef USE_MY_MM
-      #define USE_VER_MIN 1300
-    #else
-      #define USE_VER_MIN 1900
-    #endif
-    #if (_MSC_VER >= USE_VER_MIN)
+    #if (_MSC_VER >= 1900)
       #define USE_HW_SHA
     #else
       #define Z7_USE_HW_SHA_STUB
@@ -47,23 +35,20 @@
 
 // #pragma message("Sha1 HW")
 
+
+
+
 // sse/sse2/ssse3:
 #include <tmmintrin.h>
 // sha*:
 #include <immintrin.h>
 
 #if defined (__clang__) && defined(_MSC_VER)
-  // #if !defined(__SSSE3__)
-  // #endif
   #if !defined(__SHA__)
     #include <shaintrin.h>
   #endif
 #else
 
-#ifdef USE_MY_MM
-#include "My_mm.h"
-#endif
-
 #endif
 
 /*
@@ -84,7 +69,6 @@ SHA:
   _mm_sha1*
 */
 
-
 #define XOR_SI128(dest, src)      dest = _mm_xor_si128(dest, src);
 #define SHUFFLE_EPI8(dest, mask)  dest = _mm_shuffle_epi8(dest, mask);
 #define SHUFFLE_EPI32(dest, mask) dest = _mm_shuffle_epi32(dest, mask);
@@ -99,11 +83,12 @@ SHA:
 #define SHA1_MSG1(dest, src)      dest = _mm_sha1msg1_epu32(dest, src);
 #define SHA1_MSG2(dest, src)      dest = _mm_sha1msg2_epu32(dest, src);
 
-
 #define LOAD_SHUFFLE(m, k) \
     m = _mm_loadu_si128((const __m128i *)(const void *)(data + (k) * 16)); \
     SHUFFLE_EPI8(m, mask) \
 
+#define NNN(m0, m1, m2, m3)
+
 #define SM1(m0, m1, m2, m3) \
     SHA1_MSG1(m0, m1) \
 
@@ -116,35 +101,19 @@ SHA:
     SM1(m0, m1, m2, m3) \
     SHA1_MSG2(m3, m2) \
 
-#define NNN(m0, m1, m2, m3)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#define R4(k, e0, e1, m0, m1, m2, m3, OP) \
+#define R4(k, m0, m1, m2, m3, e0, e1, OP) \
     e1 = abcd; \
     SHA1_RND4(abcd, e0, (k) / 5) \
     SHA1_NEXTE(e1, m1) \
     OP(m0, m1, m2, m3) \
 
+
+
 #define R16(k, mx, OP0, OP1, OP2, OP3) \
-    R4 ( (k)*4+0, e0,e1, m0,m1,m2,m3, OP0 ) \
-    R4 ( (k)*4+1, e1,e0, m1,m2,m3,m0, OP1 ) \
-    R4 ( (k)*4+2, e0,e1, m2,m3,m0,m1, OP2 ) \
-    R4 ( (k)*4+3, e1,e0, m3,mx,m1,m2, OP3 ) \
+    R4 ( (k)*4+0, m0,m1,m2,m3, e0,e1, OP0 ) \
+    R4 ( (k)*4+1, m1,m2,m3,m0, e1,e0, OP1 ) \
+    R4 ( (k)*4+2, m2,m3,m0,m1, e0,e1, OP2 ) \
+    R4 ( (k)*4+3, m3,mx,m1,m2, e1,e0, OP3 ) \
 
 #define PREPARE_STATE \
     SHUFFLE_EPI32 (abcd, 0x1B) \
@@ -162,8 +131,9 @@ void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[5], const Byte *data, size_t
 {
   const __m128i mask = _mm_set_epi32(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f);
 
-  __m128i abcd, e0;
   
+  __m128i abcd, e0;
+
   if (numBlocks == 0)
     return;
   
@@ -204,7 +174,7 @@ void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[5], const Byte *data, size_t
   PREPARE_STATE
 
   _mm_storeu_si128((__m128i *) (void *) state, abcd);
-  *(state+4) = (UInt32)_mm_cvtsi128_si32(e0);
+  *(state + 4) = (UInt32)_mm_cvtsi128_si32(e0);
 }
 
 #endif // USE_HW_SHA
@@ -262,22 +232,10 @@ void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[5], const Byte *data, size_t
   #define _ARM_USE_NEW_NEON_INTRINSICS
 #endif
 
-
-
-
-
 #if defined(Z7_MSC_VER_ORIGINAL) && defined(MY_CPU_ARM64)
 #include <arm64_neon.h>
 #else
 
-
-
-
-
-
-
-
-
 #if defined(__clang__) && __clang_major__ < 16
 #if !defined(__ARM_FEATURE_SHA2) && \
     !defined(__ARM_FEATURE_CRYPTO)
@@ -329,26 +287,37 @@ typedef uint32x4_t v128;
 #endif
 
 #ifdef MY_CPU_BE
-  #define MY_rev32_for_LE(x)
+  #define MY_rev32_for_LE(x) x
 #else
-  #define MY_rev32_for_LE(x) x = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(x)))
+  #define MY_rev32_for_LE(x) vrev32q_u8(x)
 #endif
 
-#define LOAD_128(_p)      (*(const v128 *)(const void *)(_p))
-#define STORE_128(_p, _v) *(v128 *)(void *)(_p) = (_v)
+#define LOAD_128_32(_p)       vld1q_u32(_p)
+#define LOAD_128_8(_p)        vld1q_u8 (_p)
+#define STORE_128_32(_p, _v)  vst1q_u32(_p, _v)
 
 #define LOAD_SHUFFLE(m, k) \
-    m = LOAD_128((data + (k) * 16)); \
-    MY_rev32_for_LE(m); \
-
-#define SU0(dest, src2, src3) dest = vsha1su0q_u32(dest, src2, src3)
-#define SU1(dest, src)        dest = vsha1su1q_u32(dest, src)
+    m = vreinterpretq_u32_u8( \
+        MY_rev32_for_LE( \
+        LOAD_128_8(data + (k) * 16))); \
+
+#define N0(dest, src2, src3)
+#define N1(dest, src)
+#define U0(dest, src2, src3)  dest = vsha1su0q_u32(dest, src2, src3);
+#define U1(dest, src)         dest = vsha1su1q_u32(dest, src);
 #define C(e)                  abcd = vsha1cq_u32(abcd, e, t)
 #define P(e)                  abcd = vsha1pq_u32(abcd, e, t)
 #define M(e)                  abcd = vsha1mq_u32(abcd, e, t)
 #define H(e)                  e = vsha1h_u32(vgetq_lane_u32(abcd, 0))
 #define T(m, c)               t = vaddq_u32(m, c)
 
+#define R16(d0,d1,d2,d3, f0,z0, f1,z1, f2,z2, f3,z3, w0,w1,w2,w3) \
+    T(m0, d0);  f0(m3, m0, m1)  z0(m2, m1)  H(e1);  w0(e0); \
+    T(m1, d1);  f1(m0, m1, m2)  z1(m3, m2)  H(e0);  w1(e1); \
+    T(m2, d2);  f2(m1, m2, m3)  z2(m0, m3)  H(e1);  w2(e0); \
+    T(m3, d3);  f3(m2, m3, m0)  z3(m1, m0)  H(e0);  w3(e1); \
+
+
 void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks);
 #ifdef ATTRIB_SHA
 ATTRIB_SHA
@@ -367,7 +336,7 @@ void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t
   c2 = vdupq_n_u32(0x8f1bbcdc);
   c3 = vdupq_n_u32(0xca62c1d6);
 
-  abcd = LOAD_128(&state[0]);
+  abcd = LOAD_128_32(&state[0]);
   e0 = state[4];
   
   do
@@ -385,26 +354,11 @@ void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t
     LOAD_SHUFFLE (m2, 2)
     LOAD_SHUFFLE (m3, 3)
                      
-    T(m0, c0);                                  H(e1); C(e0);
-    T(m1, c0);  SU0(m0, m1, m2);                H(e0); C(e1);
-    T(m2, c0);  SU0(m1, m2, m3);  SU1(m0, m3);  H(e1); C(e0);
-    T(m3, c0);  SU0(m2, m3, m0);  SU1(m1, m0);  H(e0); C(e1);
-    T(m0, c0);  SU0(m3, m0, m1);  SU1(m2, m1);  H(e1); C(e0);
-    T(m1, c1);  SU0(m0, m1, m2);  SU1(m3, m2);  H(e0); P(e1);
-    T(m2, c1);  SU0(m1, m2, m3);  SU1(m0, m3);  H(e1); P(e0);
-    T(m3, c1);  SU0(m2, m3, m0);  SU1(m1, m0);  H(e0); P(e1);
-    T(m0, c1);  SU0(m3, m0, m1);  SU1(m2, m1);  H(e1); P(e0);
-    T(m1, c1);  SU0(m0, m1, m2);  SU1(m3, m2);  H(e0); P(e1);
-    T(m2, c2);  SU0(m1, m2, m3);  SU1(m0, m3);  H(e1); M(e0);
-    T(m3, c2);  SU0(m2, m3, m0);  SU1(m1, m0);  H(e0); M(e1);
-    T(m0, c2);  SU0(m3, m0, m1);  SU1(m2, m1);  H(e1); M(e0);
-    T(m1, c2);  SU0(m0, m1, m2);  SU1(m3, m2);  H(e0); M(e1);
-    T(m2, c2);  SU0(m1, m2, m3);  SU1(m0, m3);  H(e1); M(e0);
-    T(m3, c3);  SU0(m2, m3, m0);  SU1(m1, m0);  H(e0); P(e1);
-    T(m0, c3);  SU0(m3, m0, m1);  SU1(m2, m1);  H(e1); P(e0);
-    T(m1, c3);                    SU1(m3, m2);  H(e0); P(e1);
-    T(m2, c3);                                  H(e1); P(e0);
-    T(m3, c3);                                  H(e0); P(e1);
+    R16 ( c0,c0,c0,c0, N0,N1, U0,N1, U0,U1, U0,U1, C,C,C,C )
+    R16 ( c0,c1,c1,c1, U0,U1, U0,U1, U0,U1, U0,U1, C,P,P,P )
+    R16 ( c1,c1,c2,c2, U0,U1, U0,U1, U0,U1, U0,U1, P,P,M,M )
+    R16 ( c2,c2,c2,c3, U0,U1, U0,U1, U0,U1, U0,U1, M,M,M,P )
+    R16 ( c3,c3,c3,c3, U0,U1, N0,U1, N0,N1, N0,N1, P,P,P,P )
                                                                                                                      
     abcd = vaddq_u32(abcd, abcd_save);
     e0 += e0_save;
@@ -413,7 +367,7 @@ void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t
   }
   while (--numBlocks);
 
-  STORE_128(&state[0], abcd);
+  STORE_128_32(&state[0], abcd);
   state[4] = e0;
 }
 
@@ -421,13 +375,9 @@ void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t
 
 #endif // MY_CPU_ARM_OR_ARM64
 
-
 #if !defined(USE_HW_SHA) && defined(Z7_USE_HW_SHA_STUB)
 // #error Stop_Compiling_UNSUPPORTED_SHA
 // #include <stdlib.h>
-
-
-
 // #include "Sha1.h"
 // #if defined(_MSC_VER)
 #pragma message("Sha1   HW-SW stub was used")
@@ -447,8 +397,10 @@ void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[5], const Byte *data, size_t
 }
 #endif
 
-#undef SU0
-#undef SU1
+#undef U0
+#undef U1
+#undef N0
+#undef N1
 #undef C
 #undef P
 #undef M
diff --git a/C/Sha256.c b/C/Sha256.c
index 14d3be9..ea7ed8e 100644
--- a/C/Sha256.c
+++ b/C/Sha256.c
@@ -1,18 +1,14 @@
 /* Sha256.c -- SHA-256 Hash
-2024-03-01 : Igor Pavlov : Public domain
+: Igor Pavlov : Public domain
 This code is based on public domain code from Wei Dai's Crypto++ library. */
 
 #include "Precomp.h"
 
 #include <string.h>
 
-#include "CpuArch.h"
-#include "RotateDefs.h"
 #include "Sha256.h"
-
-#if defined(_MSC_VER) && (_MSC_VER < 1900)
-// #define USE_MY_MM
-#endif
+#include "RotateDefs.h"
+#include "CpuArch.h"
 
 #ifdef MY_CPU_X86_OR_AMD64
   #if   defined(Z7_LLVM_CLANG_VERSION)  && (Z7_LLVM_CLANG_VERSION  >= 30800) \
@@ -56,7 +52,7 @@ void Z7_FASTCALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t n
   static SHA256_FUNC_UPDATE_BLOCKS g_SHA256_FUNC_UPDATE_BLOCKS = Sha256_UpdateBlocks;
   static SHA256_FUNC_UPDATE_BLOCKS g_SHA256_FUNC_UPDATE_BLOCKS_HW;
 
-  #define SHA256_UPDATE_BLOCKS(p) p->func_UpdateBlocks
+  #define SHA256_UPDATE_BLOCKS(p) p->v.vars.func_UpdateBlocks
 #else
   #define SHA256_UPDATE_BLOCKS(p) Sha256_UpdateBlocks
 #endif
@@ -85,7 +81,7 @@ BoolInt Sha256_SetFunction(CSha256 *p, unsigned algo)
       return False;
   #endif
 
-  p->func_UpdateBlocks = func;
+  p->v.vars.func_UpdateBlocks = func;
   return True;
 }
 
@@ -111,7 +107,7 @@ BoolInt Sha256_SetFunction(CSha256 *p, unsigned algo)
 
 void Sha256_InitState(CSha256 *p)
 {
-  p->count = 0;
+  p->v.vars.count = 0;
   p->state[0] = 0x6a09e667;
   p->state[1] = 0xbb67ae85;
   p->state[2] = 0x3c6ef372;
@@ -122,9 +118,16 @@ void Sha256_InitState(CSha256 *p)
   p->state[7] = 0x5be0cd19;
 }
 
+
+
+
+
+
+
+
 void Sha256_Init(CSha256 *p)
 {
-  p->func_UpdateBlocks =
+  p->v.vars.func_UpdateBlocks =
   #ifdef Z7_COMPILER_SHA256_SUPPORTED
       g_SHA256_FUNC_UPDATE_BLOCKS;
   #else
@@ -133,10 +136,10 @@ void Sha256_Init(CSha256 *p)
   Sha256_InitState(p);
 }
 
-#define S0(x) (rotrFixed(x, 2) ^ rotrFixed(x,13) ^ rotrFixed(x, 22))
-#define S1(x) (rotrFixed(x, 6) ^ rotrFixed(x,11) ^ rotrFixed(x, 25))
+#define S0(x) (rotrFixed(x, 2) ^ rotrFixed(x,13) ^ rotrFixed(x,22))
+#define S1(x) (rotrFixed(x, 6) ^ rotrFixed(x,11) ^ rotrFixed(x,25))
 #define s0(x) (rotrFixed(x, 7) ^ rotrFixed(x,18) ^ (x >> 3))
-#define s1(x) (rotrFixed(x,17) ^ rotrFixed(x,19) ^ (x >> 10))
+#define s1(x) (rotrFixed(x,17) ^ rotrFixed(x,19) ^ (x >>10))
 
 #define Ch(x,y,z) (z^(x&(y^z)))
 #define Maj(x,y,z) ((x&y)|(z&(x|y)))
@@ -224,12 +227,10 @@ void Sha256_Init(CSha256 *p)
 
 #endif
 
-// static
-extern MY_ALIGN(64)
-const UInt32 SHA256_K_ARRAY[64];
 
-MY_ALIGN(64)
-const UInt32 SHA256_K_ARRAY[64] = {
+extern
+MY_ALIGN(64) const UInt32 SHA256_K_ARRAY[64];
+MY_ALIGN(64) const UInt32 SHA256_K_ARRAY[64] = {
   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
   0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
   0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
@@ -248,27 +249,29 @@ const UInt32 SHA256_K_ARRAY[64] = {
   0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 };
 
-#define K SHA256_K_ARRAY
 
 
+
+
+#define K SHA256_K_ARRAY
+
 Z7_NO_INLINE
 void Z7_FASTCALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t numBlocks)
 {
   UInt32 W
-  #ifdef Z7_SHA256_BIG_W
+#ifdef Z7_SHA256_BIG_W
       [64];
-  #else
+#else
       [16];
-  #endif
-
+#endif
   unsigned j;
-
   UInt32 a,b,c,d,e,f,g,h;
-
-  #if !defined(Z7_SHA256_UNROLL) || (STEP_MAIN <= 4) || (STEP_PRE <= 4)
+#if !defined(Z7_SHA256_UNROLL) || (STEP_MAIN <= 4) || (STEP_PRE <= 4)
   UInt32 tmp;
-  #endif
+#endif
   
+  if (numBlocks == 0) return;
+
   a = state[0];
   b = state[1];
   c = state[2];
@@ -278,7 +281,7 @@ void Z7_FASTCALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t n
   g = state[6];
   h = state[7];
 
-  while (numBlocks)
+  do
   {
 
   for (j = 0; j < 16; j += STEP_PRE)
@@ -352,19 +355,11 @@ void Z7_FASTCALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t n
   g += state[6]; state[6] = g;
   h += state[7]; state[7] = h;
 
-  data += 64;
-  numBlocks--;
+  data += SHA256_BLOCK_SIZE;
   }
-
-  /* Wipe variables */
-  /* memset(W, 0, sizeof(W)); */
+  while (--numBlocks);
 }
 
-#undef S0
-#undef S1
-#undef s0
-#undef s1
-#undef K
 
 #define Sha256_UpdateBlock(p) SHA256_UPDATE_BLOCKS(p)(p->state, p->buffer, 1)
 
@@ -372,20 +367,15 @@ void Sha256_Update(CSha256 *p, const Byte *data, size_t size)
 {
   if (size == 0)
     return;
-
   {
-    unsigned pos = (unsigned)p->count & 0x3F;
-    unsigned num;
-    
-    p->count += size;
-    
-    num = 64 - pos;
+    const unsigned pos = (unsigned)p->v.vars.count & (SHA256_BLOCK_SIZE - 1);
+    const unsigned num = SHA256_BLOCK_SIZE - pos;
+    p->v.vars.count += size;
     if (num > size)
     {
       memcpy(p->buffer + pos, data, size);
       return;
     }
-    
     if (pos != 0)
     {
       size -= num;
@@ -395,9 +385,10 @@ void Sha256_Update(CSha256 *p, const Byte *data, size_t size)
     }
   }
   {
-    size_t numBlocks = size >> 6;
+    const size_t numBlocks = size >> 6;
+    // if (numBlocks)
     SHA256_UPDATE_BLOCKS(p)(p->state, data, numBlocks);
-    size &= 0x3F;
+    size &= SHA256_BLOCK_SIZE - 1;
     if (size == 0)
       return;
     data += (numBlocks << 6);
@@ -408,82 +399,69 @@ void Sha256_Update(CSha256 *p, const Byte *data, size_t size)
 
 void Sha256_Final(CSha256 *p, Byte *digest)
 {
-  unsigned pos = (unsigned)p->count & 0x3F;
-  unsigned i;
-  
+  unsigned pos = (unsigned)p->v.vars.count & (SHA256_BLOCK_SIZE - 1);
   p->buffer[pos++] = 0x80;
-  
-  if (pos > (64 - 8))
+  if (pos > (SHA256_BLOCK_SIZE - 4 * 2))
   {
-    while (pos != 64) { p->buffer[pos++] = 0; }
-    // memset(&p->buf.buffer[pos], 0, 64 - pos);
+    while (pos != SHA256_BLOCK_SIZE) { p->buffer[pos++] = 0; }
+    // memset(&p->buf.buffer[pos], 0, SHA256_BLOCK_SIZE - pos);
     Sha256_UpdateBlock(p);
     pos = 0;
   }
-
-  /*
-  if (pos & 3)
+  memset(&p->buffer[pos], 0, (SHA256_BLOCK_SIZE - 4 * 2) - pos);
   {
-    p->buffer[pos] = 0;
-    p->buffer[pos + 1] = 0;
-    p->buffer[pos + 2] = 0;
-    pos += 3;
-    pos &= ~3;
+    const UInt64 numBits = p->v.vars.count << 3;
+    SetBe32(p->buffer + SHA256_BLOCK_SIZE - 4 * 2, (UInt32)(numBits >> 32))
+    SetBe32(p->buffer + SHA256_BLOCK_SIZE - 4 * 1, (UInt32)(numBits))
   }
+  Sha256_UpdateBlock(p);
+#if 1 && defined(MY_CPU_BE)
+  memcpy(digest, p->state, SHA256_DIGEST_SIZE);
+#else
   {
-    for (; pos < 64 - 8; pos += 4)
-      *(UInt32 *)(&p->buffer[pos]) = 0;
+    unsigned i;
+    for (i = 0; i < 8; i += 2)
+    {
+      const UInt32 v0 = p->state[i];
+      const UInt32 v1 = p->state[(size_t)i + 1];
+      SetBe32(digest    , v0)
+      SetBe32(digest + 4, v1)
+      digest += 4 * 2;
+    }
   }
-  */
 
-  memset(&p->buffer[pos], 0, (64 - 8) - pos);
 
-  {
-    UInt64 numBits = (p->count << 3);
-    SetBe32(p->buffer + 64 - 8, (UInt32)(numBits >> 32))
-    SetBe32(p->buffer + 64 - 4, (UInt32)(numBits))
-  }
-  
-  Sha256_UpdateBlock(p);
 
-  for (i = 0; i < 8; i += 2)
-  {
-    UInt32 v0 = p->state[i];
-    UInt32 v1 = p->state[(size_t)i + 1];
-    SetBe32(digest    , v0)
-    SetBe32(digest + 4, v1)
-    digest += 8;
-  }
-  
+
+#endif
   Sha256_InitState(p);
 }
 
 
 void Sha256Prepare(void)
 {
-  #ifdef Z7_COMPILER_SHA256_SUPPORTED
+#ifdef Z7_COMPILER_SHA256_SUPPORTED
   SHA256_FUNC_UPDATE_BLOCKS f, f_hw;
   f = Sha256_UpdateBlocks;
   f_hw = NULL;
-  #ifdef MY_CPU_X86_OR_AMD64
-  #ifndef USE_MY_MM
+#ifdef MY_CPU_X86_OR_AMD64
   if (CPU_IsSupported_SHA()
       && CPU_IsSupported_SSSE3()
-      // && CPU_IsSupported_SSE41()
       )
-  #endif
-  #else
+#else
   if (CPU_IsSupported_SHA2())
-  #endif
+#endif
   {
     // printf("\n========== HW SHA256 ======== \n");
     f = f_hw = Sha256_UpdateBlocks_HW;
   }
   g_SHA256_FUNC_UPDATE_BLOCKS    = f;
   g_SHA256_FUNC_UPDATE_BLOCKS_HW = f_hw;
-  #endif
+#endif
 }
 
+#undef U64C
+#undef K
 #undef S0
 #undef S1
 #undef s0
diff --git a/C/Sha256.h b/C/Sha256.h
index 9e04223..75329cd 100644
--- a/C/Sha256.h
+++ b/C/Sha256.h
@@ -1,5 +1,5 @@
 /* Sha256.h -- SHA-256 Hash
-2023-04-02 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_SHA256_H
 #define ZIP7_INC_SHA256_H
@@ -14,6 +14,9 @@ EXTERN_C_BEGIN
 #define SHA256_BLOCK_SIZE   (SHA256_NUM_BLOCK_WORDS * 4)
 #define SHA256_DIGEST_SIZE  (SHA256_NUM_DIGEST_WORDS * 4)
 
+
+
+
 typedef void (Z7_FASTCALL *SHA256_FUNC_UPDATE_BLOCKS)(UInt32 state[8], const Byte *data, size_t numBlocks);
 
 /*
@@ -32,9 +35,16 @@ typedef void (Z7_FASTCALL *SHA256_FUNC_UPDATE_BLOCKS)(UInt32 state[8], const Byt
 
 typedef struct
 {
-  SHA256_FUNC_UPDATE_BLOCKS func_UpdateBlocks;
-  UInt64 count;
-  UInt64 _pad_2[2];
+  union
+  {
+    struct
+    {
+      SHA256_FUNC_UPDATE_BLOCKS func_UpdateBlocks;
+      UInt64 count;
+    } vars;
+    UInt64 _pad_64bit[4];
+    void *_pad_align_ptr[2];
+  } v;
   UInt32 state[SHA256_NUM_DIGEST_WORDS];
 
   Byte buffer[SHA256_BLOCK_SIZE];
diff --git a/C/Sha256Opt.c b/C/Sha256Opt.c
index eb38166..1c6b50f 100644
--- a/C/Sha256Opt.c
+++ b/C/Sha256Opt.c
@@ -1,18 +1,11 @@
 /* Sha256Opt.c -- SHA-256 optimized code for SHA-256 hardware instructions
-2024-03-01 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 #include "Compiler.h"
 #include "CpuArch.h"
 
-#if defined(_MSC_VER)
-#if (_MSC_VER < 1900) && (_MSC_VER >= 1200)
-// #define USE_MY_MM
-#endif
-#endif
-
 // #define Z7_USE_HW_SHA_STUB // for debug
-
 #ifdef MY_CPU_X86_OR_AMD64
   #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1600) // fix that check
       #define USE_HW_SHA
@@ -20,19 +13,14 @@
      || defined(Z7_APPLE_CLANG_VERSION) && (Z7_APPLE_CLANG_VERSION >= 50100) \
      || defined(Z7_GCC_VERSION)         && (Z7_GCC_VERSION         >= 40900)
       #define USE_HW_SHA
-      #if !defined(_INTEL_COMPILER)
+      #if !defined(__INTEL_COMPILER)
       // icc defines __GNUC__, but icc doesn't support __attribute__(__target__)
       #if !defined(__SHA__) || !defined(__SSSE3__)
         #define ATTRIB_SHA __attribute__((__target__("sha,ssse3")))
       #endif
       #endif
   #elif defined(_MSC_VER)
-    #ifdef USE_MY_MM
-      #define USE_VER_MIN 1300
-    #else
-      #define USE_VER_MIN 1900
-    #endif
-    #if (_MSC_VER >= USE_VER_MIN)
+    #if (_MSC_VER >= 1900)
       #define USE_HW_SHA
     #else
       #define Z7_USE_HW_SHA_STUB
@@ -47,23 +35,20 @@
 
 // #pragma message("Sha256 HW")
 
+
+
+
 // sse/sse2/ssse3:
 #include <tmmintrin.h>
 // sha*:
 #include <immintrin.h>
 
 #if defined (__clang__) && defined(_MSC_VER)
-  // #if !defined(__SSSE3__)
-  // #endif
   #if !defined(__SHA__)
     #include <shaintrin.h>
   #endif
 #else
 
-#ifdef USE_MY_MM
-#include "My_mm.h"
-#endif
-
 #endif
 
 /*
@@ -91,60 +76,44 @@ SHA:
 extern
 MY_ALIGN(64)
 const UInt32 SHA256_K_ARRAY[64];
-
 #define K SHA256_K_ARRAY
 
 
 #define ADD_EPI32(dest, src)      dest = _mm_add_epi32(dest, src);
 #define SHA256_MSG1(dest, src)    dest = _mm_sha256msg1_epu32(dest, src);
-#define SHA25G_MSG2(dest, src)    dest = _mm_sha256msg2_epu32(dest, src);
-
+#define SHA256_MSG2(dest, src)    dest = _mm_sha256msg2_epu32(dest, src);
 
 #define LOAD_SHUFFLE(m, k) \
     m = _mm_loadu_si128((const __m128i *)(const void *)(data + (k) * 16)); \
     m = _mm_shuffle_epi8(m, mask); \
 
-#define SM1(g0, g1, g2, g3) \
-    SHA256_MSG1(g3, g0); \
+#define NNN(m0, m1, m2, m3)
 
-#define SM2(g0, g1, g2, g3) \
-    tmp = _mm_alignr_epi8(g1, g0, 4); \
-    ADD_EPI32(g2, tmp) \
-    SHA25G_MSG2(g2, g1); \
-
-// #define LS0(k, g0, g1, g2, g3) LOAD_SHUFFLE(g0, k)
-// #define LS1(k, g0, g1, g2, g3) LOAD_SHUFFLE(g1, k+1)
-
-
-#define NNN(g0, g1, g2, g3)
+#define SM1(m1, m2, m3, m0) \
+    SHA256_MSG1(m0, m1); \
 
+#define SM2(m2, m3, m0, m1) \
+    ADD_EPI32(m0, _mm_alignr_epi8(m3, m2, 4)) \
+    SHA256_MSG2(m0, m3); \
 
 #define RND2(t0, t1) \
     t0 = _mm_sha256rnds2_epu32(t0, t1, msg);
 
-#define RND2_0(m, k) \
-    msg = _mm_add_epi32(m, *(const __m128i *) (const void *) &K[(k) * 4]); \
-    RND2(state0, state1); \
-    msg = _mm_shuffle_epi32(msg, 0x0E); \
 
 
-#define RND2_1 \
+#define R4(k, m0, m1, m2, m3, OP0, OP1) \
+    msg = _mm_add_epi32(m0, *(const __m128i *) (const void *) &K[(k) * 4]); \
+    RND2(state0, state1); \
+    msg = _mm_shuffle_epi32(msg, 0x0E); \
+    OP0(m0, m1, m2, m3) \
     RND2(state1, state0); \
-
-
-// We use scheme with 3 rounds ahead for SHA256_MSG1 / 2 rounds ahead for SHA256_MSG2
-
-#define R4(k, g0, g1, g2, g3, OP0, OP1) \
-    RND2_0(g0, k) \
-    OP0(g0, g1, g2, g3) \
-    RND2_1 \
-    OP1(g0, g1, g2, g3) \
+    OP1(m0, m1, m2, m3) \
 
 #define R16(k, OP0, OP1, OP2, OP3, OP4, OP5, OP6, OP7) \
-    R4 ( (k)*4+0,        m0,m1,m2,m3, OP0, OP1 ) \
-    R4 ( (k)*4+1,        m1,m2,m3,m0, OP2, OP3 ) \
-    R4 ( (k)*4+2,        m2,m3,m0,m1, OP4, OP5 ) \
-    R4 ( (k)*4+3,        m3,m0,m1,m2, OP6, OP7 ) \
+    R4 ( (k)*4+0, m0,m1,m2,m3, OP0, OP1 ) \
+    R4 ( (k)*4+1, m1,m2,m3,m0, OP2, OP3 ) \
+    R4 ( (k)*4+2, m2,m3,m0,m1, OP4, OP5 ) \
+    R4 ( (k)*4+3, m3,m0,m1,m2, OP6, OP7 ) \
 
 #define PREPARE_STATE \
     tmp    = _mm_shuffle_epi32(state0, 0x1B); /* abcd */ \
@@ -161,8 +130,9 @@ ATTRIB_SHA
 void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks)
 {
   const __m128i mask = _mm_set_epi32(0x0c0d0e0f, 0x08090a0b, 0x04050607, 0x00010203);
-  __m128i tmp;
-  __m128i state0, state1;
+   
+  
+  __m128i tmp, state0, state1;
 
   if (numBlocks == 0)
     return;
@@ -262,22 +232,10 @@ void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_
   #define _ARM_USE_NEW_NEON_INTRINSICS
 #endif
 
-
-
-
-
 #if defined(Z7_MSC_VER_ORIGINAL) && defined(MY_CPU_ARM64)
 #include <arm64_neon.h>
 #else
 
-
-
-
-
-
-
-
-
 #if defined(__clang__) && __clang_major__ < 16
 #if !defined(__ARM_FEATURE_SHA2) && \
     !defined(__ARM_FEATURE_CRYPTO)
@@ -324,41 +282,70 @@ typedef uint32x4_t v128;
 // typedef __n128 v128; // MSVC
 
 #ifdef MY_CPU_BE
-  #define MY_rev32_for_LE(x)
+  #define MY_rev32_for_LE(x) x
 #else
-  #define MY_rev32_for_LE(x) x = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(x)))
+  #define MY_rev32_for_LE(x) vrev32q_u8(x)
 #endif
 
-#define LOAD_128(_p)      (*(const v128 *)(const void *)(_p))
-#define STORE_128(_p, _v) *(v128 *)(void *)(_p) = (_v)
+#if 1 // 0 for debug
+// for arm32: it works slower by some reason than direct code
+/*
+for arm32 it generates:
+MSVC-2022, GCC-9:
+    vld1.32 {d18,d19}, [r10]
+    vst1.32 {d4,d5}, [r3]
+    vld1.8  {d20-d21}, [r4]
+there is no align hint (like [r10:128]).  So instruction allows unaligned access
+*/
+#define LOAD_128_32(_p)       vld1q_u32(_p)
+#define LOAD_128_8(_p)        vld1q_u8 (_p)
+#define STORE_128_32(_p, _v)  vst1q_u32(_p, _v)
+#else
+/*
+for arm32:
+MSVC-2022:
+    vldm r10,{d18,d19}
+    vstm r3,{d4,d5}
+    does it require strict alignment?
+GCC-9:
+    vld1.64 {d30-d31}, [r0:64]
+    vldr  d28, [r0, #16]
+    vldr  d29, [r0, #24]
+    vst1.64 {d30-d31}, [r0:64]
+    vstr  d28, [r0, #16]
+    vstr  d29, [r0, #24]
+there is hint [r0:64], so does it requires 64-bit alignment.
+*/
+#define LOAD_128_32(_p)       (*(const v128 *)(const void *)(_p))
+#define LOAD_128_8(_p)        vreinterpretq_u8_u32(*(const v128 *)(const void *)(_p))
+#define STORE_128_32(_p, _v)  *(v128 *)(void *)(_p) = (_v)
+#endif
 
 #define LOAD_SHUFFLE(m, k) \
-    m = LOAD_128((data + (k) * 16)); \
-    MY_rev32_for_LE(m); \
+    m = vreinterpretq_u32_u8( \
+        MY_rev32_for_LE( \
+        LOAD_128_8(data + (k) * 16))); \
 
 // K array must be aligned for 16-bytes at least.
 extern
 MY_ALIGN(64)
 const UInt32 SHA256_K_ARRAY[64];
-
 #define K SHA256_K_ARRAY
 
-
 #define SHA256_SU0(dest, src)        dest = vsha256su0q_u32(dest, src);
-#define SHA25G_SU1(dest, src2, src3) dest = vsha256su1q_u32(dest, src2, src3);
+#define SHA256_SU1(dest, src2, src3) dest = vsha256su1q_u32(dest, src2, src3);
 
-#define SM1(g0, g1, g2, g3)  SHA256_SU0(g3, g0)
-#define SM2(g0, g1, g2, g3)  SHA25G_SU1(g2, g0, g1)
-#define NNN(g0, g1, g2, g3)
+#define SM1(m0, m1, m2, m3)  SHA256_SU0(m3, m0)
+#define SM2(m0, m1, m2, m3)  SHA256_SU1(m2, m0, m1)
+#define NNN(m0, m1, m2, m3)
 
-
-#define R4(k, g0, g1, g2, g3, OP0, OP1) \
-    msg = vaddq_u32(g0, *(const v128 *) (const void *) &K[(k) * 4]); \
+#define R4(k, m0, m1, m2, m3, OP0, OP1) \
+    msg = vaddq_u32(m0, *(const v128 *) (const void *) &K[(k) * 4]); \
     tmp = state0; \
     state0 = vsha256hq_u32( state0, state1, msg ); \
     state1 = vsha256h2q_u32( state1, tmp, msg ); \
-    OP0(g0, g1, g2, g3); \
-    OP1(g0, g1, g2, g3); \
+    OP0(m0, m1, m2, m3); \
+    OP1(m0, m1, m2, m3); \
 
 
 #define R16(k, OP0, OP1, OP2, OP3, OP4, OP5, OP6, OP7) \
@@ -379,8 +366,8 @@ void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_
   if (numBlocks == 0)
     return;
 
-  state0 = LOAD_128(&state[0]);
-  state1 = LOAD_128(&state[4]);
+  state0 = LOAD_128_32(&state[0]);
+  state1 = LOAD_128_32(&state[4]);
   
   do
   {
@@ -408,8 +395,8 @@ void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_
   }
   while (--numBlocks);
 
-  STORE_128(&state[0], state0);
-  STORE_128(&state[4], state1);
+  STORE_128_32(&state[0], state0);
+  STORE_128_32(&state[4], state1);
 }
 
 #endif // USE_HW_SHA
@@ -443,13 +430,10 @@ void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_
 #endif
 
 
-
 #undef K
 #undef RND2
-#undef RND2_0
-#undef RND2_1
-
 #undef MY_rev32_for_LE
+
 #undef NNN
 #undef LOAD_128
 #undef STORE_128
@@ -457,7 +441,7 @@ void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_
 #undef SM1
 #undef SM2
 
-#undef NNN
+
 #undef R4
 #undef R16
 #undef PREPARE_STATE
diff --git a/C/Sha3.c b/C/Sha3.c
new file mode 100644
index 0000000..be972d6
--- /dev/null
+++ b/C/Sha3.c
@@ -0,0 +1,359 @@
+/* Sha3.c -- SHA-3 Hash
+: Igor Pavlov : Public domain
+This code is based on public domain code from Wei Dai's Crypto++ library. */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "Sha3.h"
+#include "RotateDefs.h"
+#include "CpuArch.h"
+
+#define U64C(x) UINT64_CONST(x)
+
+static
+MY_ALIGN(64)
+const UInt64 SHA3_K_ARRAY[24] =
+{
+  U64C(0x0000000000000001), U64C(0x0000000000008082),
+  U64C(0x800000000000808a), U64C(0x8000000080008000),
+  U64C(0x000000000000808b), U64C(0x0000000080000001),
+  U64C(0x8000000080008081), U64C(0x8000000000008009),
+  U64C(0x000000000000008a), U64C(0x0000000000000088),
+  U64C(0x0000000080008009), U64C(0x000000008000000a),
+  U64C(0x000000008000808b), U64C(0x800000000000008b),
+  U64C(0x8000000000008089), U64C(0x8000000000008003),
+  U64C(0x8000000000008002), U64C(0x8000000000000080),
+  U64C(0x000000000000800a), U64C(0x800000008000000a),
+  U64C(0x8000000080008081), U64C(0x8000000000008080),
+  U64C(0x0000000080000001), U64C(0x8000000080008008)
+};
+
+void Sha3_Init(CSha3 *p)
+{
+  p->count = 0;
+  memset(p->state, 0, sizeof(p->state));
+}
+
+#define GET_state(i, a)   UInt64 a = state[i];
+#define SET_state(i, a)   state[i] = a;
+
+#define LS_5(M, i, a0,a1,a2,a3,a4) \
+        M ((i) * 5    , a0) \
+        M ((i) * 5 + 1, a1) \
+        M ((i) * 5 + 2, a2) \
+        M ((i) * 5 + 3, a3) \
+        M ((i) * 5 + 4, a4) \
+
+#define LS_25(M) \
+        LS_5 (M, 0, a50, a51, a52, a53, a54) \
+        LS_5 (M, 1, a60, a61, a62, a63, a64) \
+        LS_5 (M, 2, a70, a71, a72, a73, a74) \
+        LS_5 (M, 3, a80, a81, a82, a83, a84) \
+        LS_5 (M, 4, a90, a91, a92, a93, a94) \
+
+
+#define XOR_1(i, a0) \
+        a0 ^= GetUi64(data + (i) * 8); \
+
+#define XOR_4(i, a0,a1,a2,a3) \
+        XOR_1 ((i)    , a0); \
+        XOR_1 ((i) + 1, a1); \
+        XOR_1 ((i) + 2, a2); \
+        XOR_1 ((i) + 3, a3); \
+
+#define D(d,b1,b2) \
+        d = b1 ^ Z7_ROTL64(b2, 1);
+
+#define D5 \
+        D (d0, c4, c1) \
+        D (d1, c0, c2) \
+        D (d2, c1, c3) \
+        D (d3, c2, c4) \
+        D (d4, c3, c0) \
+
+#define C0(c,a,d) \
+        c = a ^ d; \
+
+#define C(c,a,d,k) \
+        c = a ^ d; \
+        c = Z7_ROTL64(c, k); \
+
+#define E4(e1,e2,e3,e4) \
+        e1 = c1 ^ (~c2 & c3); \
+        e2 = c2 ^ (~c3 & c4); \
+        e3 = c3 ^ (~c4 & c0); \
+        e4 = c4 ^ (~c0 & c1); \
+
+#define CK(   v0,w0,    \
+              v1,w1,k1, \
+              v2,w2,k2, \
+              v3,w3,k3, \
+              v4,w4,k4, e0,e1,e2,e3,e4, keccak_c) \
+        C0(c0,v0,w0)    \
+        C (c1,v1,w1,k1) \
+        C (c2,v2,w2,k2) \
+        C (c3,v3,w3,k3) \
+        C (c4,v4,w4,k4) \
+        e0 = c0 ^ (~c1 & c2) ^ keccak_c; \
+        E4(e1,e2,e3,e4) \
+
+#define CE(   v0,w0,k0, \
+              v1,w1,k1, \
+              v2,w2,k2, \
+              v3,w3,k3, \
+              v4,w4,k4, e0,e1,e2,e3,e4) \
+        C (c0,v0,w0,k0) \
+        C (c1,v1,w1,k1) \
+        C (c2,v2,w2,k2) \
+        C (c3,v3,w3,k3) \
+        C (c4,v4,w4,k4) \
+        e0 = c0 ^ (~c1 & c2); \
+        E4(e1,e2,e3,e4) \
+
+// numBlocks != 0
+static
+Z7_NO_INLINE
+void Z7_FASTCALL Sha3_UpdateBlocks(UInt64 state[SHA3_NUM_STATE_WORDS],
+    const Byte *data, size_t numBlocks, size_t blockSize)
+{
+  LS_25 (GET_state)
+
+  do
+  {
+    unsigned round;
+                              XOR_4 ( 0, a50, a51, a52, a53)
+                              XOR_4 ( 4, a54, a60, a61, a62)
+                              XOR_1 ( 8, a63)
+    if (blockSize > 8 *  9) { XOR_4 ( 9, a64, a70, a71, a72)  // sha3-384
+    if (blockSize > 8 * 13) { XOR_4 (13, a73, a74, a80, a81)  // sha3-256
+    if (blockSize > 8 * 17) { XOR_1 (17, a82)                 // sha3-224
+    if (blockSize > 8 * 18) { XOR_1 (18, a83)                 // shake128
+                              XOR_1 (19, a84)
+                              XOR_1 (20, a90) }}}}
+    data += blockSize;
+
+    for (round = 0; round < 24; round += 2)
+    {
+      UInt64 c0, c1, c2, c3, c4;
+      UInt64 d0, d1, d2, d3, d4;
+      UInt64 e50, e51, e52, e53, e54;
+      UInt64 e60, e61, e62, e63, e64;
+      UInt64 e70, e71, e72, e73, e74;
+      UInt64 e80, e81, e82, e83, e84;
+      UInt64 e90, e91, e92, e93, e94;
+
+      c0 = a50^a60^a70^a80^a90;
+      c1 = a51^a61^a71^a81^a91;
+      c2 = a52^a62^a72^a82^a92;
+      c3 = a53^a63^a73^a83^a93;
+      c4 = a54^a64^a74^a84^a94;
+      D5
+      CK( a50, d0,
+          a61, d1, 44,
+          a72, d2, 43,
+          a83, d3, 21,
+          a94, d4, 14, e50, e51, e52, e53, e54, SHA3_K_ARRAY[round])
+      CE( a53, d3, 28,
+          a64, d4, 20,
+          a70, d0,  3,
+          a81, d1, 45,
+          a92, d2, 61, e60, e61, e62, e63, e64)
+      CE( a51, d1,  1,
+          a62, d2,  6,
+          a73, d3, 25,
+          a84, d4,  8,
+          a90, d0, 18, e70, e71, e72, e73, e74)
+      CE( a54, d4, 27,
+          a60, d0, 36,
+          a71, d1, 10,
+          a82, d2, 15,
+          a93, d3, 56, e80, e81, e82, e83, e84)
+      CE( a52, d2, 62,
+          a63, d3, 55,
+          a74, d4, 39,
+          a80, d0, 41,
+          a91, d1,  2, e90, e91, e92, e93, e94)
+      
+      // ---------- ROUND + 1 ----------
+
+      c0 = e50^e60^e70^e80^e90;
+      c1 = e51^e61^e71^e81^e91;
+      c2 = e52^e62^e72^e82^e92;
+      c3 = e53^e63^e73^e83^e93;
+      c4 = e54^e64^e74^e84^e94;
+      D5
+      CK( e50, d0,
+          e61, d1, 44,
+          e72, d2, 43,
+          e83, d3, 21,
+          e94, d4, 14, a50, a51, a52, a53, a54, SHA3_K_ARRAY[(size_t)round + 1])
+      CE( e53, d3, 28,
+          e64, d4, 20,
+          e70, d0,  3,
+          e81, d1, 45,
+          e92, d2, 61, a60, a61, a62, a63, a64)
+      CE( e51, d1,  1,
+          e62, d2,  6,
+          e73, d3, 25,
+          e84, d4,  8,
+          e90, d0, 18, a70, a71, a72, a73, a74)
+      CE (e54, d4, 27,
+          e60, d0, 36,
+          e71, d1, 10,
+          e82, d2, 15,
+          e93, d3, 56, a80, a81, a82, a83, a84)
+      CE (e52, d2, 62,
+          e63, d3, 55,
+          e74, d4, 39,
+          e80, d0, 41,
+          e91, d1,  2, a90, a91, a92, a93, a94)
+    }
+  }
+  while (--numBlocks);
+
+  LS_25 (SET_state)
+}
+
+
+#define Sha3_UpdateBlock(p) \
+        Sha3_UpdateBlocks(p->state, p->buffer, 1, p->blockSize)
+
+void Sha3_Update(CSha3 *p, const Byte *data, size_t size)
+{
+/*
+  for (;;)
+  {
+    if (size == 0)
+      return;
+    unsigned cur = p->blockSize - p->count;
+    if (cur > size)
+      cur = (unsigned)size;
+    size -= cur;
+    unsigned pos = p->count;
+    p->count = pos + cur;
+    while (pos & 7)
+    {
+      if (cur == 0)
+        return;
+      Byte *pb = &(((Byte *)p->state)[pos]);
+      *pb = (Byte)(*pb ^ *data++);
+      cur--;
+      pos++;
+    }
+    if (cur >= 8)
+    {
+      do
+      {
+        *(UInt64 *)(void *)&(((Byte *)p->state)[pos]) ^= GetUi64(data);
+        data += 8;
+        pos += 8;
+        cur -= 8;
+      }
+      while (cur >= 8);
+    }
+    if (pos != p->blockSize)
+    {
+      if (cur)
+      {
+        Byte *pb = &(((Byte *)p->state)[pos]);
+        do
+        {
+          *pb = (Byte)(*pb ^ *data++);
+          pb++;
+        }
+        while (--cur);
+      }
+      return;
+    }
+    Sha3_UpdateBlock(p->state);
+    p->count = 0;
+  }
+*/
+  if (size == 0)
+    return;
+  {
+    const unsigned pos = p->count;
+    const unsigned num = p->blockSize - pos;
+    if (num > size)
+    {
+      p->count = pos + (unsigned)size;
+      memcpy(p->buffer + pos, data, size);
+      return;
+    }
+    if (pos != 0)
+    {
+      size -= num;
+      memcpy(p->buffer + pos, data, num);
+      data += num;
+      Sha3_UpdateBlock(p);
+    }
+  }
+  if (size >= p->blockSize)
+  {
+    const size_t numBlocks = size / p->blockSize;
+    const Byte *dataOld = data;
+    data += numBlocks * p->blockSize;
+    size = (size_t)(dataOld + size - data);
+    Sha3_UpdateBlocks(p->state, dataOld, numBlocks, p->blockSize);
+  }
+  p->count = (unsigned)size;
+  if (size)
+    memcpy(p->buffer, data, size);
+}
+
+
+// we support only (digestSize % 4 == 0) cases
+void Sha3_Final(CSha3 *p, Byte *digest, unsigned digestSize, unsigned shake)
+{
+  memset(p->buffer + p->count, 0, p->blockSize - p->count);
+  // we write bits markers from low to higher in current byte:
+  //   - if sha-3 : 2 bits : 0,1
+  //   - if shake : 4 bits : 1111
+  // then we write bit 1 to same byte.
+  // And we write bit 1 to highest bit of last byte of block.
+  p->buffer[p->count] = (Byte)(shake ? 0x1f : 0x06);
+  // we need xor operation (^= 0x80) here because we must write 0x80 bit
+  // to same byte as (0x1f : 0x06), if (p->count == p->blockSize - 1) !!!
+  p->buffer[p->blockSize - 1] ^= 0x80;
+/*
+  ((Byte *)p->state)[p->count] ^= (Byte)(shake ? 0x1f : 0x06);
+  ((Byte *)p->state)[p->blockSize - 1] ^= 0x80;
+*/
+  Sha3_UpdateBlock(p);
+#if 1 && defined(MY_CPU_LE)
+  memcpy(digest, p->state, digestSize);
+#else
+  {
+    const unsigned numWords = digestSize >> 3;
+    unsigned i;
+    for (i = 0; i < numWords; i++)
+    {
+      const UInt64 v = p->state[i];
+      SetUi64(digest, v)
+      digest += 8;
+    }
+    if (digestSize & 4) // for SHA3-224
+    {
+      const UInt32 v = (UInt32)p->state[numWords];
+      SetUi32(digest, v)
+    }
+  }
+#endif
+  Sha3_Init(p);
+}
+
+#undef GET_state
+#undef SET_state
+#undef LS_5
+#undef LS_25
+#undef XOR_1
+#undef XOR_4
+#undef D
+#undef D5
+#undef C0
+#undef C
+#undef E4
+#undef CK
+#undef CE
diff --git a/C/Sha3.h b/C/Sha3.h
new file mode 100644
index 0000000..c5909c9
--- /dev/null
+++ b/C/Sha3.h
@@ -0,0 +1,36 @@
+/* Sha3.h -- SHA-3 Hash
+: Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_MD5_H
+#define ZIP7_INC_MD5_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define SHA3_NUM_STATE_WORDS  25
+
+#define SHA3_BLOCK_SIZE_FROM_DIGEST_SIZE(digestSize) \
+    (SHA3_NUM_STATE_WORDS * 8 - (digestSize) * 2)
+
+typedef struct
+{
+  UInt32 count;     // < blockSize
+  UInt32 blockSize; // <= SHA3_NUM_STATE_WORDS * 8
+  UInt64 _pad1[3];
+  // we want 32-bytes alignment here
+  UInt64 state[SHA3_NUM_STATE_WORDS];
+  UInt64 _pad2[3];
+  // we want 64-bytes alignment here
+  Byte buffer[SHA3_NUM_STATE_WORDS * 8]; // last bytes will be unused with predefined blockSize values
+} CSha3;
+
+#define Sha3_SET_blockSize(p, blockSize) { (p)->blockSize = (blockSize); }
+
+void Sha3_Init(CSha3 *p);
+void Sha3_Update(CSha3 *p, const Byte *data, size_t size);
+void Sha3_Final(CSha3 *p, Byte *digest, unsigned digestSize, unsigned shake);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Sha512.c b/C/Sha512.c
new file mode 100644
index 0000000..f0787fd
--- /dev/null
+++ b/C/Sha512.c
@@ -0,0 +1,711 @@
+/* Sha512.c -- SHA-512 Hash
+: Igor Pavlov : Public domain
+This code is based on public domain code from Wei Dai's Crypto++ library. */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "Sha512.h"
+#include "RotateDefs.h"
+#include "CpuArch.h"
+
+#ifdef MY_CPU_X86_OR_AMD64
+  #if   defined(Z7_LLVM_CLANG_VERSION)  && (Z7_LLVM_CLANG_VERSION  >= 170001) \
+     || defined(Z7_APPLE_CLANG_VERSION) && (Z7_APPLE_CLANG_VERSION >= 170001) \
+     || defined(Z7_GCC_VERSION)         && (Z7_GCC_VERSION         >= 140000) \
+     || defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 2400) && (__INTEL_COMPILER <= 9900) \
+     || defined(_MSC_VER) && (_MSC_VER >= 1940)
+      #define Z7_COMPILER_SHA512_SUPPORTED
+  #endif
+#elif defined(MY_CPU_ARM64) && defined(MY_CPU_LE)
+  #if defined(__ARM_FEATURE_SHA512)
+    #define Z7_COMPILER_SHA512_SUPPORTED
+  #else
+    #if (defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 130000) \
+           || defined(__GNUC__) && (__GNUC__ >= 9) \
+        ) \
+      || defined(Z7_MSC_VER_ORIGINAL) && (_MSC_VER >= 1940) // fix it
+      #define Z7_COMPILER_SHA512_SUPPORTED
+    #endif
+  #endif
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void Z7_FASTCALL Sha512_UpdateBlocks(UInt64 state[8], const Byte *data, size_t numBlocks);
+
+#ifdef Z7_COMPILER_SHA512_SUPPORTED
+  void Z7_FASTCALL Sha512_UpdateBlocks_HW(UInt64 state[8], const Byte *data, size_t numBlocks);
+
+  static SHA512_FUNC_UPDATE_BLOCKS g_SHA512_FUNC_UPDATE_BLOCKS = Sha512_UpdateBlocks;
+  static SHA512_FUNC_UPDATE_BLOCKS g_SHA512_FUNC_UPDATE_BLOCKS_HW;
+
+  #define SHA512_UPDATE_BLOCKS(p) p->v.vars.func_UpdateBlocks
+#else
+  #define SHA512_UPDATE_BLOCKS(p) Sha512_UpdateBlocks
+#endif
+
+
+BoolInt Sha512_SetFunction(CSha512 *p, unsigned algo)
+{
+  SHA512_FUNC_UPDATE_BLOCKS func = Sha512_UpdateBlocks;
+  
+  #ifdef Z7_COMPILER_SHA512_SUPPORTED
+    if (algo != SHA512_ALGO_SW)
+    {
+      if (algo == SHA512_ALGO_DEFAULT)
+        func = g_SHA512_FUNC_UPDATE_BLOCKS;
+      else
+      {
+        if (algo != SHA512_ALGO_HW)
+          return False;
+        func = g_SHA512_FUNC_UPDATE_BLOCKS_HW;
+        if (!func)
+          return False;
+      }
+    }
+  #else
+    if (algo > 1)
+      return False;
+  #endif
+
+  p->v.vars.func_UpdateBlocks = func;
+  return True;
+}
+
+
+/* define it for speed optimization */
+
+#if 0 // 1 for size optimization
+  #define STEP_PRE 1
+  #define STEP_MAIN 1
+#else
+  #define STEP_PRE 2
+  #define STEP_MAIN 4
+  // #define Z7_SHA512_UNROLL
+#endif
+
+#undef Z7_SHA512_BIG_W
+#if STEP_MAIN != 16
+  #define Z7_SHA512_BIG_W
+#endif
+
+
+#define U64C(x) UINT64_CONST(x)
+
+static MY_ALIGN(64) const UInt64 SHA512_INIT_ARRAYS[4][8] = {
+{ U64C(0x8c3d37c819544da2), U64C(0x73e1996689dcd4d6), U64C(0x1dfab7ae32ff9c82), U64C(0x679dd514582f9fcf),
+  U64C(0x0f6d2b697bd44da8), U64C(0x77e36f7304c48942), U64C(0x3f9d85a86a1d36c8), U64C(0x1112e6ad91d692a1)
+},
+{ U64C(0x22312194fc2bf72c), U64C(0x9f555fa3c84c64c2), U64C(0x2393b86b6f53b151), U64C(0x963877195940eabd),
+  U64C(0x96283ee2a88effe3), U64C(0xbe5e1e2553863992), U64C(0x2b0199fc2c85b8aa), U64C(0x0eb72ddc81c52ca2)
+},
+{ U64C(0xcbbb9d5dc1059ed8), U64C(0x629a292a367cd507), U64C(0x9159015a3070dd17), U64C(0x152fecd8f70e5939),
+  U64C(0x67332667ffc00b31), U64C(0x8eb44a8768581511), U64C(0xdb0c2e0d64f98fa7), U64C(0x47b5481dbefa4fa4)
+},
+{ U64C(0x6a09e667f3bcc908), U64C(0xbb67ae8584caa73b), U64C(0x3c6ef372fe94f82b), U64C(0xa54ff53a5f1d36f1),
+  U64C(0x510e527fade682d1), U64C(0x9b05688c2b3e6c1f), U64C(0x1f83d9abfb41bd6b), U64C(0x5be0cd19137e2179)
+}};
+
+void Sha512_InitState(CSha512 *p, unsigned digestSize)
+{
+  p->v.vars.count = 0;
+  memcpy(p->state, SHA512_INIT_ARRAYS[(size_t)(digestSize >> 4) - 1], sizeof(p->state));
+}
+
+void Sha512_Init(CSha512 *p, unsigned digestSize)
+{
+  p->v.vars.func_UpdateBlocks =
+  #ifdef Z7_COMPILER_SHA512_SUPPORTED
+      g_SHA512_FUNC_UPDATE_BLOCKS;
+  #else
+      NULL;
+  #endif
+  Sha512_InitState(p, digestSize);
+}
+
+#define S0(x) (Z7_ROTR64(x,28) ^ Z7_ROTR64(x,34) ^ Z7_ROTR64(x,39))
+#define S1(x) (Z7_ROTR64(x,14) ^ Z7_ROTR64(x,18) ^ Z7_ROTR64(x,41))
+#define s0(x) (Z7_ROTR64(x, 1) ^ Z7_ROTR64(x, 8) ^ (x >> 7))
+#define s1(x) (Z7_ROTR64(x,19) ^ Z7_ROTR64(x,61) ^ (x >> 6))
+
+#define Ch(x,y,z) (z^(x&(y^z)))
+#define Maj(x,y,z) ((x&y)|(z&(x|y)))
+
+
+#define W_PRE(i) (W[(i) + (size_t)(j)] = GetBe64(data + ((size_t)(j) + i) * 8))
+
+#define blk2_main(j, i)  s1(w(j, (i)-2)) + w(j, (i)-7) + s0(w(j, (i)-15))
+
+#ifdef Z7_SHA512_BIG_W
+    // we use +i instead of +(i) to change the order to solve CLANG compiler warning for signed/unsigned.
+    #define w(j, i)     W[(size_t)(j) + i]
+    #define blk2(j, i)  (w(j, i) = w(j, (i)-16) + blk2_main(j, i))
+#else
+    #if STEP_MAIN == 16
+        #define w(j, i)  W[(i) & 15]
+    #else
+        #define w(j, i)  W[((size_t)(j) + (i)) & 15]
+    #endif
+    #define blk2(j, i)  (w(j, i) += blk2_main(j, i))
+#endif
+
+#define W_MAIN(i)  blk2(j, i)
+
+
+#define T1(wx, i) \
+    tmp = h + S1(e) + Ch(e,f,g) + K[(i)+(size_t)(j)] + wx(i); \
+    h = g; \
+    g = f; \
+    f = e; \
+    e = d + tmp; \
+    tmp += S0(a) + Maj(a, b, c); \
+    d = c; \
+    c = b; \
+    b = a; \
+    a = tmp; \
+
+#define R1_PRE(i)  T1( W_PRE, i)
+#define R1_MAIN(i) T1( W_MAIN, i)
+
+#if (!defined(Z7_SHA512_UNROLL) || STEP_MAIN < 8) && (STEP_MAIN >= 4)
+#define R2_MAIN(i) \
+    R1_MAIN(i) \
+    R1_MAIN(i + 1) \
+
+#endif
+
+
+
+#if defined(Z7_SHA512_UNROLL) && STEP_MAIN >= 8
+
+#define T4( a,b,c,d,e,f,g,h, wx, i) \
+    h += S1(e) + Ch(e,f,g) + K[(i)+(size_t)(j)] + wx(i); \
+    tmp = h; \
+    h += d; \
+    d = tmp + S0(a) + Maj(a, b, c); \
+
+#define R4( wx, i) \
+    T4 ( a,b,c,d,e,f,g,h, wx, (i  )); \
+    T4 ( d,a,b,c,h,e,f,g, wx, (i+1)); \
+    T4 ( c,d,a,b,g,h,e,f, wx, (i+2)); \
+    T4 ( b,c,d,a,f,g,h,e, wx, (i+3)); \
+
+#define R4_PRE(i)  R4( W_PRE, i)
+#define R4_MAIN(i) R4( W_MAIN, i)
+
+
+#define T8( a,b,c,d,e,f,g,h, wx, i) \
+    h += S1(e) + Ch(e,f,g) + K[(i)+(size_t)(j)] + wx(i); \
+    d += h; \
+    h += S0(a) + Maj(a, b, c); \
+
+#define R8( wx, i) \
+    T8 ( a,b,c,d,e,f,g,h, wx, i  ); \
+    T8 ( h,a,b,c,d,e,f,g, wx, i+1); \
+    T8 ( g,h,a,b,c,d,e,f, wx, i+2); \
+    T8 ( f,g,h,a,b,c,d,e, wx, i+3); \
+    T8 ( e,f,g,h,a,b,c,d, wx, i+4); \
+    T8 ( d,e,f,g,h,a,b,c, wx, i+5); \
+    T8 ( c,d,e,f,g,h,a,b, wx, i+6); \
+    T8 ( b,c,d,e,f,g,h,a, wx, i+7); \
+
+#define R8_PRE(i)  R8( W_PRE, i)
+#define R8_MAIN(i) R8( W_MAIN, i)
+
+#endif
+
+
+extern
+MY_ALIGN(64) const UInt64 SHA512_K_ARRAY[80];
+MY_ALIGN(64) const UInt64 SHA512_K_ARRAY[80] = {
+  U64C(0x428a2f98d728ae22), U64C(0x7137449123ef65cd), U64C(0xb5c0fbcfec4d3b2f), U64C(0xe9b5dba58189dbbc),
+  U64C(0x3956c25bf348b538), U64C(0x59f111f1b605d019), U64C(0x923f82a4af194f9b), U64C(0xab1c5ed5da6d8118),
+  U64C(0xd807aa98a3030242), U64C(0x12835b0145706fbe), U64C(0x243185be4ee4b28c), U64C(0x550c7dc3d5ffb4e2),
+  U64C(0x72be5d74f27b896f), U64C(0x80deb1fe3b1696b1), U64C(0x9bdc06a725c71235), U64C(0xc19bf174cf692694),
+  U64C(0xe49b69c19ef14ad2), U64C(0xefbe4786384f25e3), U64C(0x0fc19dc68b8cd5b5), U64C(0x240ca1cc77ac9c65),
+  U64C(0x2de92c6f592b0275), U64C(0x4a7484aa6ea6e483), U64C(0x5cb0a9dcbd41fbd4), U64C(0x76f988da831153b5),
+  U64C(0x983e5152ee66dfab), U64C(0xa831c66d2db43210), U64C(0xb00327c898fb213f), U64C(0xbf597fc7beef0ee4),
+  U64C(0xc6e00bf33da88fc2), U64C(0xd5a79147930aa725), U64C(0x06ca6351e003826f), U64C(0x142929670a0e6e70),
+  U64C(0x27b70a8546d22ffc), U64C(0x2e1b21385c26c926), U64C(0x4d2c6dfc5ac42aed), U64C(0x53380d139d95b3df),
+  U64C(0x650a73548baf63de), U64C(0x766a0abb3c77b2a8), U64C(0x81c2c92e47edaee6), U64C(0x92722c851482353b),
+  U64C(0xa2bfe8a14cf10364), U64C(0xa81a664bbc423001), U64C(0xc24b8b70d0f89791), U64C(0xc76c51a30654be30),
+  U64C(0xd192e819d6ef5218), U64C(0xd69906245565a910), U64C(0xf40e35855771202a), U64C(0x106aa07032bbd1b8),
+  U64C(0x19a4c116b8d2d0c8), U64C(0x1e376c085141ab53), U64C(0x2748774cdf8eeb99), U64C(0x34b0bcb5e19b48a8),
+  U64C(0x391c0cb3c5c95a63), U64C(0x4ed8aa4ae3418acb), U64C(0x5b9cca4f7763e373), U64C(0x682e6ff3d6b2b8a3),
+  U64C(0x748f82ee5defb2fc), U64C(0x78a5636f43172f60), U64C(0x84c87814a1f0ab72), U64C(0x8cc702081a6439ec),
+  U64C(0x90befffa23631e28), U64C(0xa4506cebde82bde9), U64C(0xbef9a3f7b2c67915), U64C(0xc67178f2e372532b),
+  U64C(0xca273eceea26619c), U64C(0xd186b8c721c0c207), U64C(0xeada7dd6cde0eb1e), U64C(0xf57d4f7fee6ed178),
+  U64C(0x06f067aa72176fba), U64C(0x0a637dc5a2c898a6), U64C(0x113f9804bef90dae), U64C(0x1b710b35131c471b),
+  U64C(0x28db77f523047d84), U64C(0x32caab7b40c72493), U64C(0x3c9ebe0a15c9bebc), U64C(0x431d67c49c100d4c),
+  U64C(0x4cc5d4becb3e42b6), U64C(0x597f299cfc657e2a), U64C(0x5fcb6fab3ad6faec), U64C(0x6c44198c4a475817)
+};
+
+#define K SHA512_K_ARRAY
+
+Z7_NO_INLINE
+void Z7_FASTCALL Sha512_UpdateBlocks(UInt64 state[8], const Byte *data, size_t numBlocks)
+{
+  UInt64 W
+#ifdef Z7_SHA512_BIG_W
+      [80];
+#else
+      [16];
+#endif
+  unsigned j;
+  UInt64 a,b,c,d,e,f,g,h;
+#if !defined(Z7_SHA512_UNROLL) || (STEP_MAIN <= 4) || (STEP_PRE <= 4)
+  UInt64 tmp;
+#endif
+
+  if (numBlocks == 0) return;
+  
+  a = state[0];
+  b = state[1];
+  c = state[2];
+  d = state[3];
+  e = state[4];
+  f = state[5];
+  g = state[6];
+  h = state[7];
+
+  do
+  {
+
+  for (j = 0; j < 16; j += STEP_PRE)
+  {
+    #if STEP_PRE > 4
+
+      #if STEP_PRE < 8
+      R4_PRE(0);
+      #else
+      R8_PRE(0);
+      #if STEP_PRE == 16
+      R8_PRE(8);
+      #endif
+      #endif
+
+    #else
+
+      R1_PRE(0)
+      #if STEP_PRE >= 2
+      R1_PRE(1)
+      #if STEP_PRE >= 4
+      R1_PRE(2)
+      R1_PRE(3)
+      #endif
+      #endif
+    
+    #endif
+  }
+
+  for (j = 16; j < 80; j += STEP_MAIN)
+  {
+    #if defined(Z7_SHA512_UNROLL) && STEP_MAIN >= 8
+
+      #if STEP_MAIN < 8
+      R4_MAIN(0)
+      #else
+      R8_MAIN(0)
+      #if STEP_MAIN == 16
+      R8_MAIN(8)
+      #endif
+      #endif
+
+    #else
+      
+      R1_MAIN(0)
+      #if STEP_MAIN >= 2
+      R1_MAIN(1)
+      #if STEP_MAIN >= 4
+      R2_MAIN(2)
+      #if STEP_MAIN >= 8
+      R2_MAIN(4)
+      R2_MAIN(6)
+      #if STEP_MAIN >= 16
+      R2_MAIN(8)
+      R2_MAIN(10)
+      R2_MAIN(12)
+      R2_MAIN(14)
+      #endif
+      #endif
+      #endif
+      #endif
+    #endif
+  }
+
+  a += state[0]; state[0] = a;
+  b += state[1]; state[1] = b;
+  c += state[2]; state[2] = c;
+  d += state[3]; state[3] = d;
+  e += state[4]; state[4] = e;
+  f += state[5]; state[5] = f;
+  g += state[6]; state[6] = g;
+  h += state[7]; state[7] = h;
+
+  data += SHA512_BLOCK_SIZE;
+  }
+  while (--numBlocks);
+}
+
+
+#define Sha512_UpdateBlock(p) SHA512_UPDATE_BLOCKS(p)(p->state, p->buffer, 1)
+
+void Sha512_Update(CSha512 *p, const Byte *data, size_t size)
+{
+  if (size == 0)
+    return;
+  {
+    const unsigned pos = (unsigned)p->v.vars.count & (SHA512_BLOCK_SIZE - 1);
+    const unsigned num = SHA512_BLOCK_SIZE - pos;
+    p->v.vars.count += size;
+    if (num > size)
+    {
+      memcpy(p->buffer + pos, data, size);
+      return;
+    }
+    if (pos != 0)
+    {
+      size -= num;
+      memcpy(p->buffer + pos, data, num);
+      data += num;
+      Sha512_UpdateBlock(p);
+    }
+  }
+  {
+    const size_t numBlocks = size >> 7;
+    // if (numBlocks)
+    SHA512_UPDATE_BLOCKS(p)(p->state, data, numBlocks);
+    size &= SHA512_BLOCK_SIZE - 1;
+    if (size == 0)
+      return;
+    data += (numBlocks << 7);
+    memcpy(p->buffer, data, size);
+  }
+}
+
+
+void Sha512_Final(CSha512 *p, Byte *digest, unsigned digestSize)
+{
+  unsigned pos = (unsigned)p->v.vars.count & (SHA512_BLOCK_SIZE - 1);
+  p->buffer[pos++] = 0x80;
+  if (pos > (SHA512_BLOCK_SIZE - 8 * 2))
+  {
+    while (pos != SHA512_BLOCK_SIZE) { p->buffer[pos++] = 0; }
+    // memset(&p->buf.buffer[pos], 0, SHA512_BLOCK_SIZE - pos);
+    Sha512_UpdateBlock(p);
+    pos = 0;
+  }
+  memset(&p->buffer[pos], 0, (SHA512_BLOCK_SIZE - 8 * 2) - pos);
+  {
+    const UInt64 numBits = p->v.vars.count << 3;
+    SetBe64(p->buffer + SHA512_BLOCK_SIZE - 8 * 2, 0) // = (p->v.vars.count >> (64 - 3)); (high 64-bits)
+    SetBe64(p->buffer + SHA512_BLOCK_SIZE - 8 * 1, numBits)
+  }
+  Sha512_UpdateBlock(p);
+#if 1 && defined(MY_CPU_BE)
+  memcpy(digest, p->state, digestSize);
+#else
+  {
+    const unsigned numWords = digestSize >> 3;
+    unsigned i;
+    for (i = 0; i < numWords; i++)
+    {
+      const UInt64 v = p->state[i];
+      SetBe64(digest, v)
+      digest += 8;
+    }
+    if (digestSize & 4) // digestSize == SHA512_224_DIGEST_SIZE
+    {
+      const UInt32 v = (UInt32)((p->state[numWords]) >> 32);
+      SetBe32(digest, v)
+    }
+  }
+#endif
+  Sha512_InitState(p, digestSize);
+}
+
+
+
+// #define Z7_SHA512_PROBE_DEBUG // for debug
+
+#if defined(Z7_SHA512_PROBE_DEBUG) || defined(Z7_COMPILER_SHA512_SUPPORTED)
+
+#if defined(Z7_SHA512_PROBE_DEBUG) \
+    || defined(_WIN32) && defined(MY_CPU_ARM64)
+#ifndef Z7_SHA512_USE_PROBE
+#define Z7_SHA512_USE_PROBE
+#endif
+#endif
+
+#ifdef Z7_SHA512_USE_PROBE
+
+#ifdef Z7_SHA512_PROBE_DEBUG
+#include <stdio.h>
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#if 0 || !defined(_MSC_VER) // 1 || : for debug LONGJMP mode
+// MINGW doesn't support __try. So we use signal() / longjmp().
+// Note: signal() / longjmp() probably is not thread-safe.
+// So we must call Sha512Prepare() from main thread at program start.
+#ifndef Z7_SHA512_USE_LONGJMP
+#define Z7_SHA512_USE_LONGJMP
+#endif
+#endif
+
+#ifdef Z7_SHA512_USE_LONGJMP
+#include <signal.h>
+#include <setjmp.h>
+static jmp_buf g_Sha512_jmp_buf;
+// static int g_Sha512_Unsupported;
+
+#if defined(__GNUC__) && (__GNUC__ >= 8) \
+    || defined(__clang__) && (__clang_major__ >= 3)
+  __attribute__((noreturn))
+#endif
+static void Z7_CDECL Sha512_signal_Handler(int v)
+{
+  PRF(printf("======== Sha512_signal_Handler = %x\n", (unsigned)v);)
+  // g_Sha512_Unsupported = 1;
+  longjmp(g_Sha512_jmp_buf, 1);
+}
+#endif // Z7_SHA512_USE_LONGJMP
+
+
+#if defined(_WIN32)
+#include "7zWindows.h"
+#endif
+
+#if defined(MY_CPU_ARM64)
+// #define Z7_SHA512_USE_SIMPLIFIED_PROBE // for debug
+#endif
+
+#ifdef Z7_SHA512_USE_SIMPLIFIED_PROBE
+#include <arm_neon.h>
+#if defined(__clang__)
+  __attribute__((__target__("sha3")))
+#elif !defined(_MSC_VER)
+  __attribute__((__target__("arch=armv8.2-a+sha3")))
+#endif
+#endif
+static BoolInt CPU_IsSupported_SHA512_Probe(void)
+{
+  PRF(printf("\n== CPU_IsSupported_SHA512_Probe\n");)
+#if defined(_WIN32) && defined(MY_CPU_ARM64)
+  // we have no SHA512 flag for IsProcessorFeaturePresent() still.
+  if (!CPU_IsSupported_CRYPTO())
+    return False;
+  PRF(printf("==== Registry check\n");)
+  {
+    // we can't read ID_AA64ISAR0_EL1 register from application.
+    // but ID_AA64ISAR0_EL1 register is mapped to "CP 4030" registry value.
+    HKEY key = NULL;
+    LONG res = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+        TEXT("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"),
+        0, KEY_READ, &key);
+    if (res != ERROR_SUCCESS)
+      return False;
+    {
+      DWORD type = 0;
+      DWORD count = sizeof(UInt64);
+      UInt64 val = 0;
+      res = RegQueryValueEx(key, TEXT("CP 4030"), NULL,
+          &type, (LPBYTE)&val, &count);
+      RegCloseKey(key);
+      if (res != ERROR_SUCCESS
+          || type != REG_QWORD
+          || count != sizeof(UInt64)
+          || ((unsigned)(val >> 12) & 0xf) != 2)
+        return False;
+      // we parse SHA2 field of ID_AA64ISAR0_EL1 register:
+      //   0 : No SHA2 instructions implemented
+      //   1 : SHA256 implemented
+      //   2 : SHA256 and SHA512 implemented
+    }
+  }
+#endif // defined(_WIN32) && defined(MY_CPU_ARM64)
+
+
+#if 1  // 0 for debug to disable SHA512 PROBE code
+
+/*
+----- SHA512 PROBE -----
+
+We suppose that "CP 4030" registry reading is enough.
+But we use additional SHA512 PROBE code, because
+we can catch exception here, and we don't catch exceptions,
+if we call Sha512 functions from main code.
+
+NOTE: arm64 PROBE code doesn't work, if we call it via Wine in linux-arm64.
+The program just stops.
+Also x64 version of PROBE code doesn't work, if we run it via Intel SDE emulator
+without SHA512 support (-skl switch),
+The program stops, and we have message from SDE:
+  TID 0 SDE-ERROR: Executed instruction not valid for specified chip (SKYLAKE): vsha512msg1
+But we still want to catch that exception instead of process stopping.
+Does this PROBE code work in native Windows-arm64 (with/without sha512 hw instructions)?
+Are there any ways to fix the problems with arm64-wine and x64-SDE cases?
+*/
+
+  PRF(printf("==== CPU_IsSupported_SHA512 PROBE\n");)
+  {
+    BoolInt isSupported = False;
+#ifdef Z7_SHA512_USE_LONGJMP
+    void (Z7_CDECL *signal_prev)(int);
+    /*
+    if (g_Sha512_Unsupported)
+    {
+      PRF(printf("==== g_Sha512_Unsupported\n");)
+      return False;
+    }
+    */
+    printf("====== signal(SIGILL)\n");
+    signal_prev = signal(SIGILL, Sha512_signal_Handler);
+    if (signal_prev == SIG_ERR)
+    {
+      PRF(printf("====== signal fail\n");)
+      return False;
+    }
+    // PRF(printf("==== signal_prev = %p\n", (void *)signal_prev);)
+    // docs: Before the specified function is executed,
+    // the value of func is set to SIG_DFL.
+    // So we can exit if (setjmp(g_Sha512_jmp_buf) != 0).
+    PRF(printf("====== setjmp\n");)
+    if (!setjmp(g_Sha512_jmp_buf))
+#else //  Z7_SHA512_USE_LONGJMP
+
+#ifdef _MSC_VER
+#ifdef __clang_major__
+  #pragma GCC diagnostic ignored "-Wlanguage-extension-token"
+#endif
+    __try
+#endif
+#endif //  Z7_SHA512_USE_LONGJMP
+
+    {
+#if defined(Z7_COMPILER_SHA512_SUPPORTED)
+#ifdef Z7_SHA512_USE_SIMPLIFIED_PROBE
+      // simplified sha512 check for arm64:
+      const uint64x2_t a = vdupq_n_u64(1);
+      const uint64x2_t b = vsha512hq_u64(a, a, a);
+      PRF(printf("======== vsha512hq_u64 probe\n");)
+      if ((UInt32)vgetq_lane_u64(b, 0) == 0x11800002)
+#else
+      MY_ALIGN(16)
+      UInt64 temp[SHA512_NUM_DIGEST_WORDS + SHA512_NUM_BLOCK_WORDS];
+      memset(temp, 0x5a, sizeof(temp));
+      PRF(printf("======== Sha512_UpdateBlocks_HW\n");)
+      Sha512_UpdateBlocks_HW(temp,
+          (const Byte *)(const void *)(temp + SHA512_NUM_DIGEST_WORDS), 1);
+      // PRF(printf("======== t = %x\n", (UInt32)temp[0]);)
+      if ((UInt32)temp[0] == 0xa33cfdf7)
+#endif
+      {
+        PRF(printf("======== PROBE SHA512: SHA512 is supported\n");)
+        isSupported = True;
+      }
+#else // Z7_COMPILER_SHA512_SUPPORTED
+      // for debug : we generate bad instrction or raise exception.
+      // __except() doesn't catch raise() calls.
+#ifdef Z7_SHA512_USE_LONGJMP
+      PRF(printf("====== raise(SIGILL)\n");)
+      raise(SIGILL);
+#else
+#if defined(_MSC_VER) && defined(MY_CPU_X86)
+      __asm  ud2
+#endif
+#endif // Z7_SHA512_USE_LONGJMP
+#endif // Z7_COMPILER_SHA512_SUPPORTED
+    }
+
+#ifdef Z7_SHA512_USE_LONGJMP
+    PRF(printf("====== restore signal SIGILL\n");)
+    signal(SIGILL, signal_prev);
+#elif _MSC_VER
+    __except (EXCEPTION_EXECUTE_HANDLER)
+    {
+      PRF(printf("==== CPU_IsSupported_SHA512 __except(EXCEPTION_EXECUTE_HANDLER)\n");)
+    }
+#endif
+    PRF(printf("== return (sha512 supported) = %d\n", isSupported);)
+    return isSupported;
+  }
+#else
+  // without SHA512 PROBE code
+  return True;
+#endif
+}
+
+#endif // Z7_SHA512_USE_PROBE
+#endif // defined(Z7_SHA512_PROBE_DEBUG) || defined(Z7_COMPILER_SHA512_SUPPORTED)
+
+
+void Sha512Prepare(void)
+{
+#ifdef Z7_COMPILER_SHA512_SUPPORTED
+  SHA512_FUNC_UPDATE_BLOCKS f, f_hw;
+  f = Sha512_UpdateBlocks;
+  f_hw = NULL;
+#ifdef Z7_SHA512_USE_PROBE
+  if (CPU_IsSupported_SHA512_Probe())
+#elif defined(MY_CPU_X86_OR_AMD64)
+  if (CPU_IsSupported_SHA512() && CPU_IsSupported_AVX2())
+#else
+  if (CPU_IsSupported_SHA512())
+#endif
+  {
+    // printf("\n========== HW SHA512 ======== \n");
+    f = f_hw = Sha512_UpdateBlocks_HW;
+  }
+  g_SHA512_FUNC_UPDATE_BLOCKS    = f;
+  g_SHA512_FUNC_UPDATE_BLOCKS_HW = f_hw;
+#elif defined(Z7_SHA512_PROBE_DEBUG)
+  CPU_IsSupported_SHA512_Probe(); // for debug
+#endif
+}
+
+
+#undef K
+#undef S0
+#undef S1
+#undef s0
+#undef s1
+#undef Ch
+#undef Maj
+#undef W_MAIN
+#undef W_PRE
+#undef w
+#undef blk2_main
+#undef blk2
+#undef T1
+#undef T4
+#undef T8
+#undef R1_PRE
+#undef R1_MAIN
+#undef R2_MAIN
+#undef R4
+#undef R4_PRE
+#undef R4_MAIN
+#undef R8
+#undef R8_PRE
+#undef R8_MAIN
+#undef STEP_PRE
+#undef STEP_MAIN
+#undef Z7_SHA512_BIG_W
+#undef Z7_SHA512_UNROLL
+#undef Z7_COMPILER_SHA512_SUPPORTED
diff --git a/C/Sha512.h b/C/Sha512.h
new file mode 100644
index 0000000..1f3a4d1
--- /dev/null
+++ b/C/Sha512.h
@@ -0,0 +1,86 @@
+/* Sha512.h -- SHA-512 Hash
+: Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_SHA512_H
+#define ZIP7_INC_SHA512_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define SHA512_NUM_BLOCK_WORDS  16
+#define SHA512_NUM_DIGEST_WORDS  8
+
+#define SHA512_BLOCK_SIZE   (SHA512_NUM_BLOCK_WORDS * 8)
+#define SHA512_DIGEST_SIZE  (SHA512_NUM_DIGEST_WORDS * 8)
+#define SHA512_224_DIGEST_SIZE  (224 / 8)
+#define SHA512_256_DIGEST_SIZE  (256 / 8)
+#define SHA512_384_DIGEST_SIZE  (384 / 8)
+
+typedef void (Z7_FASTCALL *SHA512_FUNC_UPDATE_BLOCKS)(UInt64 state[8], const Byte *data, size_t numBlocks);
+
+/*
+  if (the system supports different SHA512 code implementations)
+  {
+    (CSha512::func_UpdateBlocks) will be used
+    (CSha512::func_UpdateBlocks) can be set by
+       Sha512_Init()        - to default (fastest)
+       Sha512_SetFunction() - to any algo
+  }
+  else
+  {
+    (CSha512::func_UpdateBlocks) is ignored.
+  }
+*/
+
+typedef struct
+{
+  union
+  {
+    struct
+    {
+      SHA512_FUNC_UPDATE_BLOCKS func_UpdateBlocks;
+      UInt64 count;
+    } vars;
+    UInt64 _pad_64bit[8];
+    void *_pad_align_ptr[2];
+  } v;
+  UInt64 state[SHA512_NUM_DIGEST_WORDS];
+  
+  Byte buffer[SHA512_BLOCK_SIZE];
+} CSha512;
+
+
+#define SHA512_ALGO_DEFAULT 0
+#define SHA512_ALGO_SW      1
+#define SHA512_ALGO_HW      2
+
+/*
+Sha512_SetFunction()
+return:
+  0 - (algo) value is not supported, and func_UpdateBlocks was not changed
+  1 - func_UpdateBlocks was set according (algo) value.
+*/
+
+BoolInt Sha512_SetFunction(CSha512 *p, unsigned algo);
+// we support only these (digestSize) values: 224/8, 256/8, 384/8, 512/8
+void Sha512_InitState(CSha512 *p, unsigned digestSize);
+void Sha512_Init(CSha512 *p, unsigned digestSize);
+void Sha512_Update(CSha512 *p, const Byte *data, size_t size);
+void Sha512_Final(CSha512 *p, Byte *digest, unsigned digestSize);
+
+
+
+
+// void Z7_FASTCALL Sha512_UpdateBlocks(UInt64 state[8], const Byte *data, size_t numBlocks);
+
+/*
+call Sha512Prepare() once at program start.
+It prepares all supported implementations, and detects the fastest implementation.
+*/
+
+void Sha512Prepare(void);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Sha512Opt.c b/C/Sha512Opt.c
new file mode 100644
index 0000000..3a13868
--- /dev/null
+++ b/C/Sha512Opt.c
@@ -0,0 +1,395 @@
+/* Sha512Opt.c -- SHA-512 optimized code for SHA-512 hardware instructions
+: Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+#include "Compiler.h"
+#include "CpuArch.h"
+
+// #define Z7_USE_HW_SHA_STUB // for debug
+#ifdef MY_CPU_X86_OR_AMD64
+  #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 2400) && (__INTEL_COMPILER <= 9900) // fix it
+      #define USE_HW_SHA
+  #elif defined(Z7_LLVM_CLANG_VERSION)  && (Z7_LLVM_CLANG_VERSION  >= 170001) \
+     || defined(Z7_APPLE_CLANG_VERSION) && (Z7_APPLE_CLANG_VERSION >= 170001) \
+     || defined(Z7_GCC_VERSION)         && (Z7_GCC_VERSION         >= 140000)
+      #define USE_HW_SHA
+      #if !defined(__INTEL_COMPILER)
+      // icc defines __GNUC__, but icc doesn't support __attribute__(__target__)
+      #if !defined(__SHA512__) || !defined(__AVX2__)
+        #define ATTRIB_SHA512 __attribute__((__target__("sha512,avx2")))
+      #endif
+      #endif
+  #elif defined(Z7_MSC_VER_ORIGINAL)
+    #if (_MSC_VER >= 1940)
+      #define USE_HW_SHA
+    #else
+      // #define Z7_USE_HW_SHA_STUB
+    #endif
+  #endif
+// #endif // MY_CPU_X86_OR_AMD64
+#ifndef USE_HW_SHA
+  // #define Z7_USE_HW_SHA_STUB // for debug
+#endif
+
+#ifdef USE_HW_SHA
+
+// #pragma message("Sha512 HW")
+
+#include <immintrin.h>
+
+#if defined (__clang__) && defined(_MSC_VER)
+  #if !defined(__AVX__)
+    #include <avxintrin.h>
+  #endif
+  #if !defined(__AVX2__)
+    #include <avx2intrin.h>
+  #endif
+  #if !defined(__SHA512__)
+    #include <sha512intrin.h>
+  #endif
+#else
+
+#endif
+
+/*
+SHA512 uses:
+AVX:
+  _mm256_loadu_si256  (vmovdqu)
+  _mm256_storeu_si256
+  _mm256_set_epi32    (unused)
+AVX2:
+  _mm256_add_epi64     : vpaddq
+  _mm256_shuffle_epi8  : vpshufb
+  _mm256_shuffle_epi32 : pshufd
+  _mm256_blend_epi32   : vpblendd
+  _mm256_permute4x64_epi64 : vpermq     : 3c
+  _mm256_permute2x128_si256: vperm2i128 : 3c
+  _mm256_extracti128_si256 : vextracti128  : 3c
+SHA512:
+  _mm256_sha512*
+*/
+
+// K array must be aligned for 32-bytes at least.
+// The compiler can look align attribute and selects
+//  vmovdqu - for code without align attribute
+//  vmovdqa - for code with    align attribute
+extern
+MY_ALIGN(64)
+const UInt64 SHA512_K_ARRAY[80];
+#define K SHA512_K_ARRAY
+
+
+#define ADD_EPI64(dest, src)      dest = _mm256_add_epi64(dest, src);
+#define SHA512_MSG1(dest, src)    dest = _mm256_sha512msg1_epi64(dest, _mm256_extracti128_si256(src, 0));
+#define SHA512_MSG2(dest, src)    dest = _mm256_sha512msg2_epi64(dest, src);
+
+#define LOAD_SHUFFLE(m, k) \
+    m = _mm256_loadu_si256((const __m256i *)(const void *)(data + (k) * 32)); \
+    m = _mm256_shuffle_epi8(m, mask); \
+
+#define NNN(m0, m1, m2, m3)
+
+#define SM1(m1, m2, m3, m0) \
+    SHA512_MSG1(m0, m1); \
+            
+#define SM2(m2, m3, m0, m1) \
+    ADD_EPI64(m0, _mm256_permute4x64_epi64(_mm256_blend_epi32(m2, m3, 3), 0x39)); \
+    SHA512_MSG2(m0, m3); \
+
+#define RND2(t0, t1, lane) \
+    t0 = _mm256_sha512rnds2_epi64(t0, t1, _mm256_extracti128_si256(msg, lane));
+
+
+
+#define R4(k, m0, m1, m2, m3, OP0, OP1) \
+    msg = _mm256_add_epi64(m0, *(const __m256i *) (const void *) &K[(k) * 4]); \
+    RND2(state0, state1, 0);  OP0(m0, m1, m2, m3) \
+    RND2(state1, state0, 1);  OP1(m0, m1, m2, m3) \
+
+
+
+
+#define R16(k, OP0, OP1, OP2, OP3, OP4, OP5, OP6, OP7) \
+    R4 ( (k)*4+0, m0,m1,m2,m3, OP0, OP1 ) \
+    R4 ( (k)*4+1, m1,m2,m3,m0, OP2, OP3 ) \
+    R4 ( (k)*4+2, m2,m3,m0,m1, OP4, OP5 ) \
+    R4 ( (k)*4+3, m3,m0,m1,m2, OP6, OP7 ) \
+
+#define PREPARE_STATE \
+    state0 = _mm256_shuffle_epi32(state0, 0x4e);              /* cdab */ \
+    state1 = _mm256_shuffle_epi32(state1, 0x4e);              /* ghef */ \
+    tmp = state0; \
+    state0 = _mm256_permute2x128_si256(state0, state1, 0x13); /* cdgh */ \
+    state1 = _mm256_permute2x128_si256(tmp,    state1, 2);    /* abef */ \
+
+
+void Z7_FASTCALL Sha512_UpdateBlocks_HW(UInt64 state[8], const Byte *data, size_t numBlocks);
+#ifdef ATTRIB_SHA512
+ATTRIB_SHA512
+#endif
+void Z7_FASTCALL Sha512_UpdateBlocks_HW(UInt64 state[8], const Byte *data, size_t numBlocks)
+{
+  const __m256i mask = _mm256_set_epi32(
+      0x08090a0b,0x0c0d0e0f, 0x00010203,0x04050607,
+      0x08090a0b,0x0c0d0e0f, 0x00010203,0x04050607);
+  __m256i tmp, state0, state1;
+
+  if (numBlocks == 0)
+    return;
+
+  state0 = _mm256_loadu_si256((const __m256i *) (const void *) &state[0]);
+  state1 = _mm256_loadu_si256((const __m256i *) (const void *) &state[4]);
+  
+  PREPARE_STATE
+
+  do
+  {
+    __m256i state0_save, state1_save;
+    __m256i m0, m1, m2, m3;
+    __m256i msg;
+    // #define msg tmp
+
+    state0_save = state0;
+    state1_save = state1;
+    
+    LOAD_SHUFFLE (m0, 0)
+    LOAD_SHUFFLE (m1, 1)
+    LOAD_SHUFFLE (m2, 2)
+    LOAD_SHUFFLE (m3, 3)
+
+
+
+    R16 ( 0, NNN, NNN, SM1, NNN, SM1, SM2, SM1, SM2 )
+    R16 ( 1, SM1, SM2, SM1, SM2, SM1, SM2, SM1, SM2 )
+    R16 ( 2, SM1, SM2, SM1, SM2, SM1, SM2, SM1, SM2 )
+    R16 ( 3, SM1, SM2, SM1, SM2, SM1, SM2, SM1, SM2 )
+    R16 ( 4, SM1, SM2, NNN, SM2, NNN, NNN, NNN, NNN )
+    ADD_EPI64(state0, state0_save)
+    ADD_EPI64(state1, state1_save)
+    
+    data += 128;
+  }
+  while (--numBlocks);
+
+  PREPARE_STATE
+
+  _mm256_storeu_si256((__m256i *) (void *) &state[0], state0);
+  _mm256_storeu_si256((__m256i *) (void *) &state[4], state1);
+}
+
+#endif // USE_HW_SHA
+
+// gcc 8.5 also supports sha512, but we need also support in assembler that is called by gcc
+#elif defined(MY_CPU_ARM64) && defined(MY_CPU_LE)
+  
+  #if defined(__ARM_FEATURE_SHA512)
+    #define USE_HW_SHA
+  #else
+    #if (defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 130000) \
+           || defined(__GNUC__) && (__GNUC__ >= 9) \
+          ) \
+      || defined(Z7_MSC_VER_ORIGINAL) && (_MSC_VER >= 1940) // fix it
+      #define USE_HW_SHA
+    #endif
+  #endif
+
+#ifdef USE_HW_SHA
+
+// #pragma message("=== Sha512 HW === ")
+
+
+#if defined(__clang__) || defined(__GNUC__)
+#if !defined(__ARM_FEATURE_SHA512)
+// #pragma message("=== we define SHA3 ATTRIB_SHA512 === ")
+#if defined(__clang__)
+    #define ATTRIB_SHA512 __attribute__((__target__("sha3"))) // "armv8.2-a,sha3"
+#else
+    #define ATTRIB_SHA512 __attribute__((__target__("arch=armv8.2-a+sha3")))
+#endif
+#endif
+#endif
+
+
+#if defined(Z7_MSC_VER_ORIGINAL)
+#include <arm64_neon.h>
+#else
+
+#if defined(__clang__) && __clang_major__ < 16
+#if !defined(__ARM_FEATURE_SHA512)
+// #pragma message("=== we set __ARM_FEATURE_SHA512 1 === ")
+    Z7_DIAGNOSTIC_IGNORE_BEGIN_RESERVED_MACRO_IDENTIFIER
+    #define Z7_ARM_FEATURE_SHA512_WAS_SET 1
+    #define __ARM_FEATURE_SHA512 1
+    Z7_DIAGNOSTIC_IGNORE_END_RESERVED_MACRO_IDENTIFIER
+#endif
+#endif // clang
+
+#include <arm_neon.h>
+
+#if defined(Z7_ARM_FEATURE_SHA512_WAS_SET) && \
+    defined(__ARM_FEATURE_SHA512)
+    Z7_DIAGNOSTIC_IGNORE_BEGIN_RESERVED_MACRO_IDENTIFIER
+    #undef __ARM_FEATURE_SHA512
+    #undef Z7_ARM_FEATURE_SHA512_WAS_SET
+    Z7_DIAGNOSTIC_IGNORE_END_RESERVED_MACRO_IDENTIFIER
+// #pragma message("=== we undefine __ARM_FEATURE_CRYPTO === ")
+#endif
+
+#endif // Z7_MSC_VER_ORIGINAL
+
+typedef uint64x2_t v128_64;
+// typedef __n128 v128_64; // MSVC
+
+#ifdef MY_CPU_BE
+  #define MY_rev64_for_LE(x) x
+#else
+  #define MY_rev64_for_LE(x) vrev64q_u8(x)
+#endif
+
+#define LOAD_128_64(_p)       vld1q_u64(_p)
+#define LOAD_128_8(_p)        vld1q_u8 (_p)
+#define STORE_128_64(_p, _v)  vst1q_u64(_p, _v)
+
+#define LOAD_SHUFFLE(m, k) \
+    m = vreinterpretq_u64_u8( \
+        MY_rev64_for_LE( \
+        LOAD_128_8(data + (k) * 16))); \
+
+// K array must be aligned for 16-bytes at least.
+extern
+MY_ALIGN(64)
+const UInt64 SHA512_K_ARRAY[80];
+#define K SHA512_K_ARRAY
+
+#define NN(m0, m1, m4, m5, m7)
+#define SM(m0, m1, m4, m5, m7) \
+    m0 = vsha512su1q_u64(vsha512su0q_u64(m0, m1), m7, vextq_u64(m4, m5, 1));
+
+#define R2(k, m0,m1,m2,m3,m4,m5,m6,m7, a0,a1,a2,a3, OP) \
+    OP(m0, m1, m4, m5, m7) \
+    t = vaddq_u64(m0, vld1q_u64(k)); \
+    t = vaddq_u64(vextq_u64(t, t, 1), a3); \
+    t = vsha512hq_u64(t, vextq_u64(a2, a3, 1), vextq_u64(a1, a2, 1)); \
+    a3 = vsha512h2q_u64(t, a1, a0); \
+    a1 = vaddq_u64(a1, t); \
+
+#define R8(k,     m0,m1,m2,m3,m4,m5,m6,m7, OP) \
+    R2 ( (k)+0*2, m0,m1,m2,m3,m4,m5,m6,m7, a0,a1,a2,a3, OP ) \
+    R2 ( (k)+1*2, m1,m2,m3,m4,m5,m6,m7,m0, a3,a0,a1,a2, OP ) \
+    R2 ( (k)+2*2, m2,m3,m4,m5,m6,m7,m0,m1, a2,a3,a0,a1, OP ) \
+    R2 ( (k)+3*2, m3,m4,m5,m6,m7,m0,m1,m2, a1,a2,a3,a0, OP ) \
+
+#define R16(k, OP) \
+    R8 ( (k)+0*2, m0,m1,m2,m3,m4,m5,m6,m7, OP ) \
+    R8 ( (k)+4*2, m4,m5,m6,m7,m0,m1,m2,m3, OP ) \
+
+
+void Z7_FASTCALL Sha512_UpdateBlocks_HW(UInt64 state[8], const Byte *data, size_t numBlocks);
+#ifdef ATTRIB_SHA512
+ATTRIB_SHA512
+#endif
+void Z7_FASTCALL Sha512_UpdateBlocks_HW(UInt64 state[8], const Byte *data, size_t numBlocks)
+{
+  v128_64 a0, a1, a2, a3;
+
+  if (numBlocks == 0)
+    return;
+  a0 = LOAD_128_64(&state[0]);
+  a1 = LOAD_128_64(&state[2]);
+  a2 = LOAD_128_64(&state[4]);
+  a3 = LOAD_128_64(&state[6]);
+  do
+  {
+    v128_64 a0_save, a1_save, a2_save, a3_save;
+    v128_64 m0, m1, m2, m3, m4, m5, m6, m7;
+    v128_64 t;
+    unsigned i;
+    const UInt64 *k_ptr;
+    
+    LOAD_SHUFFLE (m0, 0)
+    LOAD_SHUFFLE (m1, 1)
+    LOAD_SHUFFLE (m2, 2)
+    LOAD_SHUFFLE (m3, 3)
+    LOAD_SHUFFLE (m4, 4)
+    LOAD_SHUFFLE (m5, 5)
+    LOAD_SHUFFLE (m6, 6)
+    LOAD_SHUFFLE (m7, 7)
+
+    a0_save = a0;
+    a1_save = a1;
+    a2_save = a2;
+    a3_save = a3;
+    
+    R16 ( K, NN )
+    k_ptr = K + 16;
+    for (i = 0; i < 4; i++)
+    {
+      R16 ( k_ptr, SM )
+      k_ptr += 16;
+    }
+    
+    a0 = vaddq_u64(a0, a0_save);
+    a1 = vaddq_u64(a1, a1_save);
+    a2 = vaddq_u64(a2, a2_save);
+    a3 = vaddq_u64(a3, a3_save);
+
+    data += 128;
+  }
+  while (--numBlocks);
+
+  STORE_128_64(&state[0], a0);
+  STORE_128_64(&state[2], a1);
+  STORE_128_64(&state[4], a2);
+  STORE_128_64(&state[6], a3);
+}
+
+#endif // USE_HW_SHA
+
+#endif // MY_CPU_ARM_OR_ARM64
+
+
+#if !defined(USE_HW_SHA) && defined(Z7_USE_HW_SHA_STUB)
+// #error Stop_Compiling_UNSUPPORTED_SHA
+// #include <stdlib.h>
+// We can compile this file with another C compiler,
+// or we can compile asm version.
+// So we can generate real code instead of this stub function.
+// #include "Sha512.h"
+// #if defined(_MSC_VER)
+#pragma message("Sha512 HW-SW stub was used")
+// #endif
+void Z7_FASTCALL Sha512_UpdateBlocks   (UInt64 state[8], const Byte *data, size_t numBlocks);
+void Z7_FASTCALL Sha512_UpdateBlocks_HW(UInt64 state[8], const Byte *data, size_t numBlocks);
+void Z7_FASTCALL Sha512_UpdateBlocks_HW(UInt64 state[8], const Byte *data, size_t numBlocks)
+{
+  Sha512_UpdateBlocks(state, data, numBlocks);
+  /*
+  UNUSED_VAR(state);
+  UNUSED_VAR(data);
+  UNUSED_VAR(numBlocks);
+  exit(1);
+  return;
+  */
+}
+#endif
+
+
+#undef K
+#undef RND2
+#undef MY_rev64_for_LE
+#undef NN
+#undef NNN
+#undef LOAD_128
+#undef STORE_128
+#undef LOAD_SHUFFLE
+#undef SM1
+#undef SM2
+#undef SM
+#undef R2
+#undef R4
+#undef R16
+#undef PREPARE_STATE
+#undef USE_HW_SHA
+#undef ATTRIB_SHA512
+#undef USE_VER_MIN
+#undef Z7_USE_HW_SHA_STUB
diff --git a/C/Sort.c b/C/Sort.c
index e1097e3..20e3e69 100644
--- a/C/Sort.c
+++ b/C/Sort.c
@@ -1,141 +1,268 @@
 /* Sort.c -- Sort functions
-2014-04-05 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
 #include "Sort.h"
+#include "CpuArch.h"
 
-#define HeapSortDown(p, k, size, temp) \
-  { for (;;) { \
-    size_t s = (k << 1); \
-    if (s > size) break; \
-    if (s < size && p[s + 1] > p[s]) s++; \
-    if (temp >= p[s]) break; \
-    p[k] = p[s]; k = s; \
-  } p[k] = temp; }
+#if (  (defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))) \
+    || (defined(__clang__) && Z7_has_builtin(__builtin_prefetch)) \
+    )
+// the code with prefetch is slow for small arrays on x86.
+// So we disable prefetch for x86.
+#ifndef MY_CPU_X86
+  // #pragma message("Z7_PREFETCH : __builtin_prefetch")
+  #define Z7_PREFETCH(a)  __builtin_prefetch((a))
+#endif
 
-void HeapSort(UInt32 *p, size_t size)
-{
-  if (size <= 1)
-    return;
-  p--;
-  {
-    size_t i = size / 2;
-    do
-    {
-      UInt32 temp = p[i];
-      size_t k = i;
-      HeapSortDown(p, k, size, temp)
-    }
-    while (--i != 0);
-  }
-  /*
-  do
-  {
-    size_t k = 1;
-    UInt32 temp = p[size];
-    p[size--] = p[1];
-    HeapSortDown(p, k, size, temp)
-  }
-  while (size > 1);
-  */
-  while (size > 3)
-  {
-    UInt32 temp = p[size];
-    size_t k = (p[3] > p[2]) ? 3 : 2;
-    p[size--] = p[1];
-    p[1] = p[k];
-    HeapSortDown(p, k, size, temp)
-  }
-  {
-    UInt32 temp = p[size];
-    p[size] = p[1];
-    if (size > 2 && p[2] < temp)
-    {
-      p[1] = p[2];
-      p[2] = temp;
-    }
-    else
-      p[1] = temp;
-  }
+#elif defined(_WIN32) // || defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "7zWindows.h"
+
+// NOTE: CLANG/GCC/MSVC can define different values for _MM_HINT_T0 / PF_TEMPORAL_LEVEL_1.
+// For example, clang-cl can generate "prefetcht2" instruction for
+// PreFetchCacheLine(PF_TEMPORAL_LEVEL_1) call.
+// But we want to generate "prefetcht0" instruction.
+// So for CLANG/GCC we must use __builtin_prefetch() in code branch above
+// instead of PreFetchCacheLine() / _mm_prefetch().
+
+// New msvc-x86 compiler generates "prefetcht0" instruction for PreFetchCacheLine() call.
+// But old x86 cpus don't support "prefetcht0".
+// So we will use PreFetchCacheLine(), only if we are sure that
+// generated instruction is supported by all cpus of that isa.
+#if defined(MY_CPU_AMD64) \
+    || defined(MY_CPU_ARM64) \
+    || defined(MY_CPU_IA64)
+// we need to use additional braces for (a) in PreFetchCacheLine call, because
+// PreFetchCacheLine macro doesn't use braces:
+//   #define PreFetchCacheLine(l, a)  _mm_prefetch((CHAR CONST *) a, l)
+  // #pragma message("Z7_PREFETCH : PreFetchCacheLine")
+  #define Z7_PREFETCH(a)  PreFetchCacheLine(PF_TEMPORAL_LEVEL_1, (a))
+#endif
+
+#endif // _WIN32
+
+
+#define PREFETCH_NO(p,k,s,size)
+
+#ifndef Z7_PREFETCH
+  #define SORT_PREFETCH(p,k,s,size)
+#else
+
+// #define PREFETCH_LEVEL 2  // use it if cache line is 32-bytes
+#define PREFETCH_LEVEL 3  // it is fast for most cases (64-bytes cache line prefetch)
+// #define PREFETCH_LEVEL 4  // it can be faster for big array (128-bytes prefetch)
+
+#if PREFETCH_LEVEL == 0
+
+  #define SORT_PREFETCH(p,k,s,size)
+
+#else // PREFETCH_LEVEL != 0
+
+/*
+if  defined(USE_PREFETCH_FOR_ALIGNED_ARRAY)
+    we prefetch one value per cache line.
+    Use it if array is aligned for cache line size (64 bytes)
+    or if array is small (less than L1 cache size).
+
+if !defined(USE_PREFETCH_FOR_ALIGNED_ARRAY)
+    we perfetch all cache lines that can be required.
+    it can be faster for big unaligned arrays.
+*/
+  #define USE_PREFETCH_FOR_ALIGNED_ARRAY
+
+// s == k * 2
+#if 0 && PREFETCH_LEVEL <= 3 && defined(MY_CPU_X86_OR_AMD64)
+  // x86 supports (lea r1*8+offset)
+  #define PREFETCH_OFFSET(k,s)  ((s) << PREFETCH_LEVEL)
+#else
+  #define PREFETCH_OFFSET(k,s)  ((k) << (PREFETCH_LEVEL + 1))
+#endif
+
+#if 1 && PREFETCH_LEVEL <= 3 && defined(USE_PREFETCH_FOR_ALIGNED_ARRAY)
+  #define PREFETCH_ADD_OFFSET   0
+#else
+  // last offset that can be reqiured in PREFETCH_LEVEL step:
+  #define PREFETCH_RANGE        ((2 << PREFETCH_LEVEL) - 1)
+  #define PREFETCH_ADD_OFFSET   PREFETCH_RANGE / 2
+#endif
+
+#if PREFETCH_LEVEL <= 3
+
+#ifdef USE_PREFETCH_FOR_ALIGNED_ARRAY
+  #define SORT_PREFETCH(p,k,s,size) \
+  { const size_t s2 = PREFETCH_OFFSET(k,s) + PREFETCH_ADD_OFFSET; \
+    if (s2 <= size) { \
+      Z7_PREFETCH((p + s2)); \
+  }}
+#else /* for unaligned array */
+  #define SORT_PREFETCH(p,k,s,size) \
+  { const size_t s2 = PREFETCH_OFFSET(k,s) + PREFETCH_RANGE; \
+    if (s2 <= size) { \
+      Z7_PREFETCH((p + s2 - PREFETCH_RANGE)); \
+      Z7_PREFETCH((p + s2)); \
+  }}
+#endif
+
+#else // PREFETCH_LEVEL > 3
+
+#ifdef USE_PREFETCH_FOR_ALIGNED_ARRAY
+  #define SORT_PREFETCH(p,k,s,size) \
+  { const size_t s2 = PREFETCH_OFFSET(k,s) + PREFETCH_RANGE - 16 / 2; \
+    if (s2 <= size) { \
+      Z7_PREFETCH((p + s2 - 16)); \
+      Z7_PREFETCH((p + s2)); \
+  }}
+#else /* for unaligned array */
+  #define SORT_PREFETCH(p,k,s,size) \
+  { const size_t s2 = PREFETCH_OFFSET(k,s) + PREFETCH_RANGE; \
+    if (s2 <= size) { \
+      Z7_PREFETCH((p + s2 - PREFETCH_RANGE)); \
+      Z7_PREFETCH((p + s2 - PREFETCH_RANGE / 2)); \
+      Z7_PREFETCH((p + s2)); \
+  }}
+#endif
+
+#endif // PREFETCH_LEVEL > 3
+#endif // PREFETCH_LEVEL != 0
+#endif // Z7_PREFETCH
+
+
+#if defined(MY_CPU_ARM64) \
+    /* || defined(MY_CPU_AMD64) */ \
+    /* || defined(MY_CPU_ARM) && !defined(_MSC_VER) */
+  // we want to use cmov, if cmov is very fast:
+  // - this cmov version is slower for clang-x64.
+  // - this cmov version is faster for gcc-arm64 for some fast arm64 cpus.
+  #define Z7_FAST_CMOV_SUPPORTED
+#endif
+ 
+#ifdef Z7_FAST_CMOV_SUPPORTED
+  // we want to use cmov here, if cmov is fast: new arm64 cpus.
+  // we want the compiler to use conditional move for this branch
+  #define GET_MAX_VAL(n0, n1, max_val_slow)  if (n0 < n1) n0 = n1;
+#else
+  // use this branch, if cpu doesn't support fast conditional move.
+  // it uses slow array access reading:
+  #define GET_MAX_VAL(n0, n1, max_val_slow)  n0 = max_val_slow;
+#endif
+
+#define HeapSortDown(p, k, size, temp, macro_prefetch) \
+{ \
+  for (;;) { \
+    UInt32 n0, n1; \
+    size_t s = k * 2; \
+    if (s >= size) { \
+      if (s == size) { \
+        n0 = p[s]; \
+        p[k] = n0; \
+        if (temp < n0) k = s; \
+      } \
+      break; \
+    } \
+    n0 = p[k * 2]; \
+    n1 = p[k * 2 + 1]; \
+    s += n0 < n1; \
+    GET_MAX_VAL(n0, n1, p[s]) \
+    if (temp >= n0) break; \
+    macro_prefetch(p, k, s, size) \
+    p[k] = n0; \
+    k = s; \
+  } \
+  p[k] = temp; \
 }
 
-void HeapSort64(UInt64 *p, size_t size)
+
+/*
+stage-1 : O(n) :
+  we generate intermediate partially sorted binary tree:
+  p[0]  : it's additional item for better alignment of tree structure in memory.
+  p[1]
+  p[2]       p[3]
+  p[4] p[5]  p[6] p[7]
+  ...
+  p[x] >= p[x * 2]
+  p[x] >= p[x * 2 + 1]
+  
+stage-2 : O(n)*log2(N):
+  we move largest item p[0] from head of tree to the end of array
+  and insert last item to sorted binary tree.
+*/
+
+// (p) must be aligned for cache line size (64-bytes) for best performance
+
+void Z7_FASTCALL HeapSort(UInt32 *p, size_t size)
 {
-  if (size <= 1)
+  if (size < 2)
     return;
-  p--;
-  {
-    size_t i = size / 2;
-    do
-    {
-      UInt64 temp = p[i];
-      size_t k = i;
-      HeapSortDown(p, k, size, temp)
-    }
-    while (--i != 0);
-  }
-  /*
-  do
+  if (size == 2)
   {
-    size_t k = 1;
-    UInt64 temp = p[size];
-    p[size--] = p[1];
-    HeapSortDown(p, k, size, temp)
-  }
-  while (size > 1);
-  */
-  while (size > 3)
-  {
-    UInt64 temp = p[size];
-    size_t k = (p[3] > p[2]) ? 3 : 2;
-    p[size--] = p[1];
-    p[1] = p[k];
-    HeapSortDown(p, k, size, temp)
+    const UInt32 a0 = p[0];
+    const UInt32 a1 = p[1];
+    const unsigned k = a1 < a0;
+    p[k] = a0;
+    p[k ^ 1] = a1;
+    return;
   }
   {
-    UInt64 temp = p[size];
-    p[size] = p[1];
-    if (size > 2 && p[2] < temp)
+    // stage-1 : O(n)
+    // we transform array to partially sorted binary tree.
+    size_t i = --size / 2;
+    // (size) now is the index of the last item in tree,
+    // if (i)
     {
-      p[1] = p[2];
-      p[2] = temp;
+      do
+      {
+        const UInt32 temp = p[i];
+        size_t k = i;
+        HeapSortDown(p, k, size, temp, PREFETCH_NO)
+      }
+      while (--i);
+    }
+    {
+      const UInt32 temp = p[0];
+      const UInt32 a1 = p[1];
+      if (temp < a1)
+      {
+        size_t k = 1;
+        p[0] = a1;
+        HeapSortDown(p, k, size, temp, PREFETCH_NO)
+      }
     }
-    else
-      p[1] = temp;
   }
-}
 
-/*
-#define HeapSortRefDown(p, vals, n, size, temp) \
-  { size_t k = n; UInt32 val = vals[temp]; for (;;) { \
-    size_t s = (k << 1); \
-    if (s > size) break; \
-    if (s < size && vals[p[s + 1]] > vals[p[s]]) s++; \
-    if (val >= vals[p[s]]) break; \
-    p[k] = p[s]; k = s; \
-  } p[k] = temp; }
-
-void HeapSortRef(UInt32 *p, UInt32 *vals, size_t size)
-{
-  if (size <= 1)
+  if (size < 3)
+  {
+    // size == 2
+    const UInt32 a0 = p[0];
+    p[0] = p[2];
+    p[2] = a0;
     return;
-  p--;
+  }
+  if (size != 3)
   {
-    size_t i = size / 2;
+    // stage-2 : O(size) * log2(size):
+    // we move largest item p[0] from head to the end of array,
+    // and insert last item to sorted binary tree.
     do
     {
-      UInt32 temp = p[i];
-      HeapSortRefDown(p, vals, i, size, temp);
+      const UInt32 temp = p[size];
+      size_t k = p[2] < p[3] ? 3 : 2;
+      p[size--] = p[0];
+      p[0] = p[1];
+      p[1] = p[k];
+      HeapSortDown(p, k, size, temp, SORT_PREFETCH) // PREFETCH_NO
     }
-    while (--i != 0);
+    while (size != 3);
   }
-  do
   {
-    UInt32 temp = p[size];
-    p[size--] = p[1];
-    HeapSortRefDown(p, vals, 1, size, temp);
+    const UInt32 a2 = p[2];
+    const UInt32 a3 = p[3];
+    const size_t k = a2 < a3;
+    p[2] = p[1];
+    p[3] = p[0];
+    p[k] = a3;
+    p[k ^ 1] = a2;
   }
-  while (size > 1);
 }
-*/
diff --git a/C/Sort.h b/C/Sort.h
index 1817b65..de5a4e8 100644
--- a/C/Sort.h
+++ b/C/Sort.h
@@ -1,5 +1,5 @@
 /* Sort.h -- Sort functions
-2023-03-05 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_SORT_H
 #define ZIP7_INC_SORT_H
@@ -8,10 +8,7 @@
 
 EXTERN_C_BEGIN
 
-void HeapSort(UInt32 *p, size_t size);
-void HeapSort64(UInt64 *p, size_t size);
-
-/* void HeapSortRef(UInt32 *p, UInt32 *vals, size_t size); */
+void Z7_FASTCALL HeapSort(UInt32 *p, size_t size);
 
 EXTERN_C_END
 
diff --git a/C/Threads.c b/C/Threads.c
index 464efec..177d1d9 100644
--- a/C/Threads.c
+++ b/C/Threads.c
@@ -1,5 +1,5 @@
 /* Threads.c -- multithreading library
-2024-03-28 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -59,6 +59,100 @@ WRes Thread_Wait_Close(CThread *p)
   return (res != 0 ? res : res2);
 }
 
+typedef struct MY_PROCESSOR_NUMBER {
+    WORD  Group;
+    BYTE  Number;
+    BYTE  Reserved;
+} MY_PROCESSOR_NUMBER, *MY_PPROCESSOR_NUMBER;
+
+typedef struct MY_GROUP_AFFINITY {
+#if defined(Z7_GCC_VERSION) && (Z7_GCC_VERSION < 100000)
+    // KAFFINITY is not defined in old mingw
+    ULONG_PTR
+#else
+    KAFFINITY
+#endif
+      Mask;
+    WORD   Group;
+    WORD   Reserved[3];
+} MY_GROUP_AFFINITY, *MY_PGROUP_AFFINITY;
+
+typedef BOOL (WINAPI *Func_SetThreadGroupAffinity)(
+    HANDLE hThread,
+    CONST MY_GROUP_AFFINITY *GroupAffinity,
+    MY_PGROUP_AFFINITY PreviousGroupAffinity);
+
+typedef BOOL (WINAPI *Func_GetThreadGroupAffinity)(
+    HANDLE hThread,
+    MY_PGROUP_AFFINITY GroupAffinity);
+
+typedef BOOL (WINAPI *Func_GetProcessGroupAffinity)(
+    HANDLE hProcess,
+    PUSHORT GroupCount,
+    PUSHORT GroupArray);
+
+Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
+
+#if 0
+#include <stdio.h>
+#define PRF(x) x
+/*
+--
+  before call of SetThreadGroupAffinity()
+    GetProcessGroupAffinity return one group.
+  after call of SetThreadGroupAffinity():
+    GetProcessGroupAffinity return more than group,
+    if SetThreadGroupAffinity() was to another group.
+--
+  GetProcessAffinityMask MS DOCs:
+  {
+    If the calling process contains threads in multiple groups,
+    the function returns zero for both affinity masks.
+  }
+  but tests in win10 with 2 groups (less than 64 cores total):
+    GetProcessAffinityMask() still returns non-zero affinity masks
+    even after SetThreadGroupAffinity() calls.
+*/
+static void PrintProcess_Info()
+{
+  {
+    const
+      Func_GetProcessGroupAffinity fn_GetProcessGroupAffinity =
+     (Func_GetProcessGroupAffinity) Z7_CAST_FUNC_C GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),
+          "GetProcessGroupAffinity");
+    if (fn_GetProcessGroupAffinity)
+    {
+      unsigned i;
+      USHORT GroupCounts[64];
+      USHORT GroupCount = Z7_ARRAY_SIZE(GroupCounts);
+      BOOL boolRes = fn_GetProcessGroupAffinity(GetCurrentProcess(),
+          &GroupCount, GroupCounts);
+      printf("\n====== GetProcessGroupAffinity : "
+          "boolRes=%u GroupCounts = %u :",
+          boolRes, (unsigned)GroupCount);
+      for (i = 0; i < GroupCount; i++)
+        printf(" %u", GroupCounts[i]);
+      printf("\n");
+    }
+  }
+  {
+    DWORD_PTR processAffinityMask, systemAffinityMask;
+    if (GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask))
+    {
+      PRF(printf("\n====== GetProcessAffinityMask : "
+        ": processAffinityMask=%x, systemAffinityMask=%x\n",
+        (UInt32)processAffinityMask, (UInt32)systemAffinityMask);)
+    }
+    else
+      printf("\n==GetProcessAffinityMask FAIL");
+  }
+}
+#else
+#ifndef USE_THREADS_CreateThread
+// #define PRF(x)
+#endif
+#endif
+
 WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param)
 {
   /* Windows Me/98/95: threadId parameter may not be NULL in _beginthreadex/CreateThread functions */
@@ -72,7 +166,43 @@ WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param)
   
   unsigned threadId;
   *p = (HANDLE)(_beginthreadex(NULL, 0, func, param, 0, &threadId));
-  
+
+#if 0 // 1 : for debug
+  {
+      DWORD_PTR prevMask;
+      DWORD_PTR affinity = 1 << 0;
+      prevMask = SetThreadAffinityMask(*p, (DWORD_PTR)affinity);
+      prevMask = prevMask;
+  }
+#endif
+#if 0 // 1 : for debug
+  {
+      /* win10: new thread will be created in same group that is assigned to parent thread
+                but affinity mask will contain all allowed threads of that group,
+                even if affinity mask of parent group is not full
+         win11: what group it will be created, if we have set
+                affinity of parent thread with ThreadGroupAffinity?
+      */
+      const
+         Func_GetThreadGroupAffinity fn =
+        (Func_GetThreadGroupAffinity) Z7_CAST_FUNC_C GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),
+             "GetThreadGroupAffinity");
+      if (fn)
+      {
+        // BOOL wres2;
+        MY_GROUP_AFFINITY groupAffinity;
+        memset(&groupAffinity, 0, sizeof(groupAffinity));
+        /* wres2 = */ fn(*p, &groupAffinity);
+        PRF(printf("\n==Thread_Create cur = %6u GetThreadGroupAffinity(): "
+            "wres2_BOOL = %u, group=%u mask=%x\n",
+            GetCurrentThreadId(),
+            wres2,
+            groupAffinity.Group,
+            (UInt32)groupAffinity.Mask);)
+      }
+  }
+#endif
+
   #endif
 
   /* maybe we must use errno here, but probably GetLastError() is also OK. */
@@ -110,7 +240,84 @@ WRes Thread_Create_With_Affinity(CThread *p, THREAD_FUNC_TYPE func, LPVOID param
       */
     }
     {
-      DWORD prevSuspendCount = ResumeThread(h);
+      const DWORD prevSuspendCount = ResumeThread(h);
+      /* ResumeThread() returns:
+         0 : was_not_suspended
+         1 : was_resumed
+        -1 : error
+      */
+      if (prevSuspendCount == (DWORD)-1)
+        wres = GetError();
+    }
+  }
+
+  /* maybe we must use errno here, but probably GetLastError() is also OK. */
+  return wres;
+
+  #endif
+}
+
+
+WRes Thread_Create_With_Group(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, unsigned group, CAffinityMask affinityMask)
+{
+#ifdef USE_THREADS_CreateThread
+
+  UNUSED_VAR(group)
+  UNUSED_VAR(affinityMask)
+  return Thread_Create(p, func, param);
+  
+#else
+  
+  /* Windows Me/98/95: threadId parameter may not be NULL in _beginthreadex/CreateThread functions */
+  HANDLE h;
+  WRes wres;
+  unsigned threadId;
+  h = (HANDLE)(_beginthreadex(NULL, 0, func, param, CREATE_SUSPENDED, &threadId));
+  *p = h;
+  wres = HandleToWRes(h);
+  if (h)
+  {
+    // PrintProcess_Info();
+    {
+      const
+         Func_SetThreadGroupAffinity fn =
+        (Func_SetThreadGroupAffinity) Z7_CAST_FUNC_C GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),
+             "SetThreadGroupAffinity");
+      if (fn)
+      {
+        // WRes wres2;
+        MY_GROUP_AFFINITY groupAffinity, prev_groupAffinity;
+        memset(&groupAffinity, 0, sizeof(groupAffinity));
+        // groupAffinity.Mask must use only bits that supported by current group
+        // (groupAffinity.Mask = 0) means all allowed bits
+        groupAffinity.Mask = affinityMask;
+        groupAffinity.Group = (WORD)group;
+        // wres2 =
+        fn(h, &groupAffinity, &prev_groupAffinity);
+        /*
+        if (groupAffinity.Group == prev_groupAffinity.Group)
+          wres2 = wres2;
+        else
+          wres2 = wres2;
+        if (wres2 == 0)
+        {
+          wres2 = GetError();
+          PRF(printf("\n==SetThreadGroupAffinity error: %u\n", wres2);)
+        }
+        else
+        {
+          PRF(printf("\n==Thread_Create_With_Group::SetThreadGroupAffinity()"
+            " threadId = %6u"
+            " group=%u mask=%x\n",
+            threadId,
+            prev_groupAffinity.Group,
+            (UInt32)prev_groupAffinity.Mask);)
+        }
+        */
+      }
+    }
+    {
+      const DWORD prevSuspendCount = ResumeThread(h);
       /* ResumeThread() returns:
          0 : was_not_suspended
          1 : was_resumed
@@ -297,6 +504,13 @@ WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param)
   return Thread_Create_With_CpuSet(p, func, param, NULL);
 }
 
+/*
+WRes Thread_Create_With_Group(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, unsigned group, CAffinityMask affinity)
+{
+  UNUSED_VAR(group)
+  return Thread_Create_With_Affinity(p, func, param, affinity);
+}
+*/
 
 WRes Thread_Create_With_Affinity(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, CAffinityMask affinity)
 {
@@ -577,5 +791,22 @@ WRes AutoResetEvent_OptCreate_And_Reset(CAutoResetEvent *p)
   return AutoResetEvent_CreateNotSignaled(p);
 }
 
+void ThreadNextGroup_Init(CThreadNextGroup *p, UInt32 numGroups, UInt32 startGroup)
+{
+  // printf("\n====== ThreadNextGroup_Init numGroups = %x: startGroup=%x\n", numGroups, startGroup);
+  if (numGroups == 0)
+      numGroups = 1;
+  p->NumGroups = numGroups;
+  p->NextGroup = startGroup % numGroups;
+}
+
+
+UInt32 ThreadNextGroup_GetNext(CThreadNextGroup *p)
+{
+  const UInt32 next = p->NextGroup;
+  p->NextGroup = (next + 1) % p->NumGroups;
+  return next;
+}
+
 #undef PRF
 #undef Print
diff --git a/C/Threads.h b/C/Threads.h
index c1484a2..be12e6e 100644
--- a/C/Threads.h
+++ b/C/Threads.h
@@ -1,5 +1,5 @@
 /* Threads.h -- multithreading library
-2024-03-28 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_THREADS_H
 #define ZIP7_INC_THREADS_H
@@ -140,12 +140,22 @@ WRes Thread_Create_With_Affinity(CThread *p, THREAD_FUNC_TYPE func, LPVOID param
 WRes Thread_Wait_Close(CThread *p);
 
 #ifdef _WIN32
+WRes Thread_Create_With_Group(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, unsigned group, CAffinityMask affinityMask);
 #define Thread_Create_With_CpuSet(p, func, param, cs) \
   Thread_Create_With_Affinity(p, func, param, *cs)
 #else
 WRes Thread_Create_With_CpuSet(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, const CCpuSet *cpuSet);
 #endif
 
+typedef struct
+{
+  unsigned NumGroups;
+  unsigned NextGroup;
+} CThreadNextGroup;
+
+void ThreadNextGroup_Init(CThreadNextGroup *p, unsigned numGroups, unsigned startGroup);
+unsigned ThreadNextGroup_GetNext(CThreadNextGroup *p);
+
 
 #ifdef _WIN32
 
diff --git a/C/Util/Lzma/LzmaUtil.dsp b/C/Util/Lzma/LzmaUtil.dsp
index e2e7d42..71de950 100644
--- a/C/Util/Lzma/LzmaUtil.dsp
+++ b/C/Util/Lzma/LzmaUtil.dsp
@@ -122,6 +122,10 @@ SOURCE=..\..\Compiler.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\CpuArch.c
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\CpuArch.h
 # End Source File
 # Begin Source File
diff --git a/C/Util/LzmaLib/LzmaLib.dsp b/C/Util/LzmaLib/LzmaLib.dsp
index bacd967..f413137 100644
--- a/C/Util/LzmaLib/LzmaLib.dsp
+++ b/C/Util/LzmaLib/LzmaLib.dsp
@@ -43,7 +43,7 @@ RSC=rc.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /YX /FD /c
-# ADD CPP /nologo /Gr /MT /W3 /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /FD /c
+# ADD CPP /nologo /Gr /MT /W4 /WX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /FD /c
 # SUBTRACT CPP /YX
 # ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
@@ -71,7 +71,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /YX /FD /GZ /c
-# ADD CPP /nologo /MTd /W3 /Gm /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /D "COMPRESS_MF_MT" /FD /GZ /c
+# ADD CPP /nologo /MTd /W4 /WX /Gm /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /D "COMPRESS_MF_MT" /FD /GZ /c
 # SUBTRACT CPP /YX
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
@@ -128,6 +128,10 @@ SOURCE=..\..\Compiler.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\CpuArch.c
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\CpuArch.h
 # End Source File
 # Begin Source File
diff --git a/C/Xz.h b/C/Xz.h
index 42bc685..ad63b48 100644
--- a/C/Xz.h
+++ b/C/Xz.h
@@ -1,5 +1,5 @@
 /* Xz.h - Xz interface
-2024-01-26 : Igor Pavlov : Public domain */
+Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_XZ_H
 #define ZIP7_INC_XZ_H
@@ -121,6 +121,7 @@ typedef struct
   UInt64 startOffset;
 } CXzStream;
 
+#define Xz_CONSTRUCT(p) { (p)->numBlocks = 0;  (p)->blocks = NULL;  (p)->flags = 0; }
 void Xz_Construct(CXzStream *p);
 void Xz_Free(CXzStream *p, ISzAllocPtr alloc);
 
@@ -136,8 +137,13 @@ typedef struct
   CXzStream *streams;
 } CXzs;
 
+#define Xzs_CONSTRUCT(p) { (p)->num = 0;  (p)->numAllocated = 0;  (p)->streams = NULL; }
 void Xzs_Construct(CXzs *p);
 void Xzs_Free(CXzs *p, ISzAllocPtr alloc);
+/*
+Xzs_ReadBackward() must be called for empty CXzs object.
+Xzs_ReadBackward() can return non empty object with (p->num != 0) even in case of error.
+*/
 SRes Xzs_ReadBackward(CXzs *p, ILookInStreamPtr inStream, Int64 *startOffset, ICompressProgressPtr progress, ISzAllocPtr alloc);
 
 UInt64 Xzs_GetNumBlocks(const CXzs *p);
@@ -268,8 +274,8 @@ typedef struct
   size_t outBufSize;
   size_t outDataWritten; // the size of data in (outBuf) that were fully unpacked
 
-  Byte shaDigest[SHA256_DIGEST_SIZE];
-  Byte buf[XZ_BLOCK_HEADER_SIZE_MAX];
+  UInt32 shaDigest32[SHA256_DIGEST_SIZE / 4];
+  Byte buf[XZ_BLOCK_HEADER_SIZE_MAX]; // it must be aligned for 4-bytes
 } CXzUnpacker;
 
 /* alloc : aligned for cache line allocation is better */
diff --git a/C/XzCrc64Opt.c b/C/XzCrc64Opt.c
index 0c1fc2f..6eea4a3 100644
--- a/C/XzCrc64Opt.c
+++ b/C/XzCrc64Opt.c
@@ -1,5 +1,5 @@
 /* XzCrc64Opt.c -- CRC64 calculation (optimized functions)
-2023-12-08 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -235,7 +235,7 @@ CRC64_FUNC_PRE_BE(Z7_CRC64_NUM_TABLES_USE)
       v  = Q32BE(1, w1) ^ Q32BE(0, w0);
       v ^= Q32BE(3, d1) ^ Q32BE(2, d0);
   #endif
-#elif
+#else
 #error Stop_Compiling_Bad_CRC64_NUM_TABLES
 #endif
       p += Z7_CRC64_NUM_TABLES_USE;
diff --git a/C/XzDec.c b/C/XzDec.c
index 3d1c98e..2dac324 100644
--- a/C/XzDec.c
+++ b/C/XzDec.c
@@ -1,5 +1,5 @@
 /* XzDec.c -- Xz Decode
-2024-03-01 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -59,7 +59,7 @@ unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value)
 
   for (i = 0; i < limit;)
   {
-    Byte b = p[i];
+    const unsigned b = p[i];
     *value |= (UInt64)(b & 0x7F) << (7 * i++);
     if ((b & 0x80) == 0)
       return (b == 0 && i != 1) ? 0 : i;
@@ -796,11 +796,10 @@ SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf)
 
 static BoolInt Xz_CheckFooter(CXzStreamFlags flags, UInt64 indexSize, const Byte *buf)
 {
-  return indexSize == (((UInt64)GetUi32(buf + 4) + 1) << 2)
-      && GetUi32(buf) == CrcCalc(buf + 4, 6)
-      && flags == GetBe16(buf + 8)
-      && buf[10] == XZ_FOOTER_SIG_0
-      && buf[11] == XZ_FOOTER_SIG_1;
+  return indexSize == (((UInt64)GetUi32a(buf + 4) + 1) << 2)
+      && GetUi32a(buf) == CrcCalc(buf + 4, 6)
+      && flags == GetBe16a(buf + 8)
+      && GetUi16a(buf + 10) == (XZ_FOOTER_SIG_0 | (XZ_FOOTER_SIG_1 << 8));
 }
 
 #define READ_VARINT_AND_CHECK(buf, pos, size, res) \
@@ -1166,7 +1165,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
             p->indexPreSize = 1 + Xz_WriteVarInt(p->buf + 1, p->numBlocks);
             p->indexPos = p->indexPreSize;
             p->indexSize += p->indexPreSize;
-            Sha256_Final(&p->sha, p->shaDigest);
+            Sha256_Final(&p->sha, (Byte *)(void *)p->shaDigest32);
             Sha256_Init(&p->sha);
             p->crc = CrcUpdate(CRC_INIT_VAL, p->buf, p->indexPreSize);
             p->state = XZ_STATE_STREAM_INDEX;
@@ -1241,10 +1240,10 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
               break;
           }
           {
-            Byte digest[XZ_CHECK_SIZE_MAX];
+            UInt32 digest32[XZ_CHECK_SIZE_MAX / 4];
             p->state = XZ_STATE_BLOCK_HEADER;
             p->pos = 0;
-            if (XzCheck_Final(&p->check, digest) && memcmp(digest, p->buf, checkSize) != 0)
+            if (XzCheck_Final(&p->check, (void *)digest32) && memcmp(digest32, p->buf, checkSize) != 0)
               return SZ_ERROR_CRC;
             if (p->decodeOnlyOneBlock)
             {
@@ -1289,12 +1288,12 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
           }
           else
           {
-            Byte digest[SHA256_DIGEST_SIZE];
+            UInt32 digest32[SHA256_DIGEST_SIZE / 4];
             p->state = XZ_STATE_STREAM_INDEX_CRC;
             p->indexSize += 4;
             p->pos = 0;
-            Sha256_Final(&p->sha, digest);
-            if (memcmp(digest, p->shaDigest, SHA256_DIGEST_SIZE) != 0)
+            Sha256_Final(&p->sha, (void *)digest32);
+            if (memcmp(digest32, p->shaDigest32, SHA256_DIGEST_SIZE) != 0)
               return SZ_ERROR_CRC;
           }
         }
@@ -1313,7 +1312,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
           const Byte *ptr = p->buf;
           p->state = XZ_STATE_STREAM_FOOTER;
           p->pos = 0;
-          if (CRC_GET_DIGEST(p->crc) != GetUi32(ptr))
+          if (CRC_GET_DIGEST(p->crc) != GetUi32a(ptr))
             return SZ_ERROR_CRC;
         }
         break;
@@ -1343,7 +1342,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
       {
         if (*src != 0)
         {
-          if (((UInt32)p->padSize & 3) != 0)
+          if ((unsigned)p->padSize & 3)
             return SZ_ERROR_NO_ARCHIVE;
           p->pos = 0;
           p->state = XZ_STATE_STREAM_HEADER;
diff --git a/C/XzEnc.c b/C/XzEnc.c
index c1affad..e40f0c8 100644
--- a/C/XzEnc.c
+++ b/C/XzEnc.c
@@ -1,5 +1,5 @@
 /* XzEnc.c -- Xz Encode
-2024-03-01 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -411,6 +411,7 @@ static SRes SeqInFilter_Read(ISeqInStreamPtr pp, void *data, size_t *size)
   }
 }
 
+Z7_FORCE_INLINE
 static void SeqInFilter_Construct(CSeqInFilter *p)
 {
   p->buf = NULL;
@@ -418,6 +419,7 @@ static void SeqInFilter_Construct(CSeqInFilter *p)
   p->vt.Read = SeqInFilter_Read;
 }
 
+Z7_FORCE_INLINE
 static void SeqInFilter_Free(CSeqInFilter *p, ISzAllocPtr alloc)
 {
   if (p->StateCoder.p)
@@ -507,6 +509,7 @@ void XzFilterProps_Init(CXzFilterProps *p)
 void XzProps_Init(CXzProps *p)
 {
   p->checkId = XZ_CHECK_CRC32;
+  p->numThreadGroups = 0;
   p->blockSize = XZ_PROPS_BLOCK_SIZE_AUTO;
   p->numBlockThreads_Reduced = -1;
   p->numBlockThreads_Max = -1;
@@ -689,6 +692,7 @@ typedef struct
 } CLzma2WithFilters;
 
 
+Z7_FORCE_INLINE
 static void Lzma2WithFilters_Construct(CLzma2WithFilters *p)
 {
   p->lzma2 = NULL;
@@ -712,6 +716,7 @@ static SRes Lzma2WithFilters_Create(CLzma2WithFilters *p, ISzAllocPtr alloc, ISz
 }
 
 
+Z7_FORCE_INLINE
 static void Lzma2WithFilters_Free(CLzma2WithFilters *p, ISzAllocPtr alloc)
 {
   #ifdef USE_SUBBLOCK
@@ -1236,6 +1241,7 @@ SRes XzEnc_Encode(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr in
     }
 
     p->mtCoder.numThreadsMax = (unsigned)props->numBlockThreads_Max;
+    p->mtCoder.numThreadGroups = props->numThreadGroups;
     p->mtCoder.expectedDataSize = p->expectedDataSize;
     
     RINOK(MtCoder_Code(&p->mtCoder))
diff --git a/C/XzEnc.h b/C/XzEnc.h
index 77b78c0..ac6bbf7 100644
--- a/C/XzEnc.h
+++ b/C/XzEnc.h
@@ -1,5 +1,5 @@
 /* XzEnc.h -- Xz Encode
-2023-04-13 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #ifndef ZIP7_INC_XZ_ENC_H
 #define ZIP7_INC_XZ_ENC_H
@@ -31,6 +31,7 @@ typedef struct
   CLzma2EncProps lzma2Props;
   CXzFilterProps filterProps;
   unsigned checkId;
+  unsigned numThreadGroups; // 0 : no groups
   UInt64 blockSize;
   int numBlockThreads_Reduced;
   int numBlockThreads_Max;
diff --git a/C/XzIn.c b/C/XzIn.c
index b68af96..ba31636 100644
--- a/C/XzIn.c
+++ b/C/XzIn.c
@@ -1,38 +1,39 @@
 /* XzIn.c - Xz input
-2023-09-07 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
 #include <string.h>
 
 #include "7zCrc.h"
-#include "CpuArch.h"
 #include "Xz.h"
+#include "CpuArch.h"
 
-/*
-#define XZ_FOOTER_SIG_CHECK(p) (memcmp((p), XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) == 0)
-*/
-#define XZ_FOOTER_SIG_CHECK(p) ((p)[0] == XZ_FOOTER_SIG_0 && (p)[1] == XZ_FOOTER_SIG_1)
-
+#define XZ_FOOTER_12B_ALIGNED16_SIG_CHECK(p) \
+    (GetUi16a((const Byte *)(const void *)(p) + 10) == \
+      (XZ_FOOTER_SIG_0 | (XZ_FOOTER_SIG_1 << 8)))
 
 SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStreamPtr inStream)
 {
-  Byte sig[XZ_STREAM_HEADER_SIZE];
+  UInt32 data32[XZ_STREAM_HEADER_SIZE / 4];
   size_t processedSize = XZ_STREAM_HEADER_SIZE;
-  RINOK(SeqInStream_ReadMax(inStream, sig, &processedSize))
+  RINOK(SeqInStream_ReadMax(inStream, data32, &processedSize))
   if (processedSize != XZ_STREAM_HEADER_SIZE
-      || memcmp(sig, XZ_SIG, XZ_SIG_SIZE) != 0)
+      || memcmp(data32, XZ_SIG, XZ_SIG_SIZE) != 0)
     return SZ_ERROR_NO_ARCHIVE;
-  return Xz_ParseHeader(p, sig);
+  return Xz_ParseHeader(p, (const Byte *)(const void *)data32);
 }
 
-#define READ_VARINT_AND_CHECK(buf, pos, size, res) \
-  { const unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \
+#define READ_VARINT_AND_CHECK(buf, size, res) \
+{ const unsigned s = Xz_ReadVarInt(buf, size, res); \
   if (s == 0) return SZ_ERROR_ARCHIVE; \
-  pos += s; }
+  size -= s; \
+  buf += s; \
+}
 
 SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStreamPtr inStream, BoolInt *isIndex, UInt32 *headerSizeRes)
 {
+  MY_ALIGN(4)
   Byte header[XZ_BLOCK_HEADER_SIZE_MAX];
   unsigned headerSize;
   *headerSizeRes = 0;
@@ -57,8 +58,12 @@ SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStreamPtr inStream, BoolInt *isIndex,
   return XzBlock_Parse(p, header);
 }
 
+
 #define ADD_SIZE_CHECK(size, val) \
-  { const UInt64 newSize = size + (val); if (newSize < size) return XZ_SIZE_OVERFLOW; size = newSize; }
+{ const UInt64 newSize = size + (val); \
+  if (newSize < size) return XZ_SIZE_OVERFLOW; \
+  size = newSize; \
+}
 
 UInt64 Xz_GetUnpackSize(const CXzStream *p)
 {
@@ -82,76 +87,85 @@ UInt64 Xz_GetPackSize(const CXzStream *p)
   return size;
 }
 
-/*
-SRes XzBlock_ReadFooter(CXzBlock *p, CXzStreamFlags f, ISeqInStreamPtr inStream)
-{
-  return SeqInStream_Read(inStream, p->check, XzFlags_GetCheckSize(f));
-}
-*/
 
-static SRes Xz_ReadIndex2(CXzStream *p, const Byte *buf, size_t size, ISzAllocPtr alloc)
+// input;
+//   CXzStream (p) is empty object.
+//   size != 0
+//   (size & 3) == 0
+//   (buf) is aligned for at least 4 bytes.
+// output:
+//   p->numBlocks is number of allocated items in p->blocks
+//   p->blocks[*] values must be ignored, if function returns error.
+static SRes Xz_ParseIndex(CXzStream *p, const Byte *buf, size_t size, ISzAllocPtr alloc)
 {
-  size_t numBlocks, pos = 1;
-  UInt32 crc;
-
+  size_t numBlocks;
   if (size < 5 || buf[0] != 0)
     return SZ_ERROR_ARCHIVE;
-
   size -= 4;
-  crc = CrcCalc(buf, size);
-  if (crc != GetUi32(buf + size))
-    return SZ_ERROR_ARCHIVE;
-
+  {
+    const UInt32 crc = CrcCalc(buf, size);
+    if (crc != GetUi32a(buf + size))
+      return SZ_ERROR_ARCHIVE;
+  }
+  buf++;
+  size--;
   {
     UInt64 numBlocks64;
-    READ_VARINT_AND_CHECK(buf, pos, size, &numBlocks64)
-    numBlocks = (size_t)numBlocks64;
-    if (numBlocks != numBlocks64 || numBlocks * 2 > size)
+    READ_VARINT_AND_CHECK(buf, size, &numBlocks64)
+    // (numBlocks64) is 63-bit value, so we can calculate (numBlocks64 * 2):
+    if (numBlocks64 * 2 > size)
       return SZ_ERROR_ARCHIVE;
+    if (numBlocks64 >= ((size_t)1 << (sizeof(size_t) * 8 - 1)) / sizeof(CXzBlockSizes))
+      return SZ_ERROR_MEM; // SZ_ERROR_ARCHIVE
+    numBlocks = (size_t)numBlocks64;
   }
-  
-  Xz_Free(p, alloc);
-  if (numBlocks != 0)
+  // Xz_Free(p, alloc); // it's optional, because (p) is empty already
+  if (numBlocks)
   {
-    size_t i;
-    p->numBlocks = numBlocks;
-    p->blocks = (CXzBlockSizes *)ISzAlloc_Alloc(alloc, sizeof(CXzBlockSizes) * numBlocks);
-    if (!p->blocks)
+    CXzBlockSizes *blocks = (CXzBlockSizes *)ISzAlloc_Alloc(alloc, sizeof(CXzBlockSizes) * numBlocks);
+    if (!blocks)
       return SZ_ERROR_MEM;
-    for (i = 0; i < numBlocks; i++)
+    p->blocks = blocks;
+    p->numBlocks = numBlocks;
+    // the caller will call Xz_Free() in case of error
+    do
     {
-      CXzBlockSizes *block = &p->blocks[i];
-      READ_VARINT_AND_CHECK(buf, pos, size, &block->totalSize)
-      READ_VARINT_AND_CHECK(buf, pos, size, &block->unpackSize)
-      if (block->totalSize == 0)
+      READ_VARINT_AND_CHECK(buf, size, &blocks->totalSize)
+      READ_VARINT_AND_CHECK(buf, size, &blocks->unpackSize)
+      if (blocks->totalSize == 0)
         return SZ_ERROR_ARCHIVE;
+      blocks++;
     }
+    while (--numBlocks);
   }
-  while ((pos & 3) != 0)
-    if (buf[pos++] != 0)
+  if (size >= 4)
+    return SZ_ERROR_ARCHIVE;
+  while (size)
+    if (buf[--size])
       return SZ_ERROR_ARCHIVE;
-  return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;
+  return SZ_OK;
 }
 
+
+/*
 static SRes Xz_ReadIndex(CXzStream *p, ILookInStreamPtr stream, UInt64 indexSize, ISzAllocPtr alloc)
 {
   SRes res;
   size_t size;
   Byte *buf;
-  if (indexSize > ((UInt32)1 << 31))
-    return SZ_ERROR_UNSUPPORTED;
+  if (indexSize >= ((size_t)1 << (sizeof(size_t) * 8 - 1)))
+    return SZ_ERROR_MEM; // SZ_ERROR_ARCHIVE
   size = (size_t)indexSize;
-  if (size != indexSize)
-    return SZ_ERROR_UNSUPPORTED;
   buf = (Byte *)ISzAlloc_Alloc(alloc, size);
   if (!buf)
     return SZ_ERROR_MEM;
   res = LookInStream_Read2(stream, buf, size, SZ_ERROR_UNSUPPORTED);
   if (res == SZ_OK)
-    res = Xz_ReadIndex2(p, buf, size, alloc);
+    res = Xz_ParseIndex(p, buf, size, alloc);
   ISzAlloc_Free(alloc, buf);
   return res;
 }
+*/
 
 static SRes LookInStream_SeekRead_ForArc(ILookInStreamPtr stream, UInt64 offset, void *buf, size_t size)
 {
@@ -160,84 +174,102 @@ static SRes LookInStream_SeekRead_ForArc(ILookInStreamPtr stream, UInt64 offset,
   /* return LookInStream_Read2(stream, buf, size, SZ_ERROR_NO_ARCHIVE); */
 }
 
+
+/*
+in:
+  (*startOffset) is position in (stream) where xz_stream must be finished.
+out:
+  if returns SZ_OK, then (*startOffset) is position in stream that shows start of xz_stream.
+*/
 static SRes Xz_ReadBackward(CXzStream *p, ILookInStreamPtr stream, Int64 *startOffset, ISzAllocPtr alloc)
 {
-  UInt64 indexSize;
-  Byte buf[XZ_STREAM_FOOTER_SIZE];
+  #define TEMP_BUF_SIZE  (1 << 10)
+  UInt32 buf32[TEMP_BUF_SIZE / 4];
   UInt64 pos = (UInt64)*startOffset;
 
-  if ((pos & 3) != 0 || pos < XZ_STREAM_FOOTER_SIZE)
+  if ((pos & 3) || pos < XZ_STREAM_FOOTER_SIZE)
     return SZ_ERROR_NO_ARCHIVE;
-
   pos -= XZ_STREAM_FOOTER_SIZE;
-  RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf, XZ_STREAM_FOOTER_SIZE))
+  RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf32, XZ_STREAM_FOOTER_SIZE))
   
-  if (!XZ_FOOTER_SIG_CHECK(buf + 10))
+  if (!XZ_FOOTER_12B_ALIGNED16_SIG_CHECK(buf32))
   {
-    UInt32 total = 0;
     pos += XZ_STREAM_FOOTER_SIZE;
-    
     for (;;)
     {
-      size_t i;
-      #define TEMP_BUF_SIZE (1 << 10)
-      Byte temp[TEMP_BUF_SIZE];
-      
-      i = (pos > TEMP_BUF_SIZE) ? TEMP_BUF_SIZE : (size_t)pos;
+      // pos != 0
+      // (pos & 3) == 0
+      size_t i = pos >= TEMP_BUF_SIZE ? TEMP_BUF_SIZE : (size_t)pos;
       pos -= i;
-      RINOK(LookInStream_SeekRead_ForArc(stream, pos, temp, i))
-      total += (UInt32)i;
-      for (; i != 0; i--)
-        if (temp[i - 1] != 0)
+      RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf32, i))
+      i /= 4;
+      do
+        if (buf32[i - 1] != 0)
           break;
-      if (i != 0)
-      {
-        if ((i & 3) != 0)
-          return SZ_ERROR_NO_ARCHIVE;
-        pos += i;
-        break;
-      }
-      if (pos < XZ_STREAM_FOOTER_SIZE || total > (1 << 16))
+      while (--i);
+
+      pos += i * 4;
+      #define XZ_STREAM_BACKWARD_READING_PAD_MAX (1 << 16)
+      // here we don't support rare case with big padding for xz stream.
+      // so we have padding limit for backward reading.
+      if ((UInt64)*startOffset - pos > XZ_STREAM_BACKWARD_READING_PAD_MAX)
         return SZ_ERROR_NO_ARCHIVE;
+      if (i)
+        break;
     }
-    
+    // we try to open xz stream after skipping zero padding.
+    // ((UInt64)*startOffset == pos) is possible here!
     if (pos < XZ_STREAM_FOOTER_SIZE)
       return SZ_ERROR_NO_ARCHIVE;
     pos -= XZ_STREAM_FOOTER_SIZE;
-    RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf, XZ_STREAM_FOOTER_SIZE))
-    if (!XZ_FOOTER_SIG_CHECK(buf + 10))
+    RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf32, XZ_STREAM_FOOTER_SIZE))
+    if (!XZ_FOOTER_12B_ALIGNED16_SIG_CHECK(buf32))
       return SZ_ERROR_NO_ARCHIVE;
   }
   
-  p->flags = (CXzStreamFlags)GetBe16(buf + 8);
-
+  p->flags = (CXzStreamFlags)GetBe16a(buf32 + 2);
   if (!XzFlags_IsSupported(p->flags))
     return SZ_ERROR_UNSUPPORTED;
-
   {
     /* to eliminate GCC 6.3 warning:
        dereferencing type-punned pointer will break strict-aliasing rules */
-    const Byte *buf_ptr = buf;
-    if (GetUi32(buf_ptr) != CrcCalc(buf + 4, 6))
+    const UInt32 *buf_ptr = buf32;
+    if (GetUi32a(buf_ptr) != CrcCalc(buf32 + 1, 6))
       return SZ_ERROR_ARCHIVE;
   }
-
-  indexSize = ((UInt64)GetUi32(buf + 4) + 1) << 2;
-
-  if (pos < indexSize)
-    return SZ_ERROR_ARCHIVE;
-
-  pos -= indexSize;
-  RINOK(LookInStream_SeekTo(stream, pos))
-  RINOK(Xz_ReadIndex(p, stream, indexSize, alloc))
-
   {
-    UInt64 totalSize = Xz_GetPackSize(p);
-    if (totalSize == XZ_SIZE_OVERFLOW
-        || totalSize >= ((UInt64)1 << 63)
-        || pos < totalSize + XZ_STREAM_HEADER_SIZE)
+    const UInt64 indexSize = ((UInt64)GetUi32a(buf32 + 1) + 1) << 2;
+    if (pos < indexSize)
       return SZ_ERROR_ARCHIVE;
-    pos -= (totalSize + XZ_STREAM_HEADER_SIZE);
+    pos -= indexSize;
+    // v25.00: relaxed indexSize check. We allow big index table.
+    // if (indexSize > ((UInt32)1 << 31))
+    if (indexSize >= ((size_t)1 << (sizeof(size_t) * 8 - 1)))
+      return SZ_ERROR_MEM; // SZ_ERROR_ARCHIVE
+    RINOK(LookInStream_SeekTo(stream, pos))
+    // RINOK(Xz_ReadIndex(p, stream, indexSize, alloc))
+    {
+      SRes res;
+      const size_t size = (size_t)indexSize;
+      // if (size != indexSize) return SZ_ERROR_UNSUPPORTED;
+      Byte *buf = (Byte *)ISzAlloc_Alloc(alloc, size);
+      if (!buf)
+        return SZ_ERROR_MEM;
+      res = LookInStream_Read2(stream, buf, size, SZ_ERROR_UNSUPPORTED);
+      if (res == SZ_OK)
+        res = Xz_ParseIndex(p, buf, size, alloc);
+      ISzAlloc_Free(alloc, buf);
+      RINOK(res)
+    }
+  }
+  {
+    UInt64 total = Xz_GetPackSize(p);
+    if (total == XZ_SIZE_OVERFLOW || total >= ((UInt64)1 << 63))
+      return SZ_ERROR_ARCHIVE;
+    total += XZ_STREAM_HEADER_SIZE;
+    if (pos < total)
+      return SZ_ERROR_ARCHIVE;
+    pos -= total;
     RINOK(LookInStream_SeekTo(stream, pos))
     *startOffset = (Int64)pos;
   }
@@ -246,7 +278,6 @@ static SRes Xz_ReadBackward(CXzStream *p, ILookInStreamPtr stream, Int64 *startO
     CSecToRead secToRead;
     SecToRead_CreateVTable(&secToRead);
     secToRead.realStream = stream;
-
     RINOK(Xz_ReadHeader(&headerFlags, &secToRead.vt))
     return (p->flags == headerFlags) ? SZ_OK : SZ_ERROR_ARCHIVE;
   }
@@ -257,8 +288,7 @@ static SRes Xz_ReadBackward(CXzStream *p, ILookInStreamPtr stream, Int64 *startO
 
 void Xzs_Construct(CXzs *p)
 {
-  p->num = p->numAllocated = 0;
-  p->streams = 0;
+  Xzs_CONSTRUCT(p)
 }
 
 void Xzs_Free(CXzs *p, ISzAllocPtr alloc)
@@ -268,7 +298,7 @@ void Xzs_Free(CXzs *p, ISzAllocPtr alloc)
     Xz_Free(&p->streams[i], alloc);
   ISzAlloc_Free(alloc, p->streams);
   p->num = p->numAllocated = 0;
-  p->streams = 0;
+  p->streams = NULL;
 }
 
 UInt64 Xzs_GetNumBlocks(const CXzs *p)
@@ -307,34 +337,49 @@ UInt64 Xzs_GetPackSize(const CXzs *p)
 SRes Xzs_ReadBackward(CXzs *p, ILookInStreamPtr stream, Int64 *startOffset, ICompressProgressPtr progress, ISzAllocPtr alloc)
 {
   Int64 endOffset = 0;
+  // it's supposed that CXzs object is empty here.
+  // if CXzs object is not empty, it will add new streams to that non-empty object.
+  // Xzs_Free(p, alloc); // it's optional call to empty CXzs object.
   RINOK(ILookInStream_Seek(stream, &endOffset, SZ_SEEK_END))
   *startOffset = endOffset;
   for (;;)
   {
     CXzStream st;
     SRes res;
-    Xz_Construct(&st);
+    Xz_CONSTRUCT(&st)
     res = Xz_ReadBackward(&st, stream, startOffset, alloc);
+    // if (res == SZ_OK), then (*startOffset) is start offset of new stream if
+    // if (res != SZ_OK), then (*startOffset) is unchend or it's expected start offset of stream with error
     st.startOffset = (UInt64)*startOffset;
-    RINOK(res)
+    // we must store (st) object to array, or we must free (st) local object.
+    if (res != SZ_OK)
+    {
+      Xz_Free(&st, alloc);
+      return res;
+    }
     if (p->num == p->numAllocated)
     {
       const size_t newNum = p->num + p->num / 4 + 1;
       void *data = ISzAlloc_Alloc(alloc, newNum * sizeof(CXzStream));
       if (!data)
+      {
+        Xz_Free(&st, alloc);
         return SZ_ERROR_MEM;
+      }
       p->numAllocated = newNum;
       if (p->num != 0)
         memcpy(data, p->streams, p->num * sizeof(CXzStream));
       ISzAlloc_Free(alloc, p->streams);
       p->streams = (CXzStream *)data;
     }
+    // we use direct copying of raw data from local variable (st) to object in array.
+    // so we don't need to call Xz_Free(&st, alloc) after copying and after p->num++
     p->streams[p->num++] = st;
     if (*startOffset == 0)
-      break;
-    RINOK(LookInStream_SeekTo(stream, (UInt64)*startOffset))
+      return SZ_OK;
+    // seek operation is optional:
+    // RINOK(LookInStream_SeekTo(stream, (UInt64)*startOffset))
     if (progress && ICompressProgress_Progress(progress, (UInt64)(endOffset - *startOffset), (UInt64)(Int64)-1) != SZ_OK)
       return SZ_ERROR_PROGRESS;
   }
-  return SZ_OK;
 }
diff --git a/CPP/7zip/7zip_gcc.mak b/CPP/7zip/7zip_gcc.mak
index 45c9ab3..12f1ef2 100644
--- a/CPP/7zip/7zip_gcc.mak
+++ b/CPP/7zip/7zip_gcc.mak
@@ -302,6 +302,8 @@ $O/ListFileUtils.o: ../../../Common/ListFileUtils.cpp
         $(CXX) $(CXXFLAGS) $<
 $O/LzFindPrepare.o: ../../../Common/LzFindPrepare.cpp
         $(CXX) $(CXXFLAGS) $<
+$O/Md5Reg.o: ../../../Common/Md5Reg.cpp
+        $(CXX) $(CXXFLAGS) $<
 $O/MyMap.o: ../../../Common/MyMap.cpp
         $(CXX) $(CXXFLAGS) $<
 $O/MyString.o: ../../../Common/MyString.cpp
@@ -326,6 +328,12 @@ $O/Sha256Prepare.o: ../../../Common/Sha256Prepare.cpp
         $(CXX) $(CXXFLAGS) $<
 $O/Sha256Reg.o: ../../../Common/Sha256Reg.cpp
         $(CXX) $(CXXFLAGS) $<
+$O/Sha3Reg.o: ../../../Common/Sha3Reg.cpp
+        $(CXX) $(CXXFLAGS) $<
+$O/Sha512Prepare.o: ../../../Common/Sha512Prepare.cpp
+        $(CXX) $(CXXFLAGS) $<
+$O/Sha512Reg.o: ../../../Common/Sha512Reg.cpp
+        $(CXX) $(CXXFLAGS) $<
 $O/StdInStream.o: ../../../Common/StdInStream.cpp
         $(CXX) $(CXXFLAGS) $<
 $O/StdOutStream.o: ../../../Common/StdOutStream.cpp
@@ -1207,6 +1215,8 @@ $O/Lzma2Enc.o: ../../../../C/Lzma2Enc.c
         $(CC) $(CFLAGS) $<
 $O/LzmaLib.o: ../../../../C/LzmaLib.c
         $(CC) $(CFLAGS) $<
+$O/Md5.o: ../../../../C/Md5.c
+        $(CC) $(CFLAGS) $<
 $O/MtCoder.o: ../../../../C/MtCoder.c
         $(CC) $(CFLAGS) $<
 $O/MtDec.o: ../../../../C/MtDec.c
@@ -1229,7 +1239,11 @@ $O/Sha1.o: ../../../../C/Sha1.c
         $(CC) $(CFLAGS) $<
 $O/Sha256.o: ../../../../C/Sha256.c
         $(CC) $(CFLAGS) $<
-$O/Sort.o: ../../../../C/Sort.c
+$O/Sha3.o: ../../../../C/Sha3.c
+        $(CC) $(CFLAGS) $<
+$O/Sha512.o: ../../../../C/Sha512.c
+        $(CC) $(CFLAGS) $<
+$O/Sha512Opt.o: ../../../../C/Sha512Opt.c
         $(CC) $(CFLAGS) $<
 $O/SwapBytes.o: ../../../../C/SwapBytes.c
         $(CC) $(CFLAGS) $<
@@ -1269,6 +1283,8 @@ $O/Sha1Opt.o: ../../../../Asm/x86/Sha1Opt.asm
         $(MY_ASM) $(AFLAGS) $<
 $O/Sha256Opt.o: ../../../../Asm/x86/Sha256Opt.asm
         $(MY_ASM) $(AFLAGS) $<
+$O/Sort.o: ../../../../Asm/x86/Sort.asm
+        $(MY_ASM) $(AFLAGS) $<
 
 ifndef USE_JWASM
 USE_X86_ASM_AES=1
@@ -1283,6 +1299,8 @@ $O/Sha1Opt.o: ../../../../C/Sha1Opt.c
         $(CC) $(CFLAGS) $<
 $O/Sha256Opt.o: ../../../../C/Sha256Opt.c
         $(CC) $(CFLAGS) $<
+$O/Sort.o: ../../../../C/Sort.c
+        $(CC) $(CFLAGS) $<
 endif
 
 
diff --git a/CPP/7zip/Archive/7z/7zCompressionMode.h b/CPP/7zip/Archive/7z/7zCompressionMode.h
index 737722d..ecfee7c 100644
--- a/CPP/7zip/Archive/7z/7zCompressionMode.h
+++ b/CPP/7zip/Archive/7z/7zCompressionMode.h
@@ -59,6 +59,7 @@ struct CCompressionMethodMode
   bool NumThreads_WasForced;
   bool MultiThreadMixer;
   UInt32 NumThreads;
+  UInt32 NumThreadGroups;
   #endif
 
   UString Password; // _Wipe
@@ -74,6 +75,7 @@ struct CCompressionMethodMode
       , NumThreads_WasForced(false)
       , MultiThreadMixer(true)
       , NumThreads(1)
+      , NumThreadGroups(0)
       #endif
       , MemoryUsageLimit((UInt64)1 << 30)
   {}
diff --git a/CPP/7zip/Archive/7z/7zHandlerOut.cpp b/CPP/7zip/Archive/7z/7zHandlerOut.cpp
index ea5ea0f..c1c2b63 100644
--- a/CPP/7zip/Archive/7z/7zHandlerOut.cpp
+++ b/CPP/7zip/Archive/7z/7zHandlerOut.cpp
@@ -111,8 +111,8 @@ HRESULT CHandler::SetMainMethod(CCompressionMethodMode &methodMode)
     }
   }
 
-  const UInt64 kSolidBytes_Min = (1 << 24);
-  const UInt64 kSolidBytes_Max = ((UInt64)1 << 32);
+  const UInt64 kSolidBytes_Min = 1 << 24;
+  const UInt64 kSolidBytes_Max = (UInt64)1 << 32;  // for non-LZMA2 methods
 
   bool needSolid = false;
   
@@ -122,22 +122,24 @@ HRESULT CHandler::SetMainMethod(CCompressionMethodMode &methodMode)
 
     SetGlobalLevelTo(oneMethodInfo);
 
-    #ifndef Z7_ST
+#ifndef Z7_ST
     const bool numThreads_WasSpecifiedInMethod = (oneMethodInfo.Get_NumThreads() >= 0);
     if (!numThreads_WasSpecifiedInMethod)
     {
       // here we set the (NCoderPropID::kNumThreads) property in each method, only if there is no such property already
       CMultiMethodProps::SetMethodThreadsTo_IfNotFinded(oneMethodInfo, methodMode.NumThreads);
     }
-    #endif
+    if (methodMode.NumThreadGroups > 1)
+      CMultiMethodProps::Set_Method_NumThreadGroups_IfNotFinded(oneMethodInfo, methodMode.NumThreadGroups);
+#endif
 
     CMethodFull &methodFull = methodMode.Methods.AddNew();
     RINOK(PropsMethod_To_FullMethod(methodFull, oneMethodInfo))
 
-    #ifndef Z7_ST
+#ifndef Z7_ST
     methodFull.Set_NumThreads = true;
     methodFull.NumThreads = methodMode.NumThreads;
-    #endif
+#endif
 
     if (methodFull.Id != k_Copy)
       needSolid = true;
@@ -217,19 +219,18 @@ HRESULT CHandler::SetMainMethod(CCompressionMethodMode &methodMode)
       // here we get real chunkSize
       cs = oneMethodInfo.Get_Xz_BlockSize();
       if (dicSize > cs)
-        dicSize = cs;
+          dicSize = cs;
 
-      const UInt64 kSolidBytes_Lzma2_Max = ((UInt64)1 << 34);
+      const UInt64 kSolidBytes_Lzma2_Max = (UInt64)1 << 34;
       if (numSolidBytes > kSolidBytes_Lzma2_Max)
-        numSolidBytes = kSolidBytes_Lzma2_Max;
+          numSolidBytes = kSolidBytes_Lzma2_Max;
 
       methodFull.Set_NumThreads = false; // we don't use ICompressSetCoderMt::SetNumberOfThreads() for LZMA2 encoder
 
       #ifndef Z7_ST
       if (!numThreads_WasSpecifiedInMethod
           && !methodMode.NumThreads_WasForced
-          && methodMode.MemoryUsageLimit_WasSet
-          )
+          && methodMode.MemoryUsageLimit_WasSet)
       {
         const UInt32 lzmaThreads = oneMethodInfo.Get_Lzma_NumThreads();
         const UInt32 numBlockThreads_Original = methodMode.NumThreads / lzmaThreads;
@@ -273,14 +274,14 @@ HRESULT CHandler::SetMainMethod(CCompressionMethodMode &methodMode)
     {
       numSolidBytes = (UInt64)dicSize << 7;
       if (numSolidBytes > kSolidBytes_Max)
-        numSolidBytes = kSolidBytes_Max;
+          numSolidBytes = kSolidBytes_Max;
     }
 
     if (_numSolidBytesDefined)
       continue;
 
     if (numSolidBytes < kSolidBytes_Min)
-      numSolidBytes = kSolidBytes_Min;
+        numSolidBytes = kSolidBytes_Min;
     _numSolidBytes = numSolidBytes;
     _numSolidBytesDefined = true;
   }
@@ -704,6 +705,9 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
     methodMode.NumThreads = numThreads;
     methodMode.NumThreads_WasForced = _numThreads_WasForced;
     methodMode.MultiThreadMixer = _useMultiThreadMixer;
+#ifdef _WIN32
+    methodMode.NumThreadGroups = _numThreadGroups; // _change it
+#endif
     // headerMethod.NumThreads = 1;
     headerMethod.MultiThreadMixer = _useMultiThreadMixer;
   }
diff --git a/CPP/7zip/Archive/ApmHandler.cpp b/CPP/7zip/Archive/ApmHandler.cpp
index 56d9b6e..e88d2fe 100644
--- a/CPP/7zip/Archive/ApmHandler.cpp
+++ b/CPP/7zip/Archive/ApmHandler.cpp
@@ -6,7 +6,6 @@
 
 #include "../../Common/ComTry.h"
 
-#include "../../Windows/PropVariant.h"
 #include "../../Windows/PropVariantUtils.h"
 
 #include "../Common/RegisterArc.h"
@@ -14,8 +13,7 @@
 
 #include "HandlerCont.h"
 
-// #define Get16(p) GetBe16(p)
-#define Get32(p) GetBe32(p)
+#define Get32(p) GetBe32a(p)
 
 using namespace NWindows;
 
@@ -41,8 +39,8 @@ static const CUInt32PCharPair k_Flags[] =
   { 5, "WRITABLE" },
   { 6, "OS_PIC_CODE" },
   // { 7, "OS_SPECIFIC_2" }, // "Unused"
-  // { 8, "ChainCompatible" }, // "OS_SPECIFIC_1"
-  // { 9, "RealDeviceDriver" },
+  { 8, "ChainCompatible" }, // "OS_SPECIFIC_1"
+  { 9, "RealDeviceDriver" },
   // { 10, "CanChainToNext" },
   { 30, "MOUNTED_AT_STARTUP" },
   { 31, "STARTUP" }
@@ -74,16 +72,16 @@ struct CItem
   bool Is_Valid_and_Allocated() const
     { return (Flags & (DPME_FLAGS_VALID | DPME_FLAGS_ALLOCATED)) != 0; }
 
-  bool Parse(const Byte *p, UInt32 &numBlocksInMap)
+  bool Parse(const UInt32 *p32, UInt32 &numBlocksInMap)
   {
-    numBlocksInMap = Get32(p + 4);
-    StartBlock = Get32(p + 8);
-    NumBlocks = Get32(p + 0xc);
-    Flags = Get32(p + 0x58);
-    memcpy(Name, p + 0x10, k_Str_Size);
-    memcpy(Type, p + 0x30, k_Str_Size);
-    if (GetUi32(p) != 0x4d50) // "PM"
+    if (GetUi32a(p32) != 0x4d50) // "PM"
       return false;
+    numBlocksInMap = Get32(p32 + 4 / 4);
+    StartBlock = Get32(p32 + 8 / 4);
+    NumBlocks = Get32(p32 + 0xc / 4);
+    Flags = Get32(p32 + 0x58 / 4);
+    memcpy(Name, p32 + 0x10 / 4, k_Str_Size);
+    memcpy(Type, p32 + 0x30 / 4, k_Str_Size);
     /*
     DataStartBlock = Get32(p + 0x50);
     NumDataBlocks = Get32(p + 0x54);
@@ -96,7 +94,7 @@ struct CItem
     if (Get32(p + 0x70) != 0)
       return false;
     BootChecksum = Get32(p + 0x74);
-    memcpy(Processor, p + 0x78, 16);
+    memcpy(Processor, p32 + 0x78 / 4, 16);
     */
     return true;
   }
@@ -109,9 +107,9 @@ Z7_class_CHandler_final: public CHandlerCont
 
   CRecordVector<CItem> _items;
   unsigned _blockSizeLog;
-  UInt32 _numBlocks;
-  UInt64 _phySize;
   bool _isArc;
+  // UInt32 _numBlocks;
+  UInt64 _phySize;
 
   UInt64 BlocksToBytes(UInt32 i) const { return (UInt64)i << _blockSizeLog; }
 
@@ -132,11 +130,11 @@ API_FUNC_static_IsArc IsArc_Apm(const Byte *p, size_t size)
 {
   if (size < kSectorSize)
     return k_IsArc_Res_NEED_MORE;
-  if (GetUi64(p + 8) != 0)
+  if (GetUi32(p + 12) != 0)
     return k_IsArc_Res_NO;
   UInt32 v = GetUi32(p); // we read as little-endian
-  v ^= (kSig0 | (unsigned)kSig1 << 8);
-  if ((v & ~((UInt32)0xf << 17)))
+  v ^= kSig0 | (unsigned)kSig1 << 8;
+  if (v & ~((UInt32)0xf << 17))
     return k_IsArc_Res_NO;
   if ((0x116u >> (v >> 17)) & 1)
     return k_IsArc_Res_YES;
@@ -149,55 +147,103 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallb
   COM_TRY_BEGIN
   Close();
 
-  Byte buf[kSectorSize];
-  unsigned numSectors_in_Cluster;
+  UInt32 buf32[kSectorSize / 4];
+  unsigned numPadSectors, blockSizeLog_from_Header;
   {
-    RINOK(ReadStream_FALSE(stream, buf, kSectorSize))
-    if (GetUi64(buf + 8) != 0)
+    // Driver Descriptor Map (DDM)
+    RINOK(ReadStream_FALSE(stream, buf32, kSectorSize))
+    //  8: UInt16 sbDevType : =0 (usually), =1 in Apple Mac OS X 10.3.0 iso
+    // 10: UInt16 sbDevId   : =0 (usually), =1 in Apple Mac OS X 10.3.0 iso
+    // 12: UInt32 sbData    : =0
+    if (buf32[3] != 0)
       return S_FALSE;
-    UInt32 v = GetUi32(buf); // we read as little-endian
-    v ^= (kSig0 | (unsigned)kSig1 << 8);
-    if ((v & ~((UInt32)0xf << 17)))
+    UInt32 v = GetUi32a(buf32); // we read as little-endian
+    v ^= kSig0 | (unsigned)kSig1 << 8;
+    if (v & ~((UInt32)0xf << 17))
       return S_FALSE;
     v >>= 16;
     if (v == 0)
       return S_FALSE;
     if (v & (v - 1))
       return S_FALSE;
-    const unsigned a = (0x30210u >> v) & 3;
-    // a = 0; // for debug
-    numSectors_in_Cluster = 1u << a;
-    _blockSizeLog = 9 + a;
+    // v == { 16,8,4,2 } : block size (x256 bytes)
+    const unsigned a =
+#if 1
+        (0x30210u >> v) & 3;
+#else
+        0; // for debug : hardcoded switch to 512-bytes mode
+#endif
+    numPadSectors = (1u << a) - 1;
+    _blockSizeLog = blockSizeLog_from_Header = 9 + a;
   }
 
-  UInt32 numBlocks = Get32(buf + 4);
-  _numBlocks = numBlocks;
-
+/*
+  some APMs (that are ".iso" macOS installation files) contain
+    (blockSizeLog == 11) in DDM header,
+  and contain 2 overlapping maps:
+    1) map for  512-bytes-step
+    2) map for 2048-bytes-step
+   512-bytes-step map is correct.
+  2048-bytes-step map can be incorrect in some cases.
+
+  macos 8 / OSX DP2 iso:
+    There is shared "hfs" item in both maps.
+    And correct (offset/size) values for "hfs" partition
+    can be calculated only in 512-bytes mode (ignoring blockSizeLog == 11).
+    But some records (Macintosh.Apple_Driver*_)
+    can be correct on both modes: 512-bytes mode / 2048-bytes-step.
+  
+  macos 921 ppc / Apple Mac OS X 10.3.0 iso:
+    Both maps are correct.
+    If we use 512-bytes-step, each 4th item is (Apple_Void) with zero size.
+    And these zero size (Apple_Void) items will be first items in 2048-bytes-step map.
+*/
+
+// we define Z7_APM_SWITCH_TO_512_BYTES, because
+// we want to support old MACOS APMs that contain correct value only
+// for 512-bytes-step mode
+#define Z7_APM_SWITCH_TO_512_BYTES
+
+  const UInt32 numBlocks_from_Header = Get32(buf32 + 1);
+  UInt32 numBlocks = 0;
   {
-    for (unsigned k = numSectors_in_Cluster; --k != 0;)
+    for (unsigned k = 0; k < numPadSectors; k++)
     {
-      RINOK(ReadStream_FALSE(stream, buf, kSectorSize))
+      RINOK(ReadStream_FALSE(stream, buf32, kSectorSize))
+#ifdef Z7_APM_SWITCH_TO_512_BYTES
+      if (k == 0)
+      {
+        if (GetUi32a(buf32) == 0x4d50        // "PM"
+            // && (Get32(buf32 + 0x58 / 4) & 1) // Flags::VALID
+            // some old APMs don't use VALID flag for Apple_partition_map item
+            && Get32(buf32 + 8 / 4) == 1)    // StartBlock
+        {
+          // we switch the mode to 512-bytes-step map reading:
+          numPadSectors = 0;
+          _blockSizeLog = 9;
+          break;
+        }
+      }
+#endif
     }
   }
 
-  UInt32 numBlocksInMap = 0;
-  
   for (unsigned i = 0;;)
   {
-    RINOK(ReadStream_FALSE(stream, buf, kSectorSize))
+#ifdef Z7_APM_SWITCH_TO_512_BYTES
+    if (i != 0 || _blockSizeLog == blockSizeLog_from_Header)
+#endif
+    {
+      RINOK(ReadStream_FALSE(stream, buf32, kSectorSize))
+    }
  
     CItem item;
-    
-    UInt32 numBlocksInMap2 = 0;
-    if (!item.Parse(buf, numBlocksInMap2))
+    UInt32 numBlocksInMap = 0;
+    if (!item.Parse(buf32, numBlocksInMap))
       return S_FALSE;
-    if (i == 0)
-    {
-      numBlocksInMap = numBlocksInMap2;
-      if (numBlocksInMap > (1 << 8) || numBlocksInMap == 0)
-        return S_FALSE;
-    }
-    else if (numBlocksInMap2 != numBlocksInMap)
+    // v24.09: we don't check that all entries have same (numBlocksInMap) values,
+    // because some APMs have different (numBlocksInMap) values, if (Apple_Void) is used.
+    if (numBlocksInMap > (1 << 8) || numBlocksInMap <= i)
       return S_FALSE;
 
     const UInt32 finish = item.StartBlock + item.NumBlocks;
@@ -207,15 +253,19 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallb
         numBlocks = finish;
     
     _items.Add(item);
-    for (unsigned k = numSectors_in_Cluster; --k != 0;)
+    if (numPadSectors != 0)
     {
-      RINOK(ReadStream_FALSE(stream, buf, kSectorSize))
+      RINOK(stream->Seek(numPadSectors << 9, STREAM_SEEK_CUR, NULL))
     }
     if (++i == numBlocksInMap)
       break;
   }
   
   _phySize = BlocksToBytes(numBlocks);
+  // _numBlocks = numBlocks;
+  const UInt64 physSize = (UInt64)numBlocks_from_Header << blockSizeLog_from_Header;
+  if (_phySize < physSize)
+      _phySize = physSize;
   _isArc = true;
   _stream = stream;
 
@@ -240,22 +290,21 @@ static const Byte kProps[] =
   kpidSize,
   kpidOffset,
   kpidCharacts
+  // , kpidCpu
 };
 
 static const Byte kArcProps[] =
 {
-  kpidClusterSize,
-  kpidNumBlocks
+  kpidClusterSize
+  // , kpidNumBlocks
 };
 
 IMP_IInArchive_Props
 IMP_IInArchive_ArcProps
 
-static AString GetString(const char *s)
+static void GetString(AString &dest, const char *src)
 {
-  AString res;
-  res.SetFrom_CalcLen(s, k_Str_Size);
-  return res;
+  dest.SetFrom_CalcLen(src, k_Str_Size);
 }
 
 Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
@@ -272,7 +321,8 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
         const CItem &item = _items[i];
         if (!item.Is_Valid_and_Allocated())
           continue;
-        AString s (GetString(item.Type));
+        AString s;
+        GetString(s, item.Type);
         if (NDmg::Is_Apple_FS_Or_Unknown(s))
         {
           if (mainIndex != -1)
@@ -289,7 +339,7 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
     }
     case kpidClusterSize: prop = (UInt32)1 << _blockSizeLog; break;
     case kpidPhySize: prop = _phySize; break;
-    case kpidNumBlocks: prop = _numBlocks; break;
+    // case kpidNumBlocks: prop = _numBlocks; break;
 
     case kpidErrorFlags:
     {
@@ -319,10 +369,12 @@ Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
   {
     case kpidPath:
     {
-      AString s (GetString(item.Name));
+      AString s;
+      GetString(s, item.Name);
       if (s.IsEmpty())
         s.Add_UInt32(index);
-      AString type (GetString(item.Type));
+      AString type;
+      GetString(type, item.Type);
       {
         const char *ext = NDmg::Find_Apple_FS_Ext(type);
         if (ext)
@@ -336,6 +388,16 @@ Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
       prop = s;
       break;
     }
+/*
+    case kpidCpu:
+    {
+      AString s;
+      s.SetFrom_CalcLen(item.Processor, sizeof(item.Processor));
+      if (!s.IsEmpty())
+        prop = s;
+      break;
+    }
+*/
     case kpidSize:
     case kpidPackSize:
       prop = BlocksToBytes(item.NumBlocks);
diff --git a/CPP/7zip/Archive/ArHandler.cpp b/CPP/7zip/Archive/ArHandler.cpp
index 95e4719..944eec4 100644
--- a/CPP/7zip/Archive/ArHandler.cpp
+++ b/CPP/7zip/Archive/ArHandler.cpp
@@ -325,7 +325,7 @@ HRESULT CHandler::ParseLongNames(IInStream *stream)
 {
   unsigned i;
   for (i = 0; i < _items.Size(); i++)
-    if (_items[i].Name == "//")
+    if (_items[i].Name.IsEqualTo("//"))
       break;
   if (i == _items.Size())
     return S_OK;
@@ -378,7 +378,7 @@ void CHandler::ChangeDuplicateNames()
     if (item.Name[0] == '/')
       continue;
     CItem &prev = _items[i - 1];
-    if (item.Name == prev.Name)
+    if (item.Name.IsEqualTo(prev.Name))
     {
       if (prev.SameNameIndex < 0)
         prev.SameNameIndex = 0;
@@ -448,9 +448,9 @@ static UInt32 Get32(const Byte *p, unsigned be) { if (be) return GetBe32(p); ret
 HRESULT CHandler::ParseLibSymbols(IInStream *stream, unsigned fileIndex)
 {
   CItem &item = _items[fileIndex];
-  if (item.Name != "/" &&
-      item.Name != "__.SYMDEF"  &&
-      item.Name != "__.SYMDEF SORTED")
+  if (!item.Name.IsEqualTo("/") &&
+      !item.Name.IsEqualTo("__.SYMDEF")  &&
+      !item.Name.IsEqualTo("__.SYMDEF SORTED"))
     return S_OK;
   if (item.Size > ((UInt32)1 << 30) ||
       item.Size < 4)
@@ -462,7 +462,7 @@ HRESULT CHandler::ParseLibSymbols(IInStream *stream, unsigned fileIndex)
  
   size_t pos = 0;
 
-  if (item.Name != "/")
+  if (!item.Name.IsEqualTo("/"))
   {
     // "__.SYMDEF" parsing (BSD)
     unsigned be;
@@ -603,7 +603,7 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
     if (_longNames_FileIndex >= 0)
       _items.Delete((unsigned)_longNames_FileIndex);
 
-    if (!_items.IsEmpty() && _items[0].Name == "debian-binary")
+    if (!_items.IsEmpty() && _items[0].Name.IsEqualTo("debian-binary"))
     {
       _type = kType_Deb;
       _items.DeleteFrontal(1);
diff --git a/CPP/7zip/Archive/Bz2Handler.cpp b/CPP/7zip/Archive/Bz2Handler.cpp
index ffd7ad0..02eeee6 100644
--- a/CPP/7zip/Archive/Bz2Handler.cpp
+++ b/CPP/7zip/Archive/Bz2Handler.cpp
@@ -427,9 +427,13 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
     }
 
     CMethodProps props2 = _props;
-    #ifndef Z7_ST
+#ifndef Z7_ST
     props2.AddProp_NumThreads(_props._numThreads);
-    #endif
+#ifdef _WIN32
+    if (_props._numThreadGroups > 1)
+      props2.AddProp32(NCoderPropID::kNumThreadGroups, _props._numThreadGroups);
+#endif
+#endif
 
     return UpdateArchive(size, outStream, props2, updateCallback);
   }
diff --git a/CPP/7zip/Archive/ComHandler.cpp b/CPP/7zip/Archive/ComHandler.cpp
index 82d939d..144369e 100644
--- a/CPP/7zip/Archive/ComHandler.cpp
+++ b/CPP/7zip/Archive/ComHandler.cpp
@@ -68,7 +68,7 @@ namespace NItemType
   static const Byte kRootStorage = 5;
 }
 
-static const UInt32 kNameSizeMax = 64;
+static const unsigned kNameSizeMax = 64;
 
 struct CItem
 {
@@ -98,30 +98,30 @@ struct CRef
 
 class CDatabase
 {
-  UInt32 NumSectorsInMiniStream;
   CObjArray<UInt32> MiniSids;
 
   HRESULT AddNode(int parent, UInt32 did);
-public:
 
+public:
   CObjArray<UInt32> Fat;
-  UInt32 FatSize;
-  
   CObjArray<UInt32> Mat;
-  UInt32 MatSize;
-
   CObjectVector<CItem> Items;
   CRecordVector<CRef> Refs;
+private:
+  UInt32 NumSectorsInMiniStream;
+public:
+  UInt32 MatSize;
+  UInt32 FatSize;
 
   UInt32 LongStreamMinSize;
   unsigned SectorSizeBits;
   unsigned MiniSectorSizeBits;
 
   Int32 MainSubfile;
+  EType Type;
 
   UInt64 PhySize;
   UInt64 PhySize_Aligned;
-  EType Type;
 
   bool IsNotArcType() const
   {
@@ -148,14 +148,14 @@ public:
 
   UInt64 GetItemPackSize(UInt64 size) const
   {
-    UInt64 mask = ((UInt64)1 << (IsLargeStream(size) ? SectorSizeBits : MiniSectorSizeBits)) - 1;
+    const UInt64 mask = ((UInt32)1 << (IsLargeStream(size) ? SectorSizeBits : MiniSectorSizeBits)) - 1;
     return (size + mask) & ~mask;
   }
 
   bool GetMiniCluster(UInt32 sid, UInt64 &res) const
   {
-    unsigned subBits = SectorSizeBits - MiniSectorSizeBits;
-    UInt32 fid = sid >> subBits;
+    const unsigned subBits = SectorSizeBits - MiniSectorSizeBits;
+    const UInt32 fid = sid >> subBits;
     if (fid >= NumSectorsInMiniStream)
       return false;
     res = (((UInt64)MiniSids[fid] + 1) << subBits) + (sid & ((1 << subBits) - 1));
@@ -177,7 +177,7 @@ HRESULT CDatabase::ReadSector(IInStream *inStream, Byte *buf, unsigned sectorSiz
 HRESULT CDatabase::ReadIDs(IInStream *inStream, Byte *buf, unsigned sectorSizeBits, UInt32 sid, UInt32 *dest)
 {
   RINOK(ReadSector(inStream, buf, sectorSizeBits, sid))
-  UInt32 sectorSize = (UInt32)1 << sectorSizeBits;
+  const UInt32 sectorSize = (UInt32)1 << sectorSizeBits;
   for (UInt32 t = 0; t < sectorSize; t += 4)
     *dest++ = Get32(buf + t);
   return S_OK;
@@ -373,7 +373,7 @@ UString CDatabase::GetItemPath(UInt32 index) const
 HRESULT CDatabase::Update_PhySize_WithItem(unsigned index)
 {
   const CItem &item = Items[index];
-  bool isLargeStream = (index == 0 || IsLargeStream(item.Size));
+  const bool isLargeStream = (index == 0 || IsLargeStream(item.Size));
   if (!isLargeStream)
     return S_OK;
   const unsigned bsLog = isLargeStream ? SectorSizeBits : MiniSectorSizeBits;
@@ -527,6 +527,10 @@ HRESULT CDatabase::Open(IInStream *inStream)
       {
         CItem item;
         item.Parse(sect + i, mode64bit);
+        // we use (item.Size) check here.
+        // so we don't need additional overflow checks for (item.Size +) in another code
+        if (item.Size >= ((UInt64)1 << 63))
+          return S_FALSE;
         Items.Add(item);
       }
       sid = Fat[sid];
@@ -767,11 +771,8 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
   UInt64 totalPackSize;
   totalSize = totalPackSize = 0;
   
-  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
-  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
-
-  CLocalProgress *lps = new CLocalProgress;
-  CMyComPtr<ICompressProgressInfo> progress = lps;
+  CMyComPtr2_Create<ICompressCoder, NCompress::CCopyCoder> copyCoder;
+  CMyComPtr2_Create<ICompressProgressInfo, CLocalProgress> lps;
   lps->Init(extractCallback, false);
 
   for (i = 0; i < numItems; i++)
@@ -781,7 +782,8 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     RINOK(lps->SetCur())
     const UInt32 index = allFilesMode ? i : indices[i];
     const CItem &item = _db.Items[_db.Refs[index].Did];
-
+    Int32 res;
+   {
     CMyComPtr<ISequentialOutStream> outStream;
     const Int32 askMode = testMode ?
         NExtract::NAskMode::kTest :
@@ -801,7 +803,7 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     if (!testMode && !outStream)
       continue;
     RINOK(extractCallback->PrepareOperation(askMode))
-    Int32 res = NExtract::NOperationResult::kDataError;
+    res = NExtract::NOperationResult::kDataError;
     CMyComPtr<ISequentialInStream> inStream;
     HRESULT hres = GetStream(index, &inStream);
     if (hres == S_FALSE)
@@ -813,12 +815,12 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
       RINOK(hres)
       if (inStream)
       {
-        RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
-        if (copyCoderSpec->TotalSize == item.Size)
+        RINOK(copyCoder.Interface()->Code(inStream, outStream, NULL, NULL, lps))
+        if (copyCoder->TotalSize == item.Size)
           res = NExtract::NOperationResult::kOK;
       }
     }
-    outStream.Release();
+   }
     RINOK(extractCallback->SetOperationResult(res))
   }
   return S_OK;
diff --git a/CPP/7zip/Archive/Common/HandlerOut.cpp b/CPP/7zip/Archive/Common/HandlerOut.cpp
index 17fed67..5a11e30 100644
--- a/CPP/7zip/Archive/Common/HandlerOut.cpp
+++ b/CPP/7zip/Archive/Common/HandlerOut.cpp
@@ -4,8 +4,6 @@
 
 #include "../../../Common/StringToInt.h"
 
-#include "../Common/ParseProperties.h"
-
 #include "HandlerOut.h"
 
 namespace NArchive {
@@ -82,6 +80,7 @@ bool ParseSizeString(const wchar_t *s, const PROPVARIANT &prop, UInt64 percentsB
   return true;
 }
 
+
 bool CCommonMethodProps::SetCommonProperty(const UString &name, const PROPVARIANT &value, HRESULT &hres)
 {
   hres = S_OK;
@@ -151,6 +150,11 @@ void CMultiMethodProps::SetMethodThreadsTo_Replace(CMethodProps &oneMethodInfo,
   SetMethodProp32_Replace(oneMethodInfo, NCoderPropID::kNumThreads, numThreads);
 }
 
+void CMultiMethodProps::Set_Method_NumThreadGroups_IfNotFinded(CMethodProps &oneMethodInfo, UInt32 numThreadGroups)
+{
+  SetMethodProp32(oneMethodInfo, NCoderPropID::kNumThreadGroups, numThreadGroups);
+}
+
 #endif // Z7_ST
 
 
diff --git a/CPP/7zip/Archive/Common/HandlerOut.h b/CPP/7zip/Archive/Common/HandlerOut.h
index cfba46e..3122b05 100644
--- a/CPP/7zip/Archive/Common/HandlerOut.h
+++ b/CPP/7zip/Archive/Common/HandlerOut.h
@@ -17,12 +17,22 @@ protected:
   void InitCommon()
   {
     // _Write_MTime = true;
-    #ifndef Z7_ST
-    _numProcessors = _numThreads = NWindows::NSystem::GetNumberOfProcessors();
-    _numThreads_WasForced = false;
-    #endif
-
-    UInt64 memAvail = (UInt64)(sizeof(size_t)) << 28;
+    {
+#ifndef Z7_ST
+      _numThreads_WasForced = false;
+      UInt32 numThreads;
+#ifdef _WIN32
+      NWindows::NSystem::CProcessAffinity aff;
+      numThreads = aff.Load_and_GetNumberOfThreads();
+      _numThreadGroups = aff.IsGroupMode ? aff.Groups.GroupSizes.Size() : 0;
+#else
+      numThreads = NWindows::NSystem::GetNumberOfProcessors();
+#endif // _WIN32
+      _numProcessors = _numThreads = numThreads;
+#endif // Z7_ST
+    }
+    
+    size_t memAvail = (size_t)sizeof(size_t) << 28;
     _memAvail = memAvail;
     _memUsage_Compress = memAvail;
     _memUsage_Decompress = memAvail;
@@ -46,16 +56,19 @@ protected:
   }
 
 public:
-  #ifndef Z7_ST
+#ifndef Z7_ST
   UInt32 _numThreads;
   UInt32 _numProcessors;
+#ifdef _WIN32
+  UInt32 _numThreadGroups;
+#endif
   bool _numThreads_WasForced;
-  #endif
+#endif
 
   bool _memUsage_WasSet;
   UInt64 _memUsage_Compress;
   UInt64 _memUsage_Decompress;
-  UInt64 _memAvail;
+  size_t _memAvail;
 
   bool SetCommonProperty(const UString &name, const PROPVARIANT &value, HRESULT &hres);
 
@@ -80,10 +93,12 @@ public:
   
   void SetGlobalLevelTo(COneMethodInfo &oneMethodInfo) const;
 
-  #ifndef Z7_ST
+#ifndef Z7_ST
   static void SetMethodThreadsTo_IfNotFinded(CMethodProps &props, UInt32 numThreads);
   static void SetMethodThreadsTo_Replace(CMethodProps &props, UInt32 numThreads);
-  #endif
+  
+  static void Set_Method_NumThreadGroups_IfNotFinded(CMethodProps &props, UInt32 numThreadGroups);
+#endif
 
 
   unsigned GetNumEmptyMethods() const
diff --git a/CPP/7zip/Archive/Common/ItemNameUtils.cpp b/CPP/7zip/Archive/Common/ItemNameUtils.cpp
index 8caf1d1..150efc9 100644
--- a/CPP/7zip/Archive/Common/ItemNameUtils.cpp
+++ b/CPP/7zip/Archive/Common/ItemNameUtils.cpp
@@ -47,6 +47,25 @@ UString GetOsPath_Remove_TailSlash(const UString &name)
 }
 
 
+#if WCHAR_PATH_SEPARATOR != L'/'
+void ReplaceToWinSlashes(UString &name, bool useBackslashReplacement)
+{
+  // name.Replace(kUnixPathSepar, kOsPathSepar);
+  const unsigned len = name.Len();
+  for (unsigned i = 0; i < len; i++)
+  {
+    wchar_t c = name[i];
+    if (c == L'/')
+      c = WCHAR_PATH_SEPARATOR;
+    else if (useBackslashReplacement && c == L'\\')
+      c = WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT; // WSL scheme
+    else
+      continue;
+    name.ReplaceOneCharAtPos(i, c);
+  }
+}
+#endif
+
 void ReplaceToOsSlashes_Remove_TailSlash(UString &name, bool
     #if WCHAR_PATH_SEPARATOR != L'/'
       useBackslashReplacement
@@ -57,21 +76,7 @@ void ReplaceToOsSlashes_Remove_TailSlash(UString &name, bool
     return;
 
   #if WCHAR_PATH_SEPARATOR != L'/'
-  {
-    // name.Replace(kUnixPathSepar, kOsPathSepar);
-    const unsigned len = name.Len();
-    for (unsigned i = 0; i < len; i++)
-    {
-      wchar_t c = name[i];
-      if (c == L'/')
-        c = WCHAR_PATH_SEPARATOR;
-      else if (useBackslashReplacement && c == L'\\')
-        c = WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT; // WSL scheme
-      else
-        continue;
-      name.ReplaceOneCharAtPos(i, c);
-    }
-  }
+  ReplaceToWinSlashes(name, useBackslashReplacement);
   #endif
     
   if (name.Back() == kOsPathSepar)
diff --git a/CPP/7zip/Archive/Common/ItemNameUtils.h b/CPP/7zip/Archive/Common/ItemNameUtils.h
index 8ab9b61..cea8dcc 100644
--- a/CPP/7zip/Archive/Common/ItemNameUtils.h
+++ b/CPP/7zip/Archive/Common/ItemNameUtils.h
@@ -13,6 +13,9 @@ void ReplaceSlashes_OsToUnix(UString &name);
 UString GetOsPath(const UString &name);
 UString GetOsPath_Remove_TailSlash(const UString &name);
   
+#if WCHAR_PATH_SEPARATOR != L'/'
+void ReplaceToWinSlashes(UString &name, bool useBackslashReplacement);
+#endif
 void ReplaceToOsSlashes_Remove_TailSlash(UString &name, bool useBackslashReplacement = false);
 void NormalizeSlashes_in_FileName_for_OsPath(wchar_t *s, unsigned len);
 void NormalizeSlashes_in_FileName_for_OsPath(UString &name);
diff --git a/CPP/7zip/Archive/CpioHandler.cpp b/CPP/7zip/Archive/CpioHandler.cpp
index 2228040..62184f0 100644
--- a/CPP/7zip/Archive/CpioHandler.cpp
+++ b/CPP/7zip/Archive/CpioHandler.cpp
@@ -437,7 +437,14 @@ HRESULT CInArchive::GetNextItem()
     return S_OK;
 
   /* v23.02: we have disabled rDevMinor check because real file
-     from Apple contains rDevMinor==255 by some unknown reason */
+     from Apple contains rDevMinor==255 by some unknown reason
+     cpio 2.13 and older versions: it copies stat::st_rdev to archive.
+        and stat::st_rdev can be non-zero for some old linux/filesystems cases for regular files.
+     cpio 2.14 (2023) copies st_rdev to archive only if (S_ISBLK (st->st_mode) || S_ISCHR (st->st_mode))
+     v25.00: we have disabled RDevMajor check here to support some rare case created by cpio 2.13- with old linux.
+     But we still keep full check in IsArc_Cpio() to reduce false cpio detection cases.
+  */
+#if 0 // 0 : to disable check to support some old linux cpio archives.
   if (item.RDevMajor != 0
       // || item.RDevMinor != 0
       )
@@ -446,6 +453,7 @@ HRESULT CInArchive::GetNextItem()
         !MY_LIN_S_ISBLK(item.Mode))
       return S_OK;
   }
+#endif
 
   // Size must be 0 for FIFOs and directories
   if (item.IsDir() || MY_LIN_S_ISFIFO(item.Mode))
@@ -873,17 +881,13 @@ Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
   {
     case kpidPath:
     {
-      UString res;
-      bool needConvert = true;
-      #ifdef _WIN32
-      // if (
-      ConvertUTF8ToUnicode(item.Name, res);
-      // )
-        needConvert = false;
-      #endif
-      if (needConvert)
-        res = MultiByteToUnicodeString(item.Name, CP_OEMCP);
-      prop = NItemName::GetOsPath(res);
+#ifdef _WIN32
+      UString u;
+      ConvertUTF8ToUnicode(item.Name, u);
+#else
+      const UString u = MultiByteToUnicodeString(item.Name, CP_OEMCP);
+#endif
+      prop = NItemName::GetOsPath(u);
       break;
     }
     case kpidIsDir: prop = item.IsDir(); break;
@@ -921,16 +925,12 @@ Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
         s.SetFrom_CalcLen((const char *)(const void *)(const Byte *)item.Data, (unsigned)item.Data.Size());
         if (s.Len() == item.Data.Size())
         {
+#ifdef _WIN32
           UString u;
-          bool needConvert = true;
-          #ifdef _WIN32
-            // if (
-            ConvertUTF8ToUnicode(item.Name, u);
-            // )
-            needConvert = false;
-          #endif
-          if (needConvert)
-            u = MultiByteToUnicodeString(s, CP_OEMCP);
+          ConvertUTF8ToUnicode(item.Name, u);
+#else
+          const UString u = MultiByteToUnicodeString(s, CP_OEMCP);
+#endif
           prop = u;
         }
       }
diff --git a/CPP/7zip/Archive/DmgHandler.cpp b/CPP/7zip/Archive/DmgHandler.cpp
index 3901192..9079dc7 100644
--- a/CPP/7zip/Archive/DmgHandler.cpp
+++ b/CPP/7zip/Archive/DmgHandler.cpp
@@ -444,7 +444,7 @@ const char *Find_Apple_FS_Ext(const AString &name)
   {
     const CAppleName &a = k_Names[i];
     if (a.Ext)
-      if (name == a.AppleName)
+      if (name.IsEqualTo(a.AppleName))
         return a.Ext;
   }
   return NULL;
@@ -784,7 +784,7 @@ static const CXmlItem *FindKeyPair(const CXmlItem &item, const char *key, const
   for (unsigned i = 0; i + 1 < item.SubItems.Size(); i++)
   {
     const CXmlItem &si = item.SubItems[i];
-    if (si.IsTagged("key") && si.GetSubString() == key)
+    if (si.IsTagged("key") && si.GetSubString().IsEqualTo(key))
     {
       const CXmlItem *si_1 = &item.SubItems[i + 1];
       if (si_1->IsTagged(nextTag))
@@ -1251,7 +1251,7 @@ HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *openArchiveCall
 #endif
     }
     
-    if (xml.Root.Name != "plist")
+    if (!xml.Root.Name.IsEqualTo("plist"))
       return S_FALSE;
     
     const CXmlItem *dictItem = xml.Root.FindSubTag_GetPtr("dict");
diff --git a/CPP/7zip/Archive/FatHandler.cpp b/CPP/7zip/Archive/FatHandler.cpp
index b31ee4f..18fce91 100644
--- a/CPP/7zip/Archive/FatHandler.cpp
+++ b/CPP/7zip/Archive/FatHandler.cpp
@@ -2,13 +2,12 @@
 
 #include "StdAfx.h"
 
-// #include <stdio.h>
-
 #include "../../../C/CpuArch.h"
 
 #include "../../Common/ComTry.h"
 #include "../../Common/IntToString.h"
 #include "../../Common/MyBuffer.h"
+#include "../../Common/MyBuffer2.h"
 #include "../../Common/MyCom.h"
 #include "../../Common/StringConvert.h"
 
@@ -22,14 +21,19 @@
 
 #include "../Compress/CopyCoder.h"
 
-#include "Common/DummyOutStream.h"
+#include "Common/ItemNameUtils.h"
 
 #define Get16(p) GetUi16(p)
 #define Get32(p) GetUi32(p)
 #define Get16a(p) GetUi16a(p)
 #define Get32a(p) GetUi32a(p)
 
-#define PRF(x) /* x */
+#if 0
+#include <stdio.h>
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
 
 namespace NArchive {
 namespace NFat {
@@ -38,35 +42,34 @@ static const UInt32 kFatItemUsedByDirMask = (UInt32)1 << 31;
 
 struct CHeader
 {
-  UInt32 NumSectors;
-  UInt16 NumReservedSectors;
+  Byte NumFatBits;
+  Byte SectorSizeLog;
+  Byte SectorsPerClusterLog;
+  Byte ClusterSizeLog;
   Byte NumFats;
+  Byte MediaType;
+
+  bool VolFieldsDefined;
+  bool HeadersWarning;
+
+  UInt32 FatSize;
+  UInt32 BadCluster;
+
+  UInt16 NumReservedSectors;
+  UInt32 NumSectors;
   UInt32 NumFatSectors;
   UInt32 RootDirSector;
   UInt32 NumRootDirSectors;
   UInt32 DataSector;
 
-  UInt32 FatSize;
-  UInt32 BadCluster;
-
-  Byte NumFatBits;
-  Byte SectorSizeLog;
-  Byte SectorsPerClusterLog;
-  Byte ClusterSizeLog;
-  
   UInt16 SectorsPerTrack;
   UInt16 NumHeads;
   UInt32 NumHiddenSectors;
-
-  bool VolFieldsDefined;
-  bool HeadersWarning;
   
   UInt32 VolId;
   // Byte VolName[11];
   // Byte FileSys[8];
-
   // Byte OemName[5];
-  Byte MediaType;
 
   // 32-bit FAT
   UInt16 Flags;
@@ -104,15 +107,8 @@ struct CHeader
   bool Parse(const Byte *p);
 };
 
-static int GetLog(UInt32 num)
-{
-  for (int i = 0; i < 31; i++)
-    if (((UInt32)1 << i) == num)
-      return i;
-  return -1;
-}
 
-static const UInt32 kHeaderSize = 512;
+static const unsigned kHeaderSize = 512;
 
 API_FUNC_IsArc IsArc_Fat(const Byte *p, size_t size);
 API_FUNC_IsArc IsArc_Fat(const Byte *p, size_t size)
@@ -125,7 +121,7 @@ API_FUNC_IsArc IsArc_Fat(const Byte *p, size_t size)
 
 bool CHeader::Parse(const Byte *p)
 {
-  if (p[0x1FE] != 0x55 || p[0x1FF] != 0xAA)
+  if (Get16(p + 0x1FE) != 0xAA55)
     return false;
 
   HeadersWarning = false;
@@ -139,22 +135,40 @@ bool CHeader::Parse(const Byte *p)
   }
   {
     {
-      const UInt32 val32 = Get16(p + 11);
-      const int s = GetLog(val32);
-      if (s < 9 || s > 12)
-        return false;
-      SectorSizeLog = (Byte)s;
+      const unsigned num = Get16(p + 11);
+      unsigned i = 9;
+      unsigned m = 1 << i;
+      for (;;)
+      {
+        if (m == num)
+          break;
+        m <<= 1;
+        if (++i > 12)
+          return false;
+      }
+      SectorSizeLog = (Byte)i;
     }
     {
-      const UInt32 val32 = p[13];
-      const int s = GetLog(val32);
-      if (s < 0)
+      const unsigned num = p[13];
+      unsigned i = 0;
+      unsigned m = 1 << i;
+      for (;;)
+      {
+        if (m == num)
+          break;
+        m <<= 1;
+        if (++i > 7)
+          return false;
+      }
+      SectorsPerClusterLog = (Byte)i;
+      i += SectorSizeLog;
+      ClusterSizeLog = (Byte)i;
+      // (2^15 = 32 KB is safe cluster size that is suported by all system.
+      // (2^16 = 64 KB is supported by some systems
+      // (128 KB / 256 KB) can be created by some tools, but it is not supported by many tools.
+      if (i > 18) // 256 KB
         return false;
-      SectorsPerClusterLog = (Byte)s;
     }
-    ClusterSizeLog = (Byte)(SectorSizeLog + SectorsPerClusterLog);
-    if (ClusterSizeLog > 24)
-      return false;
   }
 
   NumReservedSectors = Get16(p + 14);
@@ -169,7 +183,7 @@ bool CHeader::Parse(const Byte *p)
   const bool isOkOffset = (codeOffset == 0)
       || (codeOffset == (p[0] == 0xEB ? 2 : 3));
 
-  const UInt16 numRootDirEntries = Get16(p + 17);
+  const unsigned numRootDirEntries = Get16(p + 17);
   if (numRootDirEntries == 0)
   {
     if (codeOffset < 90 && !isOkOffset)
@@ -183,10 +197,10 @@ bool CHeader::Parse(const Byte *p)
     if (codeOffset < 62 - 24 && !isOkOffset)
       return false;
     NumFatBits = 0;
-    const UInt32 mask = (1 << (SectorSizeLog - 5)) - 1;
-    if ((numRootDirEntries & mask) != 0)
+    const unsigned mask = (1u << (SectorSizeLog - 5)) - 1;
+    if (numRootDirEntries & mask)
       return false;
-    NumRootDirSectors = (numRootDirEntries + mask) >> (SectorSizeLog - 5);
+    NumRootDirSectors = (numRootDirEntries /* + mask */) >> (SectorSizeLog - 5);
   }
 
   NumSectors = Get16(p + 19);
@@ -198,7 +212,6 @@ bool CHeader::Parse(const Byte *p)
   else if (IsFat32())
     return false;
   */
-
   MediaType = p[21];
   NumFatSectors = Get16(p + 22);
   SectorsPerTrack = Get16(p + 24);
@@ -222,7 +235,7 @@ bool CHeader::Parse(const Byte *p)
       return false;
     RootCluster = Get32(p + 8);
     FsInfoSector = Get16(p + 12);
-    for (int i = 16; i < 28; i++)
+    for (unsigned i = 16; i < 28; i++)
       if (p[i] != 0)
         return false;
     p += 28;
@@ -260,7 +273,7 @@ bool CHeader::Parse(const Byte *p)
     if (numClusters >= 0xFFF5)
       return false;
     NumFatBits = (Byte)(numClusters < 0xFF5 ? 12 : 16);
-    BadCluster &= ((1 << NumFatBits) - 1);
+    BadCluster &= (((UInt32)1 << NumFatBits) - 1);
   }
 
   FatSize = numClusters + 2;
@@ -283,103 +296,157 @@ bool CHeader::Parse(const Byte *p)
   return true;
 }
 
-struct CItem
+
+
+class CItem
 {
-  UString UName;
-  char DosName[11];
+  Z7_CLASS_NO_COPY(CItem)
+public:
+  UInt32 Size;
+  Byte Attrib;
   Byte CTime2;
-  UInt32 CTime;
-  UInt32 MTime;
   UInt16 ADate;
-  Byte Attrib;
+  CByteBuffer LongName; // if LongName.Size() == 0 : no long name
+                        // if LongName.Size() != 0 : it's NULL terminated UTF16-LE string.
+  char DosName[11];
   Byte Flags;
-  UInt32 Size;
+  UInt32 MTime;
+  UInt32 CTime;
   UInt32 Cluster;
   Int32 Parent;
 
+  CItem() {}
+
   // NT uses Flags to store Low Case status
   bool NameIsLow() const { return (Flags & 0x8) != 0; }
   bool ExtIsLow() const { return (Flags & 0x10) != 0; }
   bool IsDir() const { return (Attrib & 0x10) != 0; }
-  UString GetShortName() const;
-  UString GetName() const;
-  UString GetVolName() const;
+  void GetShortName(UString &dest) const;
+  void GetName(UString &name) const;
 };
 
-static unsigned CopyAndTrim(char *dest, const char *src, unsigned size, bool toLower)
+
+static char *CopyAndTrim(char *dest, const char *src,
+    unsigned size, unsigned toLower)
 {
-  memcpy(dest, src, size);
-  if (toLower)
+  do
   {
-    for (unsigned i = 0; i < size; i++)
+    if (src[(size_t)size - 1] != ' ')
     {
-      char c = dest[i];
-      if (c >= 'A' && c <= 'Z')
-        dest[i] = (char)(c + 0x20);
+      const unsigned range = toLower ? 'Z' - 'A' + 1 : 0;
+      do
+      {
+        unsigned c = (Byte)*src++;
+        if ((unsigned)(c - 'A') < range)
+          c += 0x20;
+        *dest++ = (char)c;
+      }
+      while (--size);
+      break;
     }
   }
-  
-  for (unsigned i = size;;)
-  {
-    if (i == 0)
-      return 0;
-    if (dest[i - 1] != ' ')
-      return i;
-    i--;
-  }
+  while (--size);
+  *dest = 0;
+  return dest;
 }
 
-static UString FatStringToUnicode(const char *s)
+
+static void FatStringToUnicode(UString &dest, const char *s)
 {
-  return MultiByteToUnicodeString(s, CP_OEMCP);
+  MultiByteToUnicodeString2(dest, AString(s), CP_OEMCP);
 }
 
-UString CItem::GetShortName() const
+void CItem::GetShortName(UString &shortName) const
 {
   char s[16];
-  unsigned i = CopyAndTrim(s, DosName, 8, NameIsLow());
-  s[i++] = '.';
-  unsigned j = CopyAndTrim(s + i, DosName + 8, 3, ExtIsLow());
-  if (j == 0)
-    i--;
-  s[i + j] = 0;
-  return FatStringToUnicode(s);
+  char *dest = CopyAndTrim(s, DosName, 8, NameIsLow());
+  *dest++ = '.';
+  char *dest2 = CopyAndTrim(dest, DosName + 8, 3, ExtIsLow());
+  if (dest == dest2)
+    dest[-1] = 0;
+  FatStringToUnicode(shortName, s);
 }
 
-UString CItem::GetName() const
+
+
+// numWords != 0
+static unsigned ParseLongName(UInt16 *buf, unsigned numWords)
 {
-  if (!UName.IsEmpty())
-    return UName;
-  return GetShortName();
+  unsigned i;
+  for (i = 0; i < numWords; i++)
+  {
+    const unsigned c = buf[i];
+    if (c == 0)
+      break;
+    if (c == 0xFFFF)
+      return 0;
+  }
+  if (i == 0)
+    return 0;
+  buf[i] = 0;
+  numWords -= i;
+  i++;
+  if (numWords > 1)
+  {
+    numWords--;
+    buf += i;
+    do
+      if (*buf++ != 0xFFFF)
+        return 0;
+    while (--numWords);
+  }
+  return i; // it includes NULL terminator
+}
+
+
+void CItem::GetName(UString &name) const
+{
+  if (LongName.Size() >= 2)
+  {
+    const Byte * const p = LongName;
+    const unsigned numWords = ((unsigned)LongName.Size() - 2) / 2;
+    wchar_t *dest = name.GetBuf(numWords);
+    for (unsigned i = 0; i < numWords; i++)
+      dest[i] = (wchar_t)Get16(p + (size_t)i * 2);
+    name.ReleaseBuf_SetEnd(numWords);
+  }
+  else
+    GetShortName(name);
+  if (name.IsEmpty()) // it's unexpected
+    name = '_';
+  NItemName::NormalizeSlashes_in_FileName_for_OsPath(name);
 }
 
-UString CItem::GetVolName() const
+
+static void GetVolName(const char dosName[11], NWindows::NCOM::CPropVariant &prop)
 {
-  if (!UName.IsEmpty())
-    return UName;
   char s[12];
-  unsigned i = CopyAndTrim(s, DosName, 11, false);
-  s[i] = 0;
-  return FatStringToUnicode(s);
+  CopyAndTrim(s, dosName, 11, false);
+  UString u;
+  FatStringToUnicode(u, AString(s));
+  prop = u;
 }
 
+
 struct CDatabase
 {
-  CHeader Header;
   CObjectVector<CItem> Items;
   UInt32 *Fat;
+  CHeader Header;
   CMyComPtr<IInStream> InStream;
   IArchiveOpenCallback *OpenCallback;
+  CAlignedBuffer ByteBuf;
+  CByteBuffer LfnBuf;
 
   UInt32 NumFreeClusters;
-  bool VolItemDefined;
-  CItem VolItem;
   UInt32 NumDirClusters;
-  CByteBuffer ByteBuf;
   UInt64 NumCurUsedBytes;
-
   UInt64 PhySize;
 
+  UInt32 Vol_MTime;
+  char VolLabel[11];
+  bool VolItem_Defined;
+
   CDatabase(): Fat(NULL) {}
   ~CDatabase() { ClearAndClose(); }
 
@@ -388,7 +455,7 @@ struct CDatabase
   HRESULT OpenProgressFat(bool changeTotal = true);
   HRESULT OpenProgress();
 
-  UString GetItemPath(UInt32 index) const;
+  void GetItemPath(UInt32 index, UString &s) const;
   HRESULT Open();
   HRESULT ReadDir(Int32 parent, UInt32 cluster, unsigned level);
 
@@ -400,6 +467,7 @@ struct CDatabase
   HRESULT SeekToCluster(UInt32 cluster) { return SeekToSector(Header.ClusterToSector(cluster)); }
 };
 
+
 HRESULT CDatabase::SeekToSector(UInt32 sector)
 {
   return InStream_SeekSet(InStream, (UInt64)sector << Header.SectorSizeLog);
@@ -408,7 +476,7 @@ HRESULT CDatabase::SeekToSector(UInt32 sector)
 void CDatabase::Clear()
 {
   PhySize = 0;
-  VolItemDefined = false;
+  VolItem_Defined = false;
   NumDirClusters = 0;
   NumCurUsedBytes = 0;
 
@@ -440,49 +508,35 @@ HRESULT CDatabase::OpenProgress()
 {
   if (!OpenCallback)
     return S_OK;
-  UInt64 numItems = Items.Size();
+  const UInt64 numItems = Items.Size();
   return OpenCallback->SetCompleted(&numItems, &NumCurUsedBytes);
 }
 
-UString CDatabase::GetItemPath(UInt32 index) const
+void CDatabase::GetItemPath(UInt32 index, UString &s) const
 {
-  const CItem *item = &Items[index];
-  UString name = item->GetName();
+  UString name;
   for (;;)
   {
-    index = (UInt32)item->Parent;
-    if (item->Parent < 0)
-      return name;
-    item = &Items[index];
-    name.InsertAtFront(WCHAR_PATH_SEPARATOR);
-    if (item->UName.IsEmpty())
-      name.Insert(0, item->GetShortName());
-    else
-      name.Insert(0, item->UName);
+    const CItem &item = Items[index];
+    item.GetName(name);
+    if (item.Parent >= 0)
+      name.InsertAtFront(WCHAR_PATH_SEPARATOR);
+    s.Insert(0, name);
+    index = (UInt32)item.Parent;
+    if (item.Parent < 0)
+      break;
   }
 }
 
-static wchar_t *AddSubStringToName(wchar_t *dest, const Byte *p, unsigned numChars)
-{
-  for (unsigned i = 0; i < numChars; i++)
-  {
-    wchar_t c = Get16(p + i * 2);
-    if (c != 0 && c != 0xFFFF)
-      *dest++ = c;
-  }
-  *dest = 0;
-  return dest;
-}
 
 HRESULT CDatabase::ReadDir(Int32 parent, UInt32 cluster, unsigned level)
 {
-  unsigned startIndex = Items.Size();
+  const unsigned startIndex = Items.Size();
   if (startIndex >= (1 << 30) || level > 256)
     return S_FALSE;
 
-  UInt32 sectorIndex = 0;
   UInt32 blockSize = Header.ClusterSize();
-  bool clusterMode = (Header.IsFat32() || parent >= 0);
+  const bool clusterMode = (Header.IsFat32() || parent >= 0);
   if (!clusterMode)
   {
     blockSize = Header.SectorSize();
@@ -490,21 +544,26 @@ HRESULT CDatabase::ReadDir(Int32 parent, UInt32 cluster, unsigned level)
   }
 
   ByteBuf.Alloc(blockSize);
-  UString curName;
-  int checkSum = -1;
-  int numLongRecords = -1;
+
+  const unsigned k_NumLfnRecords_MAX = 20; // 260 symbols limit (strict limit)
+  // const unsigned k_NumLfnRecords_MAX = 0x40 - 1; // 1260 symbols limit (relaxed limit)
+  const unsigned k_NumLfnBytes_in_Record = 13 * 2;
+  // we reserve 2 additional bytes for NULL terminator
+  LfnBuf.Alloc(k_NumLfnRecords_MAX * k_NumLfnBytes_in_Record + 2 * 1);
   
+  UInt32 curDirBytes_read = 0;
+  UInt32 sectorIndex = 0;
+  unsigned num_lfn_records = 0;
+  unsigned lfn_RecordIndex = 0;
+  int checkSum = -1;
+  bool is_record_error = false;
+
   for (UInt32 pos = blockSize;; pos += 32)
   {
     if (pos == blockSize)
     {
       pos = 0;
 
-      if ((NumDirClusters & 0xFF) == 0)
-      {
-        RINOK(OpenProgress())
-      }
-
       if (clusterMode)
       {
         if (Header.IsEoc(cluster))
@@ -514,21 +573,37 @@ HRESULT CDatabase::ReadDir(Int32 parent, UInt32 cluster, unsigned level)
         PRF(printf("\nCluster = %4X", cluster));
         RINOK(SeekToCluster(cluster))
         const UInt32 newCluster = Fat[cluster];
-        if ((newCluster & kFatItemUsedByDirMask) != 0)
+        if (newCluster & kFatItemUsedByDirMask)
           return S_FALSE;
         Fat[cluster] |= kFatItemUsedByDirMask;
         cluster = newCluster;
         NumDirClusters++;
+        if ((NumDirClusters & 0xFF) == 0)
+        {
+          RINOK(OpenProgress())
+        }
         NumCurUsedBytes += Header.ClusterSize();
       }
       else if (sectorIndex++ >= Header.NumRootDirSectors)
         break;
       
+      // if (curDirBytes_read > (1u << 28)) // do we need some relaxed limit for non-MS FATs?
+      if (curDirBytes_read >= (1u << 21)) // 2MB limit from FAT specification.
+        return S_FALSE;
       RINOK(ReadStream_FALSE(InStream, ByteBuf, blockSize))
+      curDirBytes_read += blockSize;
     }
   
-    const Byte *p = ByteBuf + pos;
-    
+    if (is_record_error)
+    {
+      Header.HeadersWarning = true;
+      num_lfn_records = 0;
+      lfn_RecordIndex = 0;
+      checkSum = -1;
+    }
+
+    const Byte * const p = ByteBuf + pos;
+   
     if (p[0] == 0)
     {
       /*
@@ -538,125 +613,191 @@ HRESULT CDatabase::ReadDir(Int32 parent, UInt32 cluster, unsigned level)
       */
       break;
     }
-    
+
+    is_record_error = true;
+
     if (p[0] == 0xE5)
     {
-      if (numLongRecords > 0)
-        return S_FALSE;
+      // deleted entry
+      if (num_lfn_records == 0)
+        is_record_error = false;
       continue;
     }
-    
-    Byte attrib = p[11];
-    if ((attrib & 0x3F) == 0xF)
+    // else
     {
-      if (p[0] > 0x7F || Get16(p + 26) != 0)
-        return S_FALSE;
-      int longIndex = p[0] & 0x3F;
-      if (longIndex == 0)
-        return S_FALSE;
-      bool isLast = (p[0] & 0x40) != 0;
-      if (numLongRecords < 0)
+      const Byte attrib = p[11];
+      // maybe we can use more strick check : (attrib == 0xF) ?
+      if ((attrib & 0x3F) == 0xF)
       {
-        if (!isLast)
+        // long file name (LFN) entry
+        const unsigned longIndex = p[0] & 0x3F;
+        if (longIndex == 0
+            || longIndex > k_NumLfnRecords_MAX
+            || p[0] > 0x7F
+            || Get16a(p + 26) != 0 // LDIR_FstClusLO
+            )
+        {
           return S_FALSE;
-        numLongRecords = longIndex;
+          // break;
+        }
+        const bool isLast = (p[0] & 0x40) != 0;
+        if (num_lfn_records == 0)
+        {
+          if (!isLast)
+            continue; // orphan
+          num_lfn_records = longIndex;
+        }
+        else if (isLast || longIndex != lfn_RecordIndex)
+        {
+          return S_FALSE;
+          // break;
+        }
+        
+        lfn_RecordIndex = longIndex - 1;
+        
+        if (p[12] == 0)
+        {
+          Byte * const dest = LfnBuf + k_NumLfnBytes_in_Record * lfn_RecordIndex;
+          memcpy(dest,          p +  1, 5 * 2);
+          memcpy(dest +  5 * 2, p + 14, 6 * 2);
+          memcpy(dest + 11 * 2, p + 28, 2 * 2);
+          if (isLast)
+            checkSum = p[13];
+          if (checkSum == p[13])
+            is_record_error = false;
+          // else return S_FALSE;
+          continue;
+        }
+        // else
+        checkSum = -1; // we will ignore LfnBuf in this case
+        continue;
       }
-      else if (isLast || numLongRecords != longIndex)
-        return S_FALSE;
-
-      numLongRecords--;
       
-      if (p[12] == 0)
+      if (lfn_RecordIndex)
       {
-        wchar_t nameBuf[14];
-        wchar_t *dest;
-        
-        dest = AddSubStringToName(nameBuf, p + 1, 5);
-        dest = AddSubStringToName(dest, p + 14, 6);
-        AddSubStringToName(dest, p + 28, 2);
-        curName = nameBuf + curName;
-        if (isLast)
-          checkSum = p[13];
-        if (checkSum != p[13])
-          return S_FALSE;
+        Header.HeadersWarning = true;
+        // return S_FALSE;
       }
-    }
-    else
-    {
-      if (numLongRecords > 0)
-        return S_FALSE;
-      CItem item;
-      memcpy(item.DosName, p, 11);
+      // lfn_RecordIndex = 0;
 
-      if (checkSum >= 0)
+      const unsigned type_in_attrib = attrib & 0x18;
+      if (type_in_attrib == 0x18)
       {
-        Byte sum = 0;
-        for (unsigned i = 0; i < 11; i++)
-          sum = (Byte)(((sum & 1) ? 0x80 : 0) + (sum >> 1) + (Byte)item.DosName[i]);
-        if (sum == checkSum)
-          item.UName = curName;
+        // invalid directory record (both flags are set: dir_flag and volume_flag)
+        return S_FALSE;
+        // break;
+        // continue;
       }
-
-      if (item.DosName[0] == 5)
-        item.DosName[0] = (char)(Byte)0xE5;
-      item.Attrib = attrib;
-      item.Flags = p[12];
-      item.Size = Get32(p + 28);
-      item.Cluster = Get16(p + 26);
-      if (Header.NumFatBits > 16)
-        item.Cluster |= ((UInt32)Get16(p + 20) << 16);
-      else
+      if (type_in_attrib == 8) // volume_flag
       {
-        // OS/2 and WinNT probably can store EA (extended atributes) in that field.
+        if (!VolItem_Defined && level == 0)
+        {
+          VolItem_Defined = true;
+          memcpy(VolLabel, p, 11);
+          Vol_MTime = Get32(p + 22);
+          is_record_error = false;
+        }
       }
-
-      item.CTime = Get32(p + 14);
-      item.CTime2 = p[13];
-      item.ADate = Get16(p + 18);
-      item.MTime = Get32(p + 22);
-      item.Parent = parent;
-
-      if (attrib == 8)
+      else if (memcmp(p, ".          ", 11) == 0
+            || memcmp(p, "..         ", 11) == 0)
       {
-        VolItem = item;
-        VolItemDefined = true;
+        if (num_lfn_records == 0 && type_in_attrib == 0x10) // dir_flag
+          is_record_error = false;
       }
       else
-        if (memcmp(item.DosName, ".          ", 11) != 0 &&
-            memcmp(item.DosName, "..         ", 11) != 0)
       {
-        if (!item.IsDir())
-          NumCurUsedBytes += Header.GetFilePackSize(item.Size);
-        Items.Add(item);
-        PRF(printf("\n%7d: %S", Items.Size(), GetItemPath(Items.Size() - 1)));
+        CItem &item = Items.AddNew();
+        memcpy(item.DosName, p, 11);
+        if (item.DosName[0] == 5)
+          item.DosName[0] = (char)(Byte)0xE5; // 0xE5 is valid KANJI lead byte value.
+        item.Attrib = attrib;
+        item.Flags = p[12];
+        item.Size = Get32a(p + 28);
+        item.Cluster = Get16a(p + 26);
+        if (Header.NumFatBits > 16)
+          item.Cluster |= ((UInt32)Get16a(p + 20) << 16);
+        else
+        {
+          // OS/2 and WinNT probably can store EA (extended atributes) in that field.
+        }
+        item.CTime = Get32(p + 14);
+        item.CTime2 = p[13];
+        item.ADate = Get16a(p + 18);
+        item.MTime = Get32(p + 22);
+        item.Parent = parent;
+        {
+          if (!item.IsDir())
+            NumCurUsedBytes += Header.GetFilePackSize(item.Size);
+          // PRF(printf("\n%7d: %S", Items.Size(), GetItemPath(Items.Size() - 1)));
+          PRF(printf("\n%7d" /* ": %S" */, Items.Size() /* , item.GetShortName() */ );)
+        }
+        if (num_lfn_records == 0)
+          is_record_error = false;
+        else if (checkSum >= 0 && lfn_RecordIndex == 0)
+        {
+          Byte sum = 0;
+          for (unsigned i = 0; i < 11; i++)
+            sum = (Byte)((sum << 7) + (sum >> 1) + (Byte)item.DosName[i]);
+          if (sum == checkSum)
+          {
+            const unsigned numWords = ParseLongName((UInt16 *)(void *)(Byte *)LfnBuf,
+                num_lfn_records * k_NumLfnBytes_in_Record / 2);
+            if (numWords > 1)
+            {
+              // numWords includes NULL terminator
+              item.LongName.CopyFrom(LfnBuf, numWords * 2);
+              is_record_error = false;
+            }
+          }
+        }
+        
+        if (
+            // item.LongName.Size() < 20 ||  // for debug
+            item.LongName.Size() <= 2 * 1
+            && memcmp(p, "           ", 11) == 0)
+        {
+          char s[16 + 16];
+          const size_t numChars = (size_t)(ConvertUInt32ToString(
+              Items.Size() - 1 - startIndex,
+              MyStpCpy(s, "[NONAME]-")) - s) + 1;
+          item.LongName.Alloc(numChars * 2);
+          for (size_t i = 0; i < numChars; i++)
+          {
+            SetUi16a(item.LongName + i * 2, (Byte)s[i])
+          }
+          Header.HeadersWarning = true;
+        }
       }
-      numLongRecords = -1;
-      curName.Empty();
-      checkSum = -1;
+      num_lfn_records = 0;
     }
   }
 
-  unsigned finishIndex = Items.Size();
+  if (is_record_error)
+    Header.HeadersWarning = true;
+
+  const unsigned finishIndex = Items.Size();
   for (unsigned i = startIndex; i < finishIndex; i++)
   {
     const CItem &item = Items[i];
     if (item.IsDir())
     {
-      PRF(printf("\n%S", GetItemPath(i)));
-      RINOK(CDatabase::ReadDir((int)i, item.Cluster, level + 1))
+      PRF(printf("\n---- %c%c%c%c%c", item.DosName[0], item.DosName[1], item.DosName[2], item.DosName[3], item.DosName[4]));
+      RINOK(ReadDir((int)i, item.Cluster, level + 1))
     }
   }
   return S_OK;
 }
 
+
+
 HRESULT CDatabase::Open()
 {
   Clear();
-  bool numFreeClustersDefined = false;
+  bool numFreeClusters_Defined = false;
   {
-    Byte buf[kHeaderSize];
-    RINOK(ReadStream_FALSE(InStream, buf, kHeaderSize))
-    if (!Header.Parse(buf))
+    UInt32 buf32[kHeaderSize / 4];
+    RINOK(ReadStream_FALSE(InStream, buf32, kHeaderSize))
+    if (!Header.Parse((Byte *)(void *)buf32))
       return S_FALSE;
     UInt64 fileSize;
     RINOK(InStream_GetSize_SeekToEnd(InStream, fileSize))
@@ -671,21 +812,21 @@ HRESULT CDatabase::Open()
     {
       if (((UInt32)Header.FsInfoSector << Header.SectorSizeLog) + kHeaderSize <= fileSize
           && SeekToSector(Header.FsInfoSector) == S_OK
-          && ReadStream_FALSE(InStream, buf, kHeaderSize) == S_OK
-          && 0xaa550000 == Get32(buf + 508)
-          && 0x41615252 == Get32(buf)
-          && 0x61417272 == Get32(buf + 484))
+          && ReadStream_FALSE(InStream, buf32, kHeaderSize) == S_OK
+          && 0xaa550000 == Get32a(buf32 + 508 / 4)
+          && 0x41615252 == Get32a(buf32)
+          && 0x61417272 == Get32a(buf32 + 484 / 4))
       {
-        NumFreeClusters = Get32(buf + 488);
-        numFreeClustersDefined = (NumFreeClusters <= Header.FatSize);
+        NumFreeClusters = Get32a(buf32 + 488 / 4);
+        numFreeClusters_Defined = (NumFreeClusters <= Header.FatSize);
       }
       else
         Header.HeadersWarning = true;
     }
   }
 
-  // numFreeClustersDefined = false; // to recalculate NumFreeClusters
-  if (!numFreeClustersDefined)
+  // numFreeClusters_Defined = false; // to recalculate NumFreeClusters
+  if (!numFreeClusters_Defined)
     NumFreeClusters = 0;
 
   CByteBuffer byteBuf;
@@ -695,7 +836,7 @@ HRESULT CDatabase::Open()
   RINOK(SeekToSector(Header.GetFatSector()))
   if (Header.NumFatBits == 32)
   {
-    const UInt32 kBufSize = (1 << 15);
+    const UInt32 kBufSize = 1 << 15;
     byteBuf.Alloc(kBufSize);
     for (UInt32 i = 0;;)
     {
@@ -712,7 +853,7 @@ HRESULT CDatabase::Open()
       const UInt32 *src = (const UInt32 *)(const void *)(const Byte *)byteBuf;
       UInt32 *dest = Fat + i;
       const UInt32 *srcLim = src + size;
-      if (numFreeClustersDefined)
+      if (numFreeClusters_Defined)
         do
           *dest++ = Get32a(src) & 0x0FFFFFFF;
         while (++src != srcLim);
@@ -731,7 +872,7 @@ HRESULT CDatabase::Open()
       i += size;
       if ((i & 0xFFFFF) == 0)
       {
-        RINOK(OpenProgressFat(!numFreeClustersDefined))
+        RINOK(OpenProgressFat(!numFreeClusters_Defined))
       }
     }
   }
@@ -751,7 +892,7 @@ HRESULT CDatabase::Open()
       for (UInt32 j = 0; j < fatSize; j++)
         fat[j] = (Get16(p + j * 3 / 2) >> ((j & 1) << 2)) & 0xFFF;
 
-    if (!numFreeClustersDefined)
+    if (!numFreeClusters_Defined)
     {
       UInt32 numFreeClusters = 0;
       for (UInt32 i = 0; i < fatSize; i++)
@@ -781,11 +922,12 @@ HRESULT CDatabase::Open()
 
 Z7_class_CHandler_final:
   public IInArchive,
+  public IArchiveGetRawProps,
   public IInArchiveGetStream,
   public CMyUnknownImp,
   CDatabase
 {
-  Z7_IFACES_IMP_UNK_2(IInArchive, IInArchiveGetStream)
+  Z7_IFACES_IMP_UNK_3(IInArchive, IArchiveGetRawProps, IInArchiveGetStream)
 };
 
 Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
@@ -831,6 +973,8 @@ Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
   COM_TRY_END
 }
 
+
+
 static const Byte kProps[] =
 {
   kpidPath,
@@ -842,6 +986,7 @@ static const Byte kProps[] =
   kpidATime,
   kpidAttrib,
   kpidShortName
+  // , kpidCharacts
 };
 
 enum
@@ -922,15 +1067,16 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
     case kpidPhySize: prop = PhySize; break;
     case kpidFreeSpace: prop = (UInt64)NumFreeClusters << Header.ClusterSizeLog; break;
     case kpidHeadersSize: prop = GetHeadersSize(); break;
-    case kpidMTime: if (VolItemDefined) PropVariant_SetFrom_DosTime(prop, VolItem.MTime); break;
+    case kpidMTime: if (VolItem_Defined) PropVariant_SetFrom_DosTime(prop, Vol_MTime); break;
     case kpidShortComment:
-    case kpidVolumeName: if (VolItemDefined) prop = VolItem.GetVolName(); break;
+    case kpidVolumeName: if (VolItem_Defined) GetVolName(VolLabel, prop); break;
     case kpidNumFats: if (Header.NumFats != 2) prop = Header.NumFats; break;
     case kpidSectorSize: prop = (UInt32)1 << Header.SectorSizeLog; break;
     // case kpidSectorsPerTrack: prop = Header.SectorsPerTrack; break;
     // case kpidNumHeads: prop = Header.NumHeads; break;
     // case kpidOemName: STRING_TO_PROP(Header.OemName, prop); break;
     case kpidId: if (Header.VolFieldsDefined) prop = Header.VolId; break;
+    case kpidIsTree: prop = true; break;
     // case kpidVolName: if (Header.VolFieldsDefined) STRING_TO_PROP(Header.VolName, prop); break;
     // case kpidFileSysType: if (Header.VolFieldsDefined) STRING_TO_PROP(Header.FileSys, prop); break;
     // case kpidHiddenSectors: prop = Header.NumHiddenSectors; break;
@@ -948,6 +1094,52 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
   COM_TRY_END
 }
 
+
+Z7_COM7F_IMF(CHandler::GetNumRawProps(UInt32 *numProps))
+{
+  *numProps = 0;
+  return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawPropInfo(UInt32 /* index */ , BSTR *name, PROPID *propID))
+{
+  *name = NULL;
+  *propID = 0;
+  return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetParent(UInt32 index, UInt32 *parent, UInt32 *parentType))
+{
+  *parentType = NParentType::kDir;
+  int par = -1;
+  if (index < Items.Size())
+    par = Items[index].Parent;
+  *parent = (UInt32)(Int32)par;
+  return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+  *data = NULL;
+  *dataSize = 0;
+  *propType = 0;
+
+  if (index < Items.Size()
+      && propID == kpidName)
+  {
+    CByteBuffer &buf = Items[index].LongName;
+    const UInt32 size = (UInt32)buf.Size();
+    if (size != 0)
+    {
+      *dataSize = size;
+      *propType = NPropDataType::kUtf16z;
+      *data = (const void *)(const Byte *)buf;
+    }
+  }
+  return S_OK;
+}
+
+
 Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
 {
   COM_TRY_BEGIN
@@ -955,8 +1147,28 @@ Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
   const CItem &item = Items[index];
   switch (propID)
   {
-    case kpidPath: prop = GetItemPath(index); break;
-    case kpidShortName: prop = item.GetShortName(); break;
+    case kpidPath:
+    case kpidName:
+    case kpidShortName:
+    {
+      UString s;
+      if (propID == kpidPath)
+        GetItemPath(index, s);
+      else if (propID == kpidName)
+        item.GetName(s);
+      else
+        item.GetShortName(s);
+      prop = s;
+      break;
+    }
+/*
+    case kpidCharacts:
+    {
+      if (item.LongName.Size())
+        prop = "LFN";
+      break;
+    }
+*/
     case kpidIsDir: prop = item.IsDir(); break;
     case kpidMTime: PropVariant_SetFrom_DosTime(prop, item.MTime); break;
     case kpidCTime: FatTimeToProp(item.CTime, item.CTime2, prop); break;
@@ -1004,34 +1216,44 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     Int32 testMode, IArchiveExtractCallback *extractCallback))
 {
   COM_TRY_BEGIN
-  const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
-  if (allFilesMode)
+  if (numItems == (UInt32)(Int32)-1)
+  {
+    indices = NULL;
     numItems = Items.Size();
-  if (numItems == 0)
-    return S_OK;
-  UInt32 i;
+    if (numItems == 0)
+      return S_OK;
+  }
+  else
+  {
+    if (numItems == 0)
+      return S_OK;
+    if (!indices)
+      return E_INVALIDARG;
+  }
   UInt64 totalSize = 0;
-  for (i = 0; i < numItems; i++)
   {
-    const CItem &item = Items[allFilesMode ? i : indices[i]];
-    if (!item.IsDir())
-      totalSize += item.Size;
+    UInt32 i = 0;
+    do
+    {
+      UInt32 index = i;
+      if (indices)
+        index = indices[i];
+      const CItem &item = Items[index];
+      if (!item.IsDir())
+        totalSize += item.Size;
+    }
+    while (++i != numItems);
   }
   RINOK(extractCallback->SetTotal(totalSize))
 
-  UInt64 totalPackSize;
-  totalSize = totalPackSize = 0;
-  
-  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
-  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
-
-  CLocalProgress *lps = new CLocalProgress;
-  CMyComPtr<ICompressProgressInfo> progress = lps;
+  CMyComPtr2_Create<ICompressProgressInfo, CLocalProgress> lps;
   lps->Init(extractCallback, false);
+  CMyComPtr2_Create<ICompressCoder, NCompress::CCopyCoder> copyCoder;
 
-  CDummyOutStream *outStreamSpec = new CDummyOutStream;
-  CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+  UInt64 totalPackSize;
+  totalSize = totalPackSize = 0;
 
+  UInt32 i;
   for (i = 0;; i++)
   {
     lps->InSize = totalPackSize;
@@ -1039,46 +1261,45 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     RINOK(lps->SetCur())
     if (i == numItems)
       break;
-    CMyComPtr<ISequentialOutStream> realOutStream;
-    const Int32 askMode = testMode ?
-        NExtract::NAskMode::kTest :
-        NExtract::NAskMode::kExtract;
-    const UInt32 index = allFilesMode ? i : indices[i];
-    const CItem &item = Items[index];
-    RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
-
-    if (item.IsDir())
+    int res;
     {
+      CMyComPtr<ISequentialOutStream> realOutStream;
+      const Int32 askMode = testMode ?
+          NExtract::NAskMode::kTest :
+          NExtract::NAskMode::kExtract;
+      UInt32 index = i;
+      if (indices)
+        index = indices[i];
+      const CItem &item = Items[index];
+      RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+        
+      if (item.IsDir())
+      {
+        RINOK(extractCallback->PrepareOperation(askMode))
+        RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+        continue;
+      }
+      
+      totalPackSize += Header.GetFilePackSize(item.Size);
+      totalSize += item.Size;
+      
+      if (!testMode && !realOutStream)
+        continue;
       RINOK(extractCallback->PrepareOperation(askMode))
-      RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
-      continue;
-    }
-
-    totalPackSize += Header.GetFilePackSize(item.Size);
-    totalSize += item.Size;
-
-    if (!testMode && !realOutStream)
-      continue;
-    RINOK(extractCallback->PrepareOperation(askMode))
-
-    outStreamSpec->SetStream(realOutStream);
-    realOutStream.Release();
-    outStreamSpec->Init();
-
-    int res = NExtract::NOperationResult::kDataError;
-    CMyComPtr<ISequentialInStream> inStream;
-    HRESULT hres = GetStream(index, &inStream);
-    if (hres != S_FALSE)
-    {
-      RINOK(hres)
-      if (inStream)
+      res = NExtract::NOperationResult::kDataError;
+      CMyComPtr<ISequentialInStream> inStream;
+      const HRESULT hres = GetStream(index, &inStream);
+      if (hres != S_FALSE)
       {
-        RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
-        if (copyCoderSpec->TotalSize == item.Size)
-          res = NExtract::NOperationResult::kOK;
+        RINOK(hres)
+        if (inStream)
+        {
+          RINOK(copyCoder.Interface()->Code(inStream, realOutStream, NULL, NULL, lps))
+          if (copyCoder->TotalSize == item.Size)
+            res = NExtract::NOperationResult::kOK;
+        }
       }
     }
-    outStreamSpec->ReleaseStream();
     RINOK(extractCallback->SetOperationResult(res))
   }
   return S_OK;
diff --git a/CPP/7zip/Archive/HfsHandler.cpp b/CPP/7zip/Archive/HfsHandler.cpp
index 4049fbc..46e0239 100644
--- a/CPP/7zip/Archive/HfsHandler.cpp
+++ b/CPP/7zip/Archive/HfsHandler.cpp
@@ -25,6 +25,9 @@
 #define Get32(p) GetBe32(p)
 #define Get64(p) GetBe64(p)
 
+#define Get16a(p) GetBe16a(p)
+#define Get32a(p) GetBe32a(p)
+
 namespace NArchive {
 namespace NHfs {
 
@@ -104,23 +107,21 @@ UInt32 CFork::Calc_NumBlocks_from_Extents() const
 {
   UInt32 num = 0;
   FOR_VECTOR (i, Extents)
-  {
     num += Extents[i].NumBlocks;
-  }
   return num;
 }
 
 bool CFork::Check_NumBlocks() const
 {
-  UInt32 num = 0;
+  UInt32 num = NumBlocks;
   FOR_VECTOR (i, Extents)
   {
-    UInt32 next = num + Extents[i].NumBlocks;
-    if (next < num)
+    const UInt32 cur = Extents[i].NumBlocks;
+    if (num < cur)
       return false;
-    num = next;
+    num -= cur;
   }
-  return num == NumBlocks;
+  return num == 0;
 }
 
 struct CIdIndexPair
@@ -175,7 +176,7 @@ static int Find_in_IdExtents(const CObjectVector<CIdExtents> &items, UInt32 id)
 
 bool CFork::Upgrade(const CObjectVector<CIdExtents> &items, UInt32 id)
 {
-  int index = Find_in_IdExtents(items, id);
+  const int index = Find_in_IdExtents(items, id);
   if (index < 0)
     return true;
   const CIdExtents &item = items[index];
@@ -188,8 +189,13 @@ bool CFork::Upgrade(const CObjectVector<CIdExtents> &items, UInt32 id)
 
 struct CVolHeader
 {
-  Byte Header[2];
-  UInt16 Version;
+  unsigned BlockSizeLog;
+  UInt32 NumFiles;
+  UInt32 NumFolders;
+  UInt32 NumBlocks;
+  UInt32 NumFreeBlocks;
+
+  bool Is_Hsfx_ver5;
   // UInt32 Attr;
   // UInt32 LastMountedVersion;
   // UInt32 JournalInfoBlock;
@@ -199,19 +205,13 @@ struct CVolHeader
   // UInt32 BackupTime;
   // UInt32 CheckedTime;
   
-  UInt32 NumFiles;
-  UInt32 NumFolders;
-  unsigned BlockSizeLog;
-  UInt32 NumBlocks;
-  UInt32 NumFreeBlocks;
-
   // UInt32 WriteCount;
   // UInt32 FinderInfo[8];
   // UInt64 VolID;
 
   UInt64 GetPhySize() const { return (UInt64)NumBlocks << BlockSizeLog; }
   UInt64 GetFreeSize() const { return (UInt64)NumFreeBlocks << BlockSizeLog; }
-  bool IsHfsX() const { return Version > 4; }
+  bool IsHfsX() const { return Is_Hsfx_ver5; }
 };
 
 inline void HfsTimeToFileTime(UInt32 hfsTime, FILETIME &ft)
@@ -463,18 +463,18 @@ public:
   bool UnsupportedFeature;
   bool ThereAreAltStreams;
   // bool CaseSensetive;
+  UInt32 MethodsMask;
   UString ResFileName;
 
   UInt64 SpecOffset;
-  UInt64 PhySize;
+  // UInt64 PhySize;
   UInt64 PhySize2;
   UInt64 ArcFileSize;
-  UInt32 MethodsMask;
 
   void Clear()
   {
     SpecOffset = 0;
-    PhySize = 0;
+    // PhySize = 0;
     PhySize2 = 0;
     ArcFileSize = 0;
     MethodsMask = 0;
@@ -596,7 +596,7 @@ HRESULT CDatabase::ReadFile(const CFork &fork, CByteBuffer &buf, IInStream *inSt
 {
   if (fork.NumBlocks >= Header.NumBlocks)
     return S_FALSE;
-  if ((ArcFileSize >> Header.BlockSizeLog) + 1 < fork.NumBlocks)
+  if (((ArcFileSize - SpecOffset) >> Header.BlockSizeLog) + 1 < fork.NumBlocks)
     return S_FALSE;
 
   const size_t totalSize = (size_t)fork.NumBlocks << Header.BlockSizeLog;
@@ -1328,28 +1328,26 @@ HRESULT CDatabase::LoadCatalog(const CFork &fork, const CObjectVector<CIdExtents
   return S_OK;
 }
 
-static const unsigned kHeaderPadSize = (1 << 10);
+static const unsigned kHeaderPadSize = 1 << 10;
 static const unsigned kMainHeaderSize = 512;
 static const unsigned kHfsHeaderSize = kHeaderPadSize + kMainHeaderSize;
 
+static const unsigned k_Signature_LE16_HFS_BD = 'B' + ((unsigned)'D' << 8);
+static const unsigned k_Signature_LE16_HPLUS  = 'H' + ((unsigned)'+' << 8);
+static const UInt32   k_Signature_LE32_HFSP_VER4 = 'H' + ((UInt32)'+' << 8) + ((UInt32)4 << 24);
+static const UInt32   k_Signature_LE32_HFSX_VER5 = 'H' + ((UInt32)'X' << 8) + ((UInt32)5 << 24);
+
 API_FUNC_static_IsArc IsArc_HFS(const Byte *p, size_t size)
 {
   if (size < kHfsHeaderSize)
     return k_IsArc_Res_NEED_MORE;
   p += kHeaderPadSize;
-  if (p[0] == 'B' && p[1] == 'D')
-  {
-    if (p[0x7C] != 'H' || p[0x7C + 1] != '+')
-      return k_IsArc_Res_NO;
-  }
-  else
-  {
-    if (p[0] != 'H' || (p[1] != '+' && p[1] != 'X'))
-      return k_IsArc_Res_NO;
-    UInt32 version = Get16(p + 2);
-    if (version < 4 || version > 5)
-      return k_IsArc_Res_NO;
-  }
+  const UInt32 sig = GetUi32(p);
+  if (sig != k_Signature_LE32_HFSP_VER4)
+  if (sig != k_Signature_LE32_HFSX_VER5)
+  if ((UInt16)sig != k_Signature_LE16_HFS_BD
+      || GetUi16(p + 0x7c) != k_Signature_LE16_HPLUS)
+    return k_IsArc_Res_NO;
   return k_IsArc_Res_YES;
 }
 }
@@ -1357,30 +1355,42 @@ API_FUNC_static_IsArc IsArc_HFS(const Byte *p, size_t size)
 HRESULT CDatabase::Open2(IInStream *inStream, IArchiveOpenCallback *progress)
 {
   Clear();
-  Byte buf[kHfsHeaderSize];
-  RINOK(ReadStream_FALSE(inStream, buf, kHfsHeaderSize))
-  {
-    for (unsigned i = 0; i < kHeaderPadSize; i++)
-      if (buf[i] != 0)
-        return S_FALSE;
-  }
-  const Byte *p = buf + kHeaderPadSize;
+  UInt32 buf32[kHfsHeaderSize / 4];
+  RINOK(ReadStream_FALSE(inStream, buf32, kHfsHeaderSize))
+  const Byte *p = (const Byte *)buf32 + kHeaderPadSize;
   CVolHeader &h = Header;
 
-  h.Header[0] = p[0];
-  h.Header[1] = p[1];
-
-  if (p[0] == 'B' && p[1] == 'D')
+  if (GetUi16a(p) == k_Signature_LE16_HFS_BD)
   {
     /*
     It's header for old HFS format.
     We don't support old HFS format, but we support
-    special HFS volume that contains embedded HFS+ volume
+    special HFS volume that contains embedded HFS+ volume.
+    HFS MDB : Master directory block
+    HFS VIB : Volume information block
+    some old images contain boot data with "LK" signature at start of buf32.
     */
-
-    if (p[0x7C] != 'H' || p[0x7C + 1] != '+')
+#if 1
+    // here we check first bytes of archive,
+    // because start data can contain signature of some another
+    // archive type that could have priority over HFS.
+    const void *buf_ptr = (const void *)buf32;
+    const unsigned sig = GetUi16a(buf_ptr);
+    if (sig != 'L' + ((unsigned)'K' << 8))
+    {
+      // some old HFS (non HFS+) files have no "LK" signature,
+      // but have non-zero data after 2 first bytes in start 1 KiB.
+      if (sig != 0)
+        return S_FALSE;
+/*
+      for (unsigned i = 0; i < kHeaderPadSize / 4; i++)
+        if (buf32[i] != 0)
+          return S_FALSE;
+*/
+    }
+#endif
+    if (GetUi16a(p + 0x7c) != k_Signature_LE16_HPLUS) // signature of embedded HFS+ volume
       return S_FALSE;
-
     /*
     h.CTime = Get32(p + 0x2);
     h.MTime = Get32(p + 0x6);
@@ -1399,80 +1409,104 @@ HRESULT CDatabase::Open2(IInStream *inStream, IArchiveOpenCallback *progress)
     h.NumFreeBlocks = Get16(p + 0x22);
     */
     
-    UInt32 blockSize = Get32(p + 0x14);
-    
-    {
-      unsigned i;
-      for (i = 9; ((UInt32)1 << i) != blockSize; i++)
-        if (i == 31)
-          return S_FALSE;
-      h.BlockSizeLog = i;
-    }
-    
-    h.NumBlocks = Get16(p + 0x12);
+    // v24.09: blockSize in old HFS image can be non-power of 2.
+    const UInt32 blockSize = Get32a(p + 0x14); // drAlBlkSiz
+    if (blockSize == 0 || (blockSize & 0x1ff))
+      return S_FALSE;
+    const unsigned numBlocks = Get16a(p + 0x12); // drNmAlBlks
+    // UInt16 drFreeBks = Get16a(p + 0x22); // number of unused allocation blocks
     /*
-    we suppose that it has the follwing layout
+    we suppose that it has the following layout:
     {
-      start block with header
-      [h.NumBlocks]
-      end block with header
+      start data with header
+      blocks[h.NumBlocks]
+      end data with header (probably size_of_footer <= blockSize).
     }
     */
-    PhySize2 = ((UInt64)h.NumBlocks + 2) << h.BlockSizeLog;
-
-    UInt32 startBlock = Get16(p + 0x7C + 2);
-    UInt32 blockCount = Get16(p + 0x7C + 4);
-    SpecOffset = (UInt64)(1 + startBlock) << h.BlockSizeLog;
-    UInt64 phy = SpecOffset + ((UInt64)blockCount << h.BlockSizeLog);
+    // PhySize2 = ((UInt64)numBlocks + 2) * blockSize;
+    const unsigned sector_of_FirstBlock = Get16a(p + 0x1c); // drAlBlSt : first allocation block in volume
+    const UInt32 startBlock = Get16a(p + 0x7c + 2);
+    const UInt32 blockCount = Get16a(p + 0x7c + 4);
+    SpecOffset = (UInt32)sector_of_FirstBlock << 9; // it's 32-bit here
+    PhySize2 = SpecOffset + (UInt64)numBlocks * blockSize;
+    SpecOffset += (UInt64)startBlock * blockSize;
+    // before v24.09: // SpecOffset = (UInt64)(1 + startBlock) * blockSize;
+    const UInt64 phy = SpecOffset + (UInt64)blockCount * blockSize;
     if (PhySize2 < phy)
-      PhySize2 = phy;
+        PhySize2 = phy;
+    UInt32 tail = 1 << 10; // at least 1 KiB tail (for footer MDB) is expected.
+    if (tail < blockSize)
+        tail = blockSize;
+    RINOK(InStream_GetSize_SeekToEnd(inStream, ArcFileSize))
+    if (ArcFileSize > PhySize2 &&
+        ArcFileSize - PhySize2 <= tail)
+    {
+      // data after blocks[h.NumBlocks] must contain another copy of MDB.
+      // In example where blockSize is not power of 2, we have
+      //   (ArcFileSize - PhySize2) < blockSize.
+      // We suppose that data after blocks[h.NumBlocks] is part of HFS archive.
+      // Maybe we should scan for footer MDB data (in last 1 KiB)?
+      PhySize2 = ArcFileSize;
+    }
     RINOK(InStream_SeekSet(inStream, SpecOffset))
-    RINOK(ReadStream_FALSE(inStream, buf, kHfsHeaderSize))
+    RINOK(ReadStream_FALSE(inStream, buf32, kHfsHeaderSize))
   }
 
-  if (p[0] != 'H' || (p[1] != '+' && p[1] != 'X'))
-    return S_FALSE;
-  h.Version = Get16(p + 2);
-  if (h.Version < 4 || h.Version > 5)
-    return S_FALSE;
-
-  // h.Attr = Get32(p + 4);
-  // h.LastMountedVersion = Get32(p + 8);
-  // h.JournalInfoBlock = Get32(p + 0xC);
-
-  h.CTime = Get32(p + 0x10);
-  h.MTime = Get32(p + 0x14);
-  // h.BackupTime = Get32(p + 0x18);
-  // h.CheckedTime = Get32(p + 0x1C);
-
-  h.NumFiles = Get32(p + 0x20);
-  h.NumFolders = Get32(p + 0x24);
-  
-  if (h.NumFolders > ((UInt32)1 << 29) ||
-      h.NumFiles > ((UInt32)1 << 30))
-    return S_FALSE;
-
-  RINOK(InStream_GetSize_SeekToEnd(inStream, ArcFileSize))
-
-  if (progress)
+  // HFS+ / HFSX volume header (starting from offset==1024):
   {
-    const UInt64 numFiles = (UInt64)h.NumFiles + h.NumFolders + 1;
-    RINOK(progress->SetTotal(&numFiles, NULL))
+    // v24.09: we use strict condition test for pair signature(Version):
+    // H+(4), HX(5):
+    const UInt32 sig = GetUi32a(p);
+    // h.Version = Get16(p + 2);
+    h.Is_Hsfx_ver5 = false;
+    if (sig != k_Signature_LE32_HFSP_VER4)
+    {
+      if (sig != k_Signature_LE32_HFSX_VER5)
+        return S_FALSE;
+      h.Is_Hsfx_ver5 = true;
+    }
   }
-
-  UInt32 blockSize = Get32(p + 0x28);
-
   {
+    const UInt32 blockSize = Get32a(p + 0x28);
     unsigned i;
     for (i = 9; ((UInt32)1 << i) != blockSize; i++)
       if (i == 31)
         return S_FALSE;
     h.BlockSizeLog = i;
   }
+#if 1
+  // HFS Plus DOCs: The first 1024 bytes are reserved for use as boot blocks
+  // v24.09: we don't check starting 1 KiB before old (HFS MDB) block ("BD" signture) .
+  //     but we still check starting 1 KiB before HFS+ / HFSX volume header.
+  // are there HFS+ / HFSX images with non-zero data in this reserved area?
+  {
+    for (unsigned i = 0; i < kHeaderPadSize / 4; i++)
+      if (buf32[i] != 0)
+        return S_FALSE;
+  }
+#endif
+  // h.Attr = Get32a(p + 4);
+  // h.LastMountedVersion = Get32a(p + 8);
+  // h.JournalInfoBlock = Get32a(p + 0xC);
+  h.CTime = Get32a(p + 0x10);
+  h.MTime = Get32a(p + 0x14);
+  // h.BackupTime = Get32a(p + 0x18);
+  // h.CheckedTime = Get32a(p + 0x1C);
+  h.NumFiles = Get32a(p + 0x20);
+  h.NumFolders = Get32a(p + 0x24);
+  if (h.NumFolders > ((UInt32)1 << 29) ||
+      h.NumFiles > ((UInt32)1 << 30))
+    return S_FALSE;
 
-  h.NumBlocks = Get32(p + 0x2C);
-  h.NumFreeBlocks = Get32(p + 0x30);
+  RINOK(InStream_GetSize_SeekToEnd(inStream, ArcFileSize))
+  if (progress)
+  {
+    const UInt64 numFiles = (UInt64)h.NumFiles + h.NumFolders + 1;
+    RINOK(progress->SetTotal(&numFiles, NULL))
+  }
 
+  h.NumBlocks = Get32a(p + 0x2C);
+  h.NumFreeBlocks = Get32a(p + 0x30);
   /*
   h.NextCalatlogNodeID = Get32(p + 0x40);
   h.WriteCount = Get32(p + 0x44);
@@ -1495,7 +1529,7 @@ HRESULT CDatabase::Open2(IInStream *inStream, IArchiveOpenCallback *progress)
     HeadersError = true;
   else
   {
-    HRESULT res = LoadExtentFile(extentsFork, inStream, overflowExtents);
+    const HRESULT res = LoadExtentFile(extentsFork, inStream, overflowExtents);
     if (res == S_FALSE)
       HeadersError = true;
     else if (res != S_OK)
@@ -1515,7 +1549,7 @@ HRESULT CDatabase::Open2(IInStream *inStream, IArchiveOpenCallback *progress)
   
   RINOK(LoadCatalog(catalogFork, overflowExtents, inStream, progress))
 
-  PhySize = Header.GetPhySize();
+  // PhySize = Header.GetPhySize();
   return S_OK;
 }
 
@@ -1591,7 +1625,7 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
     case kpidCharacts: MethodsMaskToProp(MethodsMask, prop); break;
     case kpidPhySize:
     {
-      UInt64 v = SpecOffset + PhySize;
+      UInt64 v = SpecOffset + Header.GetPhySize(); // PhySize;
       if (v < PhySize2)
         v = PhySize2;
       prop = v;
@@ -2529,7 +2563,7 @@ HRESULT CHandler::GetForkStream(const CFork &fork, ISequentialInStream **stream)
         return S_FALSE;
     }
     CSeekExtent se;
-    se.Phy = (UInt64)e.Pos << Header.BlockSizeLog;
+    se.Phy = SpecOffset + ((UInt64)e.Pos << Header.BlockSizeLog);
     se.Virt = virt;
     virt += cur;
     rem -= cur;
@@ -2540,7 +2574,7 @@ HRESULT CHandler::GetForkStream(const CFork &fork, ISequentialInStream **stream)
     return S_FALSE;
   
   CSeekExtent se;
-  se.Phy = 0;
+  se.Phy = 0; // = SpecOffset ?
   se.Virt = virt;
   extentStream->Extents.Add(se);
   extentStream->Stream = _stream;
diff --git a/CPP/7zip/Archive/LpHandler.cpp b/CPP/7zip/Archive/LpHandler.cpp
index c1a76b4..926b654 100644
--- a/CPP/7zip/Archive/LpHandler.cpp
+++ b/CPP/7zip/Archive/LpHandler.cpp
@@ -460,9 +460,11 @@ struct LpMetadataHeader
 
 static bool CheckSha256(const Byte *data, size_t size, const Byte *checksum)
 {
+  MY_ALIGN (16)
   CSha256 sha;
   Sha256_Init(&sha);
   Sha256_Update(&sha, data, size);
+  MY_ALIGN (16)
   Byte calced[32];
   Sha256_Final(&sha, calced);
   return memcmp(checksum, calced, 32) == 0;
@@ -470,6 +472,7 @@ static bool CheckSha256(const Byte *data, size_t size, const Byte *checksum)
 
 static bool CheckSha256_csOffset(Byte *data, size_t size, unsigned hashOffset)
 {
+  MY_ALIGN (4)
   Byte checksum[32];
   Byte *shaData = &data[hashOffset];
   memcpy(checksum, shaData, 32);
@@ -528,6 +531,7 @@ HRESULT CHandler::Open2(IInStream *stream)
 {
   RINOK(InStream_SeekSet(stream, LP_PARTITION_RESERVED_BYTES))
   {
+    MY_ALIGN (4)
     Byte buf[k_Geometry_Size];
     RINOK(ReadStream_FALSE(stream, buf, k_Geometry_Size))
     if (memcmp(buf, k_Signature, k_SignatureSize) != 0)
diff --git a/CPP/7zip/Archive/Nsis/NsisIn.cpp b/CPP/7zip/Archive/Nsis/NsisIn.cpp
index c9e2c01..194e5bf 100644
--- a/CPP/7zip/Archive/Nsis/NsisIn.cpp
+++ b/CPP/7zip/Archive/Nsis/NsisIn.cpp
@@ -4005,7 +4005,7 @@ HRESULT CInArchive::ReadEntries(const CBlockHeader &bh)
         AddParam_Var(params[0]);
         AString temp;
         ReadString2(temp, params[1]);
-        if (temp != "$TEMP")
+        if (!temp.IsEqualTo("$TEMP"))
           SpaceQuStr(temp);
         break;
       }
@@ -4410,7 +4410,7 @@ HRESULT CInArchive::ReadEntries(const CBlockHeader &bh)
         }
         else
         {
-          if (func == "DllUnregisterServer")
+          if (func.IsEqualTo("DllUnregisterServer"))
           {
             s += "UnRegDLL";
             printFunc = false;
@@ -4418,7 +4418,7 @@ HRESULT CInArchive::ReadEntries(const CBlockHeader &bh)
           else
           {
             s += "RegDLL";
-            if (func == "DllRegisterServer")
+            if (func.IsEqualTo("DllRegisterServer"))
               printFunc = false;
           }
           AddParam(params[0]);
@@ -4886,7 +4886,7 @@ HRESULT CInArchive::ReadEntries(const CBlockHeader &bh)
             AddParam_Var(params[1]);
             AddParam(params[2]);
             AddParam(params[4]);
-            // if (params[2] == "0") AddCommentAndString("GetWinVer");
+            // if (params[2].IsEqualTo("0")) AddCommentAndString("GetWinVer");
           }
           else
             s += "GetOsInfo";
diff --git a/CPP/7zip/Archive/NtfsHandler.cpp b/CPP/7zip/Archive/NtfsHandler.cpp
index d55521d..05c177f 100644
--- a/CPP/7zip/Archive/NtfsHandler.cpp
+++ b/CPP/7zip/Archive/NtfsHandler.cpp
@@ -1907,7 +1907,7 @@ HRESULT CDatabase::Open()
   for (i = 0; i < SecurityAttrs.Size(); i++)
   {
     const CAttr &attr = SecurityAttrs[i];
-    if (attr.Name == L"$SII")
+    if (attr.Name.IsEqualTo("$SII"))
     {
       if (attr.Type == ATTR_TYPE_INDEX_ROOT)
       {
diff --git a/CPP/7zip/Archive/PeHandler.cpp b/CPP/7zip/Archive/PeHandler.cpp
index 8a0ff05..79f89ef 100644
--- a/CPP/7zip/Archive/PeHandler.cpp
+++ b/CPP/7zip/Archive/PeHandler.cpp
@@ -2638,7 +2638,7 @@ HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *callback)
   {
     const CSection &sect = _sections[i];
     if (IsOpt())
-    if (_parseResources && sect.Name == ".rsrc")
+    if (_parseResources && sect.Name.IsEqualTo(".rsrc"))
     {
       // 20.01: we try to parse only first copy of .rsrc section.
       _parseResources = false;
@@ -2727,7 +2727,7 @@ HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *callback)
   for (i = 0; i < _mixItems.Size(); i++)
   {
     const CMixItem &mixItem = _mixItems[i];
-    if (mixItem.StringIndex < 0 && mixItem.ResourceIndex < 0 && _sections[mixItem.SectionIndex].Name == "_winzip_")
+    if (mixItem.StringIndex < 0 && mixItem.ResourceIndex < 0 && _sections[mixItem.SectionIndex].Name.IsEqualTo("_winzip_"))
     {
       _mainSubfile = (Int32)(int)i;
       break;
diff --git a/CPP/7zip/Archive/Rar/Rar5Handler.cpp b/CPP/7zip/Archive/Rar/Rar5Handler.cpp
index 34615c2..a639d8b 100644
--- a/CPP/7zip/Archive/Rar/Rar5Handler.cpp
+++ b/CPP/7zip/Archive/Rar/Rar5Handler.cpp
@@ -393,6 +393,7 @@ void CItem::Link_to_Prop(unsigned linkType, NWindows::NCOM::CPropVariant &prop)
   if (!FindExtra_Link(link))
     return;
 
+  bool isWindows = (HostOS == kHost_Windows);
   if (link.Type != linkType)
   {
     if (linkType != NLinkType::kUnixSymLink)
@@ -400,8 +401,11 @@ void CItem::Link_to_Prop(unsigned linkType, NWindows::NCOM::CPropVariant &prop)
     switch ((unsigned)link.Type)
     {
       case NLinkType::kUnixSymLink:
+        isWindows = false;
+        break;
       case NLinkType::kWinSymLink:
       case NLinkType::kWinJunction:
+        isWindows = true;
         break;
       default: return;
     }
@@ -409,10 +413,15 @@ void CItem::Link_to_Prop(unsigned linkType, NWindows::NCOM::CPropVariant &prop)
 
   AString s;
   s.SetFrom_CalcLen((const char *)(Extra + link.NameOffset), link.NameLen);
-
   UString unicode;
   ConvertUTF8ToUnicode(s, unicode);
-  prop = NItemName::GetOsPath(unicode);
+  // rar5.0  used '\\' separator for windows symlinks and \??\ prefix for abs paths.
+  // rar5.1+ uses '/'  separator for windows symlinks and /??/ prefix for abs paths.
+  // v25.00: we convert Windows slashes to Linux slashes:
+  if (isWindows)
+    unicode.Replace(L'\\', L'/');
+  prop = unicode;
+  // prop = NItemName::GetOsPath(unicode);
 }
 
 bool CItem::GetAltStreamName(AString &name) const
@@ -658,6 +667,9 @@ HRESULT CInArchive::ReadBlockHeader(CHeader &h)
     RINOK(ReadStream_Check(_buf, AES_BLOCK_SIZE * 2))
     memcpy(m_CryptoDecoder->_iv, _buf, AES_BLOCK_SIZE);
     RINOK(m_CryptoDecoder->Init())
+    // we call RAR5_AES_Filter with:
+    //   data_ptr  == aligned_ptr + 16
+    //   data_size == 16
     if (m_CryptoDecoder->Filter(_buf + AES_BLOCK_SIZE, AES_BLOCK_SIZE) != AES_BLOCK_SIZE)
       return E_FAIL;
     memcpy(buf, _buf + AES_BLOCK_SIZE, AES_BLOCK_SIZE);
@@ -689,10 +701,14 @@ HRESULT CInArchive::ReadBlockHeader(CHeader &h)
       return E_OUTOFMEMORY;
     memcpy(_buf, buf, filled);
     const size_t rem = size - filled;
+    // if (m_CryptoMode), we add AES_BLOCK_SIZE here, because _iv is not included to size.
     AddToSeekValue(size + (m_CryptoMode ? AES_BLOCK_SIZE : 0));
     RINOK(ReadStream_Check(_buf + filled, rem))
     if (m_CryptoMode)
     {
+      // we call RAR5_AES_Filter with:
+      //   data_ptr  == aligned_ptr + 16
+      //   (rem) can be big
       if (m_CryptoDecoder->Filter(_buf + filled, (UInt32)rem) != rem)
         return E_FAIL;
 #if 1
@@ -1065,7 +1081,8 @@ HRESULT CUnpacker::Create(DECL_EXTERNAL_CODECS_LOC_VARS
 
     CMyComPtr<ICompressSetDecoderProperties2> csdp;
     RINOK(lzCoder.QueryInterface(IID_ICompressSetDecoderProperties2, &csdp))
-
+    if (!csdp)
+      return E_NOTIMPL;
     const unsigned ver = item.Get_AlgoVersion_HuffRev();
     if (ver > 1)
       return E_NOTIMPL;
@@ -3343,9 +3360,9 @@ Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVAR
     }
     else if (name.IsPrefixedBy_Ascii_NoCase("memx"))
     {
-      UInt64 memAvail;
+      size_t memAvail;
       if (!NWindows::NSystem::GetRamSize(memAvail))
-        memAvail = (UInt64)(sizeof(size_t)) << 28;
+        memAvail = (size_t)sizeof(size_t) << 28;
       UInt64 v;
       if (!ParseSizeString(name.Ptr(4), prop, memAvail, v))
         return E_INVALIDARG;
diff --git a/CPP/7zip/Archive/Rar/Rar5Handler.h b/CPP/7zip/Archive/Rar/Rar5Handler.h
index 8f6581a..913ba85 100644
--- a/CPP/7zip/Archive/Rar/Rar5Handler.h
+++ b/CPP/7zip/Archive/Rar/Rar5Handler.h
@@ -286,10 +286,10 @@ struct CItem
 
   bool IsService() const { return RecordType == NHeaderType::kService; }
   
-  bool Is_STM() const { return IsService() && Name == "STM"; }
-  bool Is_CMT() const { return IsService() && Name == "CMT"; }
-  bool Is_ACL() const { return IsService() && Name == "ACL"; }
-  // bool Is_QO()  const { return IsService() && Name == "QO"; }
+  bool Is_STM() const { return IsService() && Name.IsEqualTo("STM"); }
+  bool Is_CMT() const { return IsService() && Name.IsEqualTo("CMT"); }
+  bool Is_ACL() const { return IsService() && Name.IsEqualTo("ACL"); }
+  // bool Is_QO()  const { return IsService() && Name.IsEqualTo("QO"); }
 
   int FindExtra(unsigned extraID, unsigned &recordDataSize) const;
   void PrintInfo(AString &s) const;
diff --git a/CPP/7zip/Archive/Rar/RarHandler.cpp b/CPP/7zip/Archive/Rar/RarHandler.cpp
index 9157acc..dfbad33 100644
--- a/CPP/7zip/Archive/Rar/RarHandler.cpp
+++ b/CPP/7zip/Archive/Rar/RarHandler.cpp
@@ -435,13 +435,13 @@ bool CInArchive::ReadHeaderReal(const Byte *p, unsigned size, CItem &item)
       size -= sizeof(item.Salt);
       p += sizeof(item.Salt);
     }
-    if (item.Name == "ACL" && size == 0)
+    if (item.Name.IsEqualTo("ACL") && size == 0)
     {
       item.IsAltStream = true;
       item.Name.Empty();
       item.UnicodeName.SetFromAscii(".ACL");
     }
-    else if (item.Name == "STM" && size != 0 && (size & 1) == 0)
+    else if (item.Name.IsEqualTo("STM") && size != 0 && (size & 1) == 0)
     {
       item.IsAltStream = true;
       item.Name.Empty();
diff --git a/CPP/7zip/Archive/RpmHandler.cpp b/CPP/7zip/Archive/RpmHandler.cpp
index da2b6ee..4f8aaaa 100644
--- a/CPP/7zip/Archive/RpmHandler.cpp
+++ b/CPP/7zip/Archive/RpmHandler.cpp
@@ -330,11 +330,11 @@ void CHandler::AddSubFileExtension(AString &res) const
   if (!_compressor.IsEmpty())
   {
     s = _compressor;
-    if (_compressor == "bzip2")
+    if (_compressor.IsEqualTo("bzip2"))
       s = "bz2";
-    else if (_compressor == "gzip")
+    else if (_compressor.IsEqualTo("gzip"))
       s = "gz";
-    else if (_compressor == "zstd")
+    else if (_compressor.IsEqualTo("zstd"))
       s = "zst";
   }
   else
diff --git a/CPP/7zip/Archive/VmdkHandler.cpp b/CPP/7zip/Archive/VmdkHandler.cpp
index 9c293a3..221af21 100644
--- a/CPP/7zip/Archive/VmdkHandler.cpp
+++ b/CPP/7zip/Archive/VmdkHandler.cpp
@@ -202,9 +202,12 @@ struct CExtentInfo
   // PartitionUUID
   // DeviceIdentifier
 
-  bool IsType_ZERO() const { return Type == "ZERO"; }
-  // bool IsType_FLAT() const { return Type == "FLAT"; }
-  bool IsType_Flat() const { return Type == "FLAT" || Type == "VMFS" || Type == "VMFSRAW"; }
+  bool IsType_ZERO() const { return Type.IsEqualTo("ZERO"); }
+  // bool IsType_FLAT() const { return Type.IsEqualTo("FLAT"); }
+  bool IsType_Flat() const
+    { return Type.IsEqualTo("FLAT")
+          || Type.IsEqualTo("VMFS")
+          || Type.IsEqualTo("VMFSRAW"); }
   
   bool Parse(const char *s);
 };
diff --git a/CPP/7zip/Archive/Wim/WimIn.cpp b/CPP/7zip/Archive/Wim/WimIn.cpp
index 614755a..a748e99 100644
--- a/CPP/7zip/Archive/Wim/WimIn.cpp
+++ b/CPP/7zip/Archive/Wim/WimIn.cpp
@@ -1814,7 +1814,7 @@ bool CWimXml::Parse()
 
   if (!Xml.Parse(utf))
     return false;
-  if (Xml.Root.Name != "WIM")
+  if (!Xml.Root.Name.IsEqualTo("WIM"))
     return false;
 
   FOR_VECTOR (i, Xml.Root.SubItems)
diff --git a/CPP/7zip/Archive/XarHandler.cpp b/CPP/7zip/Archive/XarHandler.cpp
index 5112a16..cba546e 100644
--- a/CPP/7zip/Archive/XarHandler.cpp
+++ b/CPP/7zip/Archive/XarHandler.cpp
@@ -3,6 +3,7 @@
 #include "StdAfx.h"
 
 #include "../../../C/Sha256.h"
+#include "../../../C/Sha512.h"
 #include "../../../C/CpuArch.h"
 
 #include "../../Common/ComTry.h"
@@ -41,22 +42,33 @@ Z7_CLASS_IMP_NOQIB_1(
   CInStreamWithSha256
   , ISequentialInStream
 )
+  bool _sha512Mode;
   CMyComPtr<ISequentialInStream> _stream;
-  CAlignedBuffer1 _sha;
+  CAlignedBuffer1 _sha256;
+  CAlignedBuffer1 _sha512;
   UInt64 _size;
 
-  CSha256 *Sha() { return (CSha256 *)(void *)(Byte *)_sha; }
+  CSha256 *Sha256() { return (CSha256 *)(void *)(Byte *)_sha256; }
+  CSha512 *Sha512() { return (CSha512 *)(void *)(Byte *)_sha512; }
 public:
-  CInStreamWithSha256(): _sha(sizeof(CSha256)) {}
+  CInStreamWithSha256():
+      _sha256(sizeof(CSha256)),
+      _sha512(sizeof(CSha512))
+      {}
   void SetStream(ISequentialInStream *stream) { _stream = stream;  }
-  void Init()
+  void Init(bool sha512Mode)
   {
+    _sha512Mode = sha512Mode;
     _size = 0;
-    Sha256_Init(Sha());
+    if (sha512Mode)
+      Sha512_Init(Sha512(), SHA512_DIGEST_SIZE);
+    else
+      Sha256_Init(Sha256());
   }
   void ReleaseStream() { _stream.Release(); }
   UInt64 GetSize() const { return _size; }
-  void Final(Byte *digest) { Sha256_Final(Sha(), digest); }
+  void Final256(Byte *digest) { Sha256_Final(Sha256(), digest); }
+  void Final512(Byte *digest) { Sha512_Final(Sha512(), digest, SHA512_DIGEST_SIZE); }
 };
 
 Z7_COM7F_IMF(CInStreamWithSha256::Read(void *data, UInt32 size, UInt32 *processedSize))
@@ -64,7 +76,10 @@ Z7_COM7F_IMF(CInStreamWithSha256::Read(void *data, UInt32 size, UInt32 *processe
   UInt32 realProcessedSize;
   const HRESULT result = _stream->Read(data, size, &realProcessedSize);
   _size += realProcessedSize;
-  Sha256_Update(Sha(), (const Byte *)data, realProcessedSize);
+  if (_sha512Mode)
+    Sha512_Update(Sha512(), (const Byte *)data, realProcessedSize);
+  else
+    Sha256_Update(Sha256(), (const Byte *)data, realProcessedSize);
   if (processedSize)
     *processedSize = realProcessedSize;
   return result;
@@ -75,25 +90,33 @@ Z7_CLASS_IMP_NOQIB_1(
   COutStreamWithSha256
   , ISequentialOutStream
 )
-  // bool _calculate;
+  bool _sha512Mode;
   CMyComPtr<ISequentialOutStream> _stream;
-  CAlignedBuffer1 _sha;
+  CAlignedBuffer1 _sha256;
+  CAlignedBuffer1 _sha512;
   UInt64 _size;
 
-  CSha256 *Sha() { return (CSha256 *)(void *)(Byte *)_sha; }
+  CSha256 *Sha256() { return (CSha256 *)(void *)(Byte *)_sha256; }
+  CSha512 *Sha512() { return (CSha512 *)(void *)(Byte *)_sha512; }
 public:
-  COutStreamWithSha256(): _sha(sizeof(CSha256)) {}
+  COutStreamWithSha256():
+      _sha256(sizeof(CSha256)),
+      _sha512(sizeof(CSha512))
+      {}
   void SetStream(ISequentialOutStream *stream) { _stream = stream; }
   void ReleaseStream() { _stream.Release(); }
-  void Init(/* bool calculate = true */ )
+  void Init(bool sha512Mode)
   {
-    // _calculate = calculate;
+    _sha512Mode = sha512Mode;
     _size = 0;
-    Sha256_Init(Sha());
+    if (sha512Mode)
+      Sha512_Init(Sha512(), SHA512_DIGEST_SIZE);
+    else
+      Sha256_Init(Sha256());
   }
-  void InitSha256() { Sha256_Init(Sha()); }
   UInt64 GetSize() const { return _size; }
-  void Final(Byte *digest) { Sha256_Final(Sha(), digest); }
+  void Final256(Byte *digest) { Sha256_Final(Sha256(), digest); }
+  void Final512(Byte *digest) { Sha512_Final(Sha512(), digest, SHA512_DIGEST_SIZE); }
 };
 
 Z7_COM7F_IMF(COutStreamWithSha256::Write(const void *data, UInt32 size, UInt32 *processedSize))
@@ -102,7 +125,10 @@ Z7_COM7F_IMF(COutStreamWithSha256::Write(const void *data, UInt32 size, UInt32 *
   if (_stream)
     result = _stream->Write(data, size, &size);
   // if (_calculate)
-  Sha256_Update(Sha(), (const Byte *)data, size);
+  if (_sha512Mode)
+    Sha512_Update(Sha512(), (const Byte *)data, size);
+  else
+    Sha256_Update(Sha256(), (const Byte *)data, size);
   _size += size;
   if (processedSize)
     *processedSize = size;
@@ -240,7 +266,7 @@ struct CFile
 
   bool IsCopyMethod() const
   {
-    return Method.IsEmpty() || Method == "octet-stream";
+    return Method.IsEmpty() || Method.IsEqualTo("octet-stream");
   }
 
   void UpdateTotalPackSize(UInt64 &totalSize) const
@@ -390,7 +416,7 @@ static bool AddItem(const CXmlItem &item, CObjectVector<CFile> &files, int paren
     return true;
   if (level >= 1024)
     return false;
-  if (item.Name == "file")
+  if (item.Name.IsEqualTo("file"))
   {
     CFile file(parent);
     parent = (int)files.Size();
@@ -409,19 +435,19 @@ static bool AddItem(const CXmlItem &item, CObjectVector<CFile> &files, int paren
       {
         file.Type = typeItem->GetSubString();
         // file.LinkFrom = typeItem->GetPropVal("link");
-        if (file.Type == "directory")
+        if (file.Type.IsEqualTo("directory"))
           file.IsDir = true;
         else
         {
           // file.IsDir = false;
           /*
-          else if (file.Type == "file")
+          else if (file.Type.IsEqualTo("file"))
           {}
-          else if (file.Type == "hardlink")
+          else if (file.Type.IsEqualTo("hardlink"))
           {}
           else
           */
-          if (file.Type == "symlink")
+          if (file.Type.IsEqualTo("symlink"))
             file.Is_SymLink = true;
           // file.IsDir = false;
         }
@@ -463,7 +489,7 @@ static bool AddItem(const CXmlItem &item, CObjectVector<CFile> &files, int paren
             if (s.IsPrefixedBy(xx))
             {
               s.DeleteFrontal(xx.Len());
-              if (s == "gzip")
+              if (s.IsEqualTo("gzip"))
                 s = METHOD_NAME_ZLIB;
             }
           }
@@ -521,10 +547,11 @@ void CInStreamWithHash::SetStreamAndInit(ISequentialInStream *stream, int algo)
     inStreamSha1->Init();
     stream = inStreamSha1;
   }
-  else if (algo == XAR_CKSUM_SHA256)
+  else if (algo == XAR_CKSUM_SHA256
+        || algo == XAR_CKSUM_SHA512)
   {
     inStreamSha256->SetStream(stream);
-    inStreamSha256->Init();
+    inStreamSha256->Init(algo == XAR_CKSUM_SHA512);
     stream = inStreamSha256;
   }
   inStreamLim->SetStream(stream);
@@ -542,7 +569,14 @@ bool CInStreamWithHash::CheckHash(int algo, const Byte *digest_from_arc) const
   else if (algo == XAR_CKSUM_SHA256)
   {
     Byte digest[SHA256_DIGEST_SIZE];
-    inStreamSha256->Final(digest);
+    inStreamSha256->Final256(digest);
+    if (memcmp(digest, digest_from_arc, sizeof(digest)) != 0)
+      return false;
+  }
+  else if (algo == XAR_CKSUM_SHA512)
+  {
+    Byte digest[SHA512_DIGEST_SIZE];
+    inStreamSha256->Final512(digest);
     if (memcmp(digest, digest_from_arc, sizeof(digest)) != 0)
       return false;
   }
@@ -658,12 +692,13 @@ HRESULT CHandler::Open2(IInStream *stream)
     file.UpdateTotalPackSize(totalPackSize);
     if (file.Parent == -1)
     {
-      if (file.Name == "Payload" || file.Name == "Content")
+      if (file.Name.IsEqualTo("Payload") ||
+          file.Name.IsEqualTo("Content"))
       {
         _mainSubfile = (Int32)(int)i;
         numMainFiles++;
       }
-      else if (file.Name == "PackageInfo")
+      else if (file.Name.IsEqualTo("PackageInfo"))
         _is_pkg = true;
     }
   }
@@ -1151,11 +1186,12 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
           outStreamSha1->SetStream(realOutStream);
           outStreamSha1->Init();
         }
-        else if (checksum_method == XAR_CKSUM_SHA256)
+        else if (checksum_method == XAR_CKSUM_SHA256
+              || checksum_method == XAR_CKSUM_SHA512)
         {
           outStreamLim->SetStream(outStreamSha256);
           outStreamSha256->SetStream(realOutStream);
-          outStreamSha256->Init();
+          outStreamSha256->Init(checksum_method == XAR_CKSUM_SHA512);
         }
         else
           outStreamLim->SetStream(realOutStream);
@@ -1175,9 +1211,9 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
           else
             opRes = NExtract::NOperationResult::kUnsupportedMethod;
         }
-        else if (item.Method == METHOD_NAME_ZLIB)
+        else if (item.Method.IsEqualTo(METHOD_NAME_ZLIB))
           coder = zlibCoder;
-        else if (item.Method == "bzip2")
+        else if (item.Method.IsEqualTo("bzip2"))
           coder = bzip2Coder;
         else
           opRes = NExtract::NOperationResult::kUnsupportedMethod;
@@ -1209,8 +1245,15 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
             else if (checksum_method == XAR_CKSUM_SHA256)
             {
               Byte digest[SHA256_DIGEST_SIZE];
-              outStreamSha256->Final(digest);
-              if (memcmp(digest, item.extracted_checksum.Data, SHA256_DIGEST_SIZE) != 0)
+              outStreamSha256->Final256(digest);
+              if (memcmp(digest, item.extracted_checksum.Data, sizeof(digest)) != 0)
+                opRes = NExtract::NOperationResult::kCRCError;
+            }
+            else if (checksum_method == XAR_CKSUM_SHA512)
+            {
+              Byte digest[SHA512_DIGEST_SIZE];
+              outStreamSha256->Final512(digest);
+              if (memcmp(digest, item.extracted_checksum.Data, sizeof(digest)) != 0)
                 opRes = NExtract::NOperationResult::kCRCError;
             }
             if (opRes == NExtract::NOperationResult::kOK)
diff --git a/CPP/7zip/Archive/XzHandler.cpp b/CPP/7zip/Archive/XzHandler.cpp
index 7ced4e1..5aaa405 100644
--- a/CPP/7zip/Archive/XzHandler.cpp
+++ b/CPP/7zip/Archive/XzHandler.cpp
@@ -446,7 +446,7 @@ void COpenCallbackWrap::Init(IArchiveOpenCallback *callback)
 struct CXzsCPP
 {
   CXzs p;
-  CXzsCPP() { Xzs_Construct(&p); }
+  CXzsCPP() { Xzs_CONSTRUCT(&p) }
   ~CXzsCPP() { Xzs_Free(&p, &g_Alloc); }
 };
 
@@ -536,6 +536,9 @@ HRESULT CHandler::Open2(IInStream *inStream, /* UInt32 flags, */ IArchiveOpenCal
 
         if (res2 == SZ_ERROR_ARCHIVE)
           return S_FALSE;
+        // what codes are possible here ?
+        // ?? res2 == SZ_ERROR_MEM           : is possible here
+        // ?? res2 == SZ_ERROR_UNSUPPORTED   : is possible here
       }
       else if (!isIndex)
       {
@@ -967,9 +970,9 @@ Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
       || _maxBlocksSize != (size_t)_maxBlocksSize)
     return S_FALSE;
 
-  UInt64 memSize;
+  size_t memSize;
   if (!NSystem::GetRamSize(memSize))
-    memSize = (UInt64)(sizeof(size_t)) << 28;
+    memSize = (size_t)sizeof(size_t) << 28;
   {
     if (_maxBlocksSize > memSize / 4)
       return S_FALSE;
@@ -1159,6 +1162,13 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
     */
 
     #ifndef Z7_ST
+
+#ifdef _WIN32
+    // we don't use chunk multithreading inside lzma2 stream.
+    // so we don't set xzProps.lzma2Props.numThreadGroups.
+    if (_numThreadGroups > 1)
+      xzProps.numThreadGroups = _numThreadGroups;
+#endif
     
     UInt32 numThreads = _numThreads;
 
@@ -1183,6 +1193,8 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
         CMultiMethodProps::SetMethodThreadsTo_IfNotFinded(oneMethodInfo, numThreads);
       }
 
+      // printf("\n====== GetProcessGroupAffinity : \n");
+
       UInt64 cs = _numSolidBytes;
       if (cs != XZ_PROPS_BLOCK_SIZE_AUTO)
         oneMethodInfo.AddProp_BlockSize2(cs);
diff --git a/CPP/7zip/Archive/Zip/ZipUpdate.cpp b/CPP/7zip/Archive/Zip/ZipUpdate.cpp
index bc047b7..b2684dc 100644
--- a/CPP/7zip/Archive/Zip/ZipUpdate.cpp
+++ b/CPP/7zip/Archive/Zip/ZipUpdate.cpp
@@ -250,13 +250,26 @@ struct CThreadInfo
   
   HRESULT CreateEvents()
   {
-    WRes wres = CompressEvent.CreateIfNotCreated_Reset();
+    const WRes wres = CompressEvent.CreateIfNotCreated_Reset();
     return HRESULT_FROM_WIN32(wres);
   }
   
-  HRESULT CreateThread()
+  // (group < 0) means no_group.
+  HRESULT CreateThread_with_group(
+#ifdef _WIN32
+      int group
+#endif
+      )
   {
-    WRes wres = Thread.Create(CoderThread, this);
+    // tested in win10: If thread is created by another thread,
+    // child thread probably uses same group as parent thread.
+    // So we don't need to send (group) to encoder in created thread.
+    const WRes wres =
+#ifdef _WIN32
+      group >= 0 ?
+        Thread.Create_With_Group(CoderThread, this, (unsigned)group) :
+#endif
+        Thread.Create(CoderThread, this);
     return HRESULT_FROM_WIN32(wres);
   }
 
@@ -450,8 +463,12 @@ static HRESULT UpdateItemOldData(
   if (ui.NewProps)
   {
     if (item.HasDescriptor())
-      return E_NOTIMPL;
-    
+    {
+      // we know compressed / uncompressed sizes and crc.
+      // so we remove descriptor here
+      item.Flags = (UInt16)(item.Flags & ~NFileHeader::NFlags::kDescriptorUsedMask);
+      // return E_NOTIMPL;
+    }
     // we keep ExternalAttrib and some another properties from old archive
     // item.ExternalAttrib = ui.Attrib;
     // if we don't change Comment, we keep Comment from OldProperties
@@ -1000,6 +1017,9 @@ static HRESULT Update2(
   #ifndef Z7_ST
 
   UInt32 numThreads = options._numThreads;
+#ifdef _WIN32
+  const UInt32 numThreadGroups = options._numThreadGroups;
+#endif
 
   UInt32 numZipThreads_limit = numThreads;
   if (numZipThreads_limit > numFilesToCompress)
@@ -1014,12 +1034,10 @@ static HRESULT Update2(
   }
 
   {
+    // we reduce number of threads for 32-bit to reduce memory usege to 256 MB
     const UInt32 kNumMaxThreads =
-      #ifdef _WIN32
-        64; // _WIN32 supports only 64 threads in one group. So no need for more threads here
-      #else
-        128;
-      #endif
+        // _WIN32 (64-bit) supports only 64 threads in one group.
+        8 << (sizeof(size_t) / 2); // 32 threads for 32-bit : 128 threads for 64-bit
     if (numThreads > kNumMaxThreads)
       numThreads = kNumMaxThreads;
   }
@@ -1264,7 +1282,14 @@ static HRESULT Update2(
       threadInfo.Progress = threadInfo.ProgressSpec;
       threadInfo.ProgressSpec->Init(&mtCompressProgressMixer, i);
       threadInfo.MtSem = &mtSem;
-      RINOK(threadInfo.CreateThread())
+      const HRESULT hres =
+        threadInfo.CreateThread_with_group(
+#ifdef _WIN32
+          (numThreadGroups > 1 && numThreads > 1) ?
+            (int)(i % numThreadGroups) : -1
+#endif
+        );
+      RINOK(hres)
     }
   }
 
diff --git a/CPP/7zip/Bundles/Alone/Alone.dsp b/CPP/7zip/Bundles/Alone/Alone.dsp
index beed5a7..558c41e 100644
--- a/CPP/7zip/Bundles/Alone/Alone.dsp
+++ b/CPP/7zip/Bundles/Alone/Alone.dsp
@@ -1148,26 +1148,6 @@ SOURCE=..\..\Compress\PpmdZip.cpp
 SOURCE=..\..\Compress\PpmdZip.h
 # End Source File
 # End Group
-# Begin Group "RangeCoder"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Compress\RangeCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\RangeCoderBit.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\RangeCoderBitTree.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\RangeCoderOpt.h
-# End Source File
-# End Group
 # Begin Group "Shrink"
 
 # PROP Default_Filter ""
diff --git a/CPP/7zip/Bundles/Alone/makefile b/CPP/7zip/Bundles/Alone/makefile
index 7547590..9f81f9e 100644
--- a/CPP/7zip/Bundles/Alone/makefile
+++ b/CPP/7zip/Bundles/Alone/makefile
@@ -5,6 +5,7 @@ CFLAGS = $(CFLAGS) -DZ7_ZIP_LZFSE_DISABLE
 # CONSOLE_VARIANT_FLAGS=-DZ7_PROG_VARIANT_A
 # ZIP_FLAGS=-DZ7_ZIP_LZFSE_DISABLE
 
+# USE_C_SORT=1
 # USE_C_AES = 1
 # USE_C_SHA = 1
 # USE_C_LZFINDOPT = 1
@@ -221,7 +222,6 @@ C_OBJS = \
   $O\Ppmd8.obj \
   $O\Ppmd8Dec.obj \
   $O\Ppmd8Enc.obj \
-  $O\Sort.obj \
   $O\SwapBytes.obj \
   $O\Threads.obj \
   $O\Xxh64.obj \
@@ -240,5 +240,6 @@ C_OBJS = \
 !include "../../LzmaDec.mak"
 !include "../../Sha1.mak"
 !include "../../Sha256.mak"
+!include "../../Sort.mak"
 
 !include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Alone7z/makefile b/CPP/7zip/Bundles/Alone7z/makefile
index 89584e1..f0a813a 100644
--- a/CPP/7zip/Bundles/Alone7z/makefile
+++ b/CPP/7zip/Bundles/Alone7z/makefile
@@ -148,7 +148,6 @@ C_OBJS = \
   $O\LzmaEnc.obj \
   $O\MtCoder.obj \
   $O\MtDec.obj \
-  $O\Sort.obj \
   $O\SwapBytes.obj \
   $O\Threads.obj \
   $O\Xz.obj \
@@ -164,5 +163,6 @@ C_OBJS = \
 !include "../../LzFindOpt.mak"
 !include "../../LzmaDec.mak"
 !include "../../Sha256.mak"
+!include "../../Sort.mak"
 
 !include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Format7z/makefile b/CPP/7zip/Bundles/Format7z/makefile
index fe6f94d..3d4754c 100644
--- a/CPP/7zip/Bundles/Format7z/makefile
+++ b/CPP/7zip/Bundles/Format7z/makefile
@@ -135,7 +135,6 @@ C_OBJS = \
   $O\Ppmd7.obj \
   $O\Ppmd7Dec.obj \
   $O\Ppmd7Enc.obj \
-  $O\Sort.obj \
   $O\SwapBytes.obj \
   $O\Threads.obj \
 
@@ -144,5 +143,6 @@ C_OBJS = \
 !include "../../LzFindOpt.mak"
 !include "../../LzmaDec.mak"
 !include "../../Sha256.mak"
+!include "../../Sort.mak"
 
 !include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Format7zF/Arc.mak b/CPP/7zip/Bundles/Format7zF/Arc.mak
index 3d8a430..b1c6fe2 100644
--- a/CPP/7zip/Bundles/Format7zF/Arc.mak
+++ b/CPP/7zip/Bundles/Format7zF/Arc.mak
@@ -4,6 +4,7 @@ COMMON_OBJS = \
   $O\DynLimBuf.obj \
   $O\IntToString.obj \
   $O\LzFindPrepare.obj \
+  $O\Md5Reg.obj \
   $O\MyMap.obj \
   $O\MyString.obj \
   $O\MyVector.obj \
@@ -11,6 +12,9 @@ COMMON_OBJS = \
   $O\NewHandler.obj \
   $O\Sha1Reg.obj \
   $O\Sha256Reg.obj \
+  $O\Sha3Reg.obj \
+  $O\Sha512Reg.obj \
+  $O\Sha512Prepare.obj \
   $O\StringConvert.obj \
   $O\StringToInt.obj \
   $O\UTFConvert.obj \
@@ -274,6 +278,7 @@ C_OBJS = \
   $O\Lzma2Enc.obj \
   $O\LzmaDec.obj \
   $O\LzmaEnc.obj \
+  $O\Md5.obj \
   $O\MtCoder.obj \
   $O\MtDec.obj \
   $O\Ppmd7.obj \
@@ -283,7 +288,9 @@ C_OBJS = \
   $O\Ppmd8.obj \
   $O\Ppmd8Dec.obj \
   $O\Ppmd8Enc.obj \
-  $O\Sort.obj \
+  $O\Sha3.obj \
+  $O\Sha512.obj \
+  $O\Sha512Opt.obj \
   $O\SwapBytes.obj \
   $O\Threads.obj \
   $O\Xxh64.obj \
@@ -300,3 +307,4 @@ C_OBJS = \
 !include "../../LzmaDec.mak"
 !include "../../Sha1.mak"
 !include "../../Sha256.mak"
+!include "../../Sort.mak"
diff --git a/CPP/7zip/Bundles/Format7zF/Arc_gcc.mak b/CPP/7zip/Bundles/Format7zF/Arc_gcc.mak
index ff5a3f9..746aaff 100644
--- a/CPP/7zip/Bundles/Format7zF/Arc_gcc.mak
+++ b/CPP/7zip/Bundles/Format7zF/Arc_gcc.mak
@@ -45,6 +45,7 @@ COMMON_OBJS = \
   $O/DynLimBuf.o \
   $O/IntToString.o \
   $O/LzFindPrepare.o \
+  $O/Md5Reg.o \
   $O/MyMap.o \
   $O/MyString.o \
   $O/MyVector.o \
@@ -54,6 +55,9 @@ COMMON_OBJS = \
   $O/Sha1Reg.o \
   $O/Sha256Prepare.o \
   $O/Sha256Reg.o \
+  $O/Sha3Reg.o \
+  $O/Sha512Prepare.o \
+  $O/Sha512Reg.o \
   $O/StringConvert.o \
   $O/StringToInt.o \
   $O/UTFConvert.o \
@@ -337,6 +341,7 @@ C_OBJS = \
   $O/Lzma2Enc.o \
   $O/LzmaDec.o \
   $O/LzmaEnc.o \
+  $O/Md5.o \
   $O/MtCoder.o \
   $O/MtDec.o \
   $O/Ppmd7.o \
@@ -350,6 +355,9 @@ C_OBJS = \
   $O/Sha1Opt.o \
   $O/Sha256.o \
   $O/Sha256Opt.o \
+  $O/Sha3.o \
+  $O/Sha512.o \
+  $O/Sha512Opt.o \
   $O/Sort.o \
   $O/SwapBytes.o \
   $O/Xxh64.o \
diff --git a/CPP/7zip/Bundles/Format7zF/Format7z.dsp b/CPP/7zip/Bundles/Format7zF/Format7z.dsp
index 6e28288..0bf976c 100644
--- a/CPP/7zip/Bundles/Format7zF/Format7z.dsp
+++ b/CPP/7zip/Bundles/Format7zF/Format7z.dsp
@@ -287,6 +287,10 @@ SOURCE=..\..\..\Common\LzFindPrepare.cpp
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\Common\Md5Reg.cpp
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\Common\MyBuffer.h
 # End Source File
 # Begin Source File
@@ -383,6 +387,18 @@ SOURCE=..\..\..\Common\Sha256Reg.cpp
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\Common\Sha3Reg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha512Prepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha512Reg.cpp
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\Common\StringConvert.cpp
 # End Source File
 # Begin Source File
@@ -2029,6 +2045,26 @@ SOURCE=..\..\..\..\C\LzmaEnc.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\..\C\Md5.c
+
+!IF  "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF  "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Md5.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\..\C\MtCoder.c
 # SUBTRACT CPP /YX /Yc /Yu
 # End Source File
@@ -2230,6 +2266,62 @@ SOURCE=..\..\..\..\C\Sha256.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\..\C\Sha3.c
+
+!IF  "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF  "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha3.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha512.c
+
+!IF  "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF  "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha512.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha512Opt.c
+
+!IF  "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF  "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\..\C\Sort.c
 
 !IF  "$(CFG)" == "7z - Win32 Release"
diff --git a/CPP/7zip/Bundles/LzmaCon/LzmaAlone.cpp b/CPP/7zip/Bundles/LzmaCon/LzmaAlone.cpp
index b4bd2de..e43e8b1 100644
--- a/CPP/7zip/Bundles/LzmaCon/LzmaAlone.cpp
+++ b/CPP/7zip/Bundles/LzmaCon/LzmaAlone.cpp
@@ -59,13 +59,13 @@ static const char * const kHelpString =
     "  b : Benchmark\n"
     "<switches>\n"
     "  -a{N}  : set compression mode : [0, 1] : default = 1 (max)\n"
-    "  -d{N}  : set dictionary size : [12, 30] : default = 24 (16 MiB)\n"
+    "  -d{N}  : set dictionary size : [12, 31] : default = 24 (16 MiB)\n"
     "  -fb{N} : set number of fast bytes : [5, 273] : default = 128\n"
     "  -mc{N} : set number of cycles for match finder\n"
     "  -lc{N} : set number of literal context bits : [0, 8] : default = 3\n"
     "  -lp{N} : set number of literal pos bits : [0, 4] : default = 0\n"
     "  -pb{N} : set number of pos bits : [0, 4] : default = 2\n"
-    "  -mf{M} : set match finder: [hc4, bt2, bt3, bt4] : default = bt4\n"
+    "  -mf{M} : set match finder: [hc4, hc5, bt2, bt3, bt4, bt5] : default = bt4\n"
     "  -mt{N} : set number of CPU threads\n"
     "  -eos   : write end of stream marker\n"
     "  -si    : read data from stdin\n"
@@ -372,8 +372,8 @@ static int main2(int numArgs, const char *args[])
     return 0;
   }
 
-  bool stdInMode = parser[NKey::kStdIn].ThereIs;
-  bool stdOutMode = parser[NKey::kStdOut].ThereIs;
+  const bool stdInMode = parser[NKey::kStdIn].ThereIs;
+  const bool stdOutMode = parser[NKey::kStdOut].ThereIs;
 
   if (!stdOutMode)
     PrintTitle();
@@ -394,7 +394,16 @@ static int main2(int numArgs, const char *args[])
     UInt32 dictLog;
     const UString &s = parser[NKey::kDict].PostStrings[0];
     dictLog = GetNumber(s);
-    dict = 1 << dictLog;
+    if (dictLog >= 32)
+      throw "unsupported dictionary size";
+    // we only want to use dictionary sizes that are powers of 2,
+    // because 7-zip only recognizes such dictionary sizes in the lzma header.#if 0
+#if 0
+    if (dictLog == 32)
+      dict = (UInt32)3840 << 20;
+    else
+#endif
+    dict = (UInt32)1 << dictLog;
     dictDefined = true;
     AddProp(props2, "d", s);
   }
@@ -522,7 +531,7 @@ static int main2(int numArgs, const char *args[])
 
   if (encodeMode && !dictDefined)
   {
-    dict = 1 << kDictSizeLog;
+    dict = (UInt32)1 << kDictSizeLog;
     if (fileSizeDefined)
     {
       unsigned i;
diff --git a/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp b/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
index eb28f5d..0c09807 100644
--- a/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
+++ b/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
@@ -229,7 +229,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
   }
 
   const FString tempDirPath = tempDir.GetPath();
-  // tempDirPath = L"M:\\1\\"; // to test low disk space
+  // tempDirPath = "M:\\1\\"; // to test low disk space
   {
     bool isCorrupt = false;
     UString errorMessage;
@@ -308,7 +308,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
   {
     if (appLaunched.IsEmpty())
     {
-      appLaunched = L"setup.exe";
+      appLaunched = "setup.exe";
       if (!NFind::DoesFileExist_FollowLink(us2fs(appLaunched)))
       {
         if (!assumeYes)
diff --git a/CPP/7zip/Common/CreateCoder.cpp b/CPP/7zip/Common/CreateCoder.cpp
index bf7b04e..93113a0 100644
--- a/CPP/7zip/Common/CreateCoder.cpp
+++ b/CPP/7zip/Common/CreateCoder.cpp
@@ -35,7 +35,7 @@ void RegisterCodec(const CCodecInfo *codecInfo) throw()
     g_Codecs[g_NumCodecs++] = codecInfo;
 }
 
-static const unsigned kNumHashersMax = 16;
+static const unsigned kNumHashersMax = 32;
 extern
 unsigned g_NumHashers;
 unsigned g_NumHashers = 0;
diff --git a/CPP/7zip/Common/InBuffer.h b/CPP/7zip/Common/InBuffer.h
index a8ccb40..13ec088 100644
--- a/CPP/7zip/Common/InBuffer.h
+++ b/CPP/7zip/Common/InBuffer.h
@@ -97,6 +97,16 @@ public:
   
   size_t ReadBytesPart(Byte *buf, size_t size);
   size_t ReadBytes(Byte *buf, size_t size);
+  const Byte *Lookahead(size_t &rem)
+  {
+    rem = (size_t)(_bufLim - _buf);
+    if (!rem)
+    {
+      ReadBlock();
+      rem = (size_t)(_bufLim - _buf);
+    }
+    return _buf;
+  }
   size_t Skip(size_t size);
 };
 
diff --git a/CPP/7zip/Common/MethodProps.cpp b/CPP/7zip/Common/MethodProps.cpp
index d87884c..a5d90cf 100644
--- a/CPP/7zip/Common/MethodProps.cpp
+++ b/CPP/7zip/Common/MethodProps.cpp
@@ -324,15 +324,22 @@ void CCoderProps::AddProp(const CProp &prop)
 
 HRESULT CProps::SetCoderProps(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce) const
 {
-  return SetCoderProps_DSReduce_Aff(scp, dataSizeReduce, NULL);
+  return SetCoderProps_DSReduce_Aff(scp, dataSizeReduce, NULL, NULL, NULL);
 }
 
 HRESULT CProps::SetCoderProps_DSReduce_Aff(
     ICompressSetCoderProperties *scp,
     const UInt64 *dataSizeReduce,
-    const UInt64 *affinity) const
-{
-  CCoderProps coderProps(Props.Size() + (dataSizeReduce ? 1 : 0) + (affinity ? 1 : 0) );
+    const UInt64 *affinity,
+    const UInt32 *affinityGroup,
+    const UInt64 *affinityInGroup) const
+{
+  CCoderProps coderProps(Props.Size()
+      + (dataSizeReduce ? 1 : 0)
+      + (affinity ? 1 : 0)
+      + (affinityGroup ? 1 : 0)
+      + (affinityInGroup ? 1 : 0)
+      );
   FOR_VECTOR (i, Props)
     coderProps.AddProp(Props[i]);
   if (dataSizeReduce)
@@ -349,6 +356,20 @@ HRESULT CProps::SetCoderProps_DSReduce_Aff(
     prop.Value = *affinity;
     coderProps.AddProp(prop);
   }
+  if (affinityGroup)
+  {
+    CProp prop;
+    prop.Id = NCoderPropID::kThreadGroup;
+    prop.Value = *affinityGroup;
+    coderProps.AddProp(prop);
+  }
+  if (affinityInGroup)
+  {
+    CProp prop;
+    prop.Id = NCoderPropID::kAffinityInGroup;
+    prop.Value = *affinityInGroup;
+    coderProps.AddProp(prop);
+  }
   return coderProps.SetProps(scp);
 }
 
@@ -409,6 +430,11 @@ static const CNameToPropID g_NameToPropID[] =
   { VT_UI4, "offset" },
   { VT_UI4, "zhb" }
   /*
+  , { VT_UI4, "tgn" }, // kNumThreadGroups
+  , { VT_UI4, "tgi" }, // kThreadGroup
+  , { VT_UI8, "tga" }, // kAffinityInGroup
+  */
+  /*
   ,
   // { VT_UI4, "zhc" },
   // { VT_UI4, "zhd" },
diff --git a/CPP/7zip/Common/MethodProps.h b/CPP/7zip/Common/MethodProps.h
index 3c332d6..be108fa 100644
--- a/CPP/7zip/Common/MethodProps.h
+++ b/CPP/7zip/Common/MethodProps.h
@@ -80,7 +80,11 @@ struct CProps
   }
 
   HRESULT SetCoderProps(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce = NULL) const;
-  HRESULT SetCoderProps_DSReduce_Aff(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce, const UInt64 *affinity) const;
+  HRESULT SetCoderProps_DSReduce_Aff(ICompressSetCoderProperties *scp,
+      const UInt64 *dataSizeReduce,
+      const UInt64 *affinity,
+      const UInt32 *affinityGroup,
+      const UInt64 *affinityInGroup) const;
 };
 
 class CMethodProps: public CProps
@@ -125,7 +129,7 @@ public:
 
   UInt32 Get_Lzma_Algo() const
   {
-    int i = FindProp(NCoderPropID::kAlgorithm);
+    const int i = FindProp(NCoderPropID::kAlgorithm);
     if (i >= 0)
     {
       const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
@@ -141,11 +145,11 @@ public:
     if (Get_DicSize(v))
       return v;
     const unsigned level = GetLevel();
-    const UInt32 dictSize =
-        ( level <= 3 ? ((UInt32)1 << (level * 2 + 16)) :
-        ( level <= 6 ? ((UInt32)1 << (level + 19)) :
-        ( level <= 7 ? ((UInt32)1 << 25) : ((UInt32)1 << 26)
-        )));
+    const UInt32 dictSize = level <= 4 ?
+        (UInt32)1 << (level * 2 + 16) :
+        level <= sizeof(size_t) / 2 + 4 ?
+          (UInt32)1 << (level + 20) :
+          (UInt32)1 << (sizeof(size_t) / 2 + 24);
     return dictSize;
   }
 
diff --git a/CPP/7zip/Common/OutBuffer.h b/CPP/7zip/Common/OutBuffer.h
index 88f5787..af78c4f 100644
--- a/CPP/7zip/Common/OutBuffer.h
+++ b/CPP/7zip/Common/OutBuffer.h
@@ -45,6 +45,7 @@ public:
   HRESULT Flush() throw();
   void FlushWithCheck();
 
+  Z7_FORCE_INLINE
   void WriteByte(Byte b)
   {
     UInt32 pos = _pos;
@@ -54,10 +55,34 @@ public:
     if (pos == _limitPos)
       FlushWithCheck();
   }
+  
   void WriteBytes(const void *data, size_t size)
   {
-    for (size_t i = 0; i < size; i++)
-      WriteByte(((const Byte *)data)[i]);
+    while (size)
+    {
+      UInt32 pos = _pos;
+      size_t cur = (size_t)(_limitPos - pos);
+      if (cur >= size)
+        cur = size;
+      size -= cur;
+      Byte *dest = _buf + pos;
+      pos += (UInt32)cur;
+      _pos = pos;
+#if 0
+      memcpy(dest, data, cur);
+      data = (const void *)((const Byte *)data + cur);
+#else
+      const Byte * const lim = (const Byte *)data + cur;
+      do
+      {
+        *dest++ = *(const Byte *)data;
+        data = (const void *)((const Byte *)data + 1);
+      }
+      while (data != lim);
+#endif
+      if (pos == _limitPos)
+        FlushWithCheck();
+    }
   }
 
   Byte *GetOutBuffer(size_t &avail)
diff --git a/CPP/7zip/Compress/BZip2Const.h b/CPP/7zip/Compress/BZip2Const.h
index 0dfcfe5..3380aaf 100644
--- a/CPP/7zip/Compress/BZip2Const.h
+++ b/CPP/7zip/Compress/BZip2Const.h
@@ -46,7 +46,7 @@ const UInt32 kBlockSizeStep = 100000;
 const UInt32 kBlockSizeMax = kBlockSizeMultMax * kBlockSizeStep;
 
 const unsigned kNumSelectorsBits = 15;
-const UInt32 kNumSelectorsMax = (2 + (kBlockSizeMax / kGroupSize));
+const unsigned kNumSelectorsMax = 2 + kBlockSizeMax / kGroupSize;
 
 const unsigned kRleModeRepSize = 4;
 
diff --git a/CPP/7zip/Compress/BZip2Encoder.cpp b/CPP/7zip/Compress/BZip2Encoder.cpp
index ef2555a..af0b312 100644
--- a/CPP/7zip/Compress/BZip2Encoder.cpp
+++ b/CPP/7zip/Compress/BZip2Encoder.cpp
@@ -6,18 +6,20 @@
 #include "../../../C/BwtSort.h"
 #include "../../../C/HuffEnc.h"
 
-#include "BZip2Crc.h"
 #include "BZip2Encoder.h"
-#include "Mtf8.h"
 
 namespace NCompress {
 namespace NBZip2 {
 
-const unsigned kMaxHuffmanLenForEncoding = 16; // it must be < kMaxHuffmanLen = 20
-
-static const UInt32 kBufferSize = (1 << 17);
+#define HUFFMAN_LEN 16
+#if HUFFMAN_LEN > Z7_HUFFMAN_LEN_MAX
+  #error Stop_Compiling_Bad_HUFFMAN_LEN_BZip2Encoder
+#endif
+  
+static const size_t kBufferSize = 1 << 17;
 static const unsigned kNumHuffPasses = 4;
 
+
 bool CThreadInfo::Alloc()
 {
   if (!m_BlockSorterIndex)
@@ -27,11 +29,15 @@ bool CThreadInfo::Alloc()
       return false;
   }
 
-  if (!m_Block)
+  if (!m_Block_Base)
   {
-    m_Block = (Byte *)::MidAlloc(kBlockSizeMax * 5 + kBlockSizeMax / 10 + (20 << 10));
-    if (!m_Block)
+    const unsigned kPadSize = 1 << 7; // we need at least 1 byte backward padding, becuase we use (m_Block - 1) pointer;
+    m_Block_Base = (Byte *)::MidAlloc(kBlockSizeMax * 5
+        + kBlockSizeMax / 10 + (20 << 10)
+        + kPadSize);
+    if (!m_Block_Base)
       return false;
+    m_Block = m_Block_Base + kPadSize;
     m_MtfArray = m_Block + kBlockSizeMax;
     m_TempArray = m_MtfArray + kBlockSizeMax * 2 + 2;
   }
@@ -42,8 +48,8 @@ void CThreadInfo::Free()
 {
   ::BigFree(m_BlockSorterIndex);
   m_BlockSorterIndex = NULL;
-  ::MidFree(m_Block);
-  m_Block = NULL;
+  ::MidFree(m_Block_Base);
+  m_Block_Base = NULL;
 }
 
 #ifndef Z7_ST
@@ -60,10 +66,14 @@ HRESULT CThreadInfo::Create()
   if (wres == 0) { wres = CanWriteEvent.Create();
   if (wres == 0)
   {
-    if (Encoder->_props.Affinity != 0)
-      wres = Thread.Create_With_Affinity(MFThread, this, (CAffinityMask)Encoder->_props.Affinity);
-    else
-      wres = Thread.Create(MFThread, this);
+    wres =
+#ifdef _WIN32
+      Encoder->_props.NumThreadGroups > 1 ?
+        Thread.Create_With_Group(MFThread, this, ThreadNextGroup_GetNext(&Encoder->ThreadNextGroup), 0) : // affinity
+#endif
+      Encoder->_props.Affinity != 0 ?
+        Thread.Create_With_Affinity(MFThread, this, (CAffinityMask)Encoder->_props.Affinity) :
+        Thread.Create(MFThread, this);
   }}}
   return HRESULT_FROM_WIN32(wres);
 }
@@ -216,94 +226,251 @@ void CEncoder::Free()
 }
 #endif
 
+struct CRleEncoder
+{
+  const Byte *_src;
+  const Byte *_srcLim;
+  Byte *_dest;
+  const Byte *_destLim;
+  Byte _prevByte;
+  unsigned _numReps;
+
+  void Encode();
+};
+
+Z7_NO_INLINE
+void CRleEncoder::Encode()
+{
+  const Byte *src = _src;
+  const Byte * const srcLim = _srcLim;
+  Byte *dest = _dest;
+  const Byte * const destLim = _destLim;
+  Byte prev = _prevByte;
+  unsigned numReps = _numReps;
+  // (dest < destLim)
+  // src = srcLim; // for debug
+  while (dest < destLim)
+  {
+    if (src == srcLim)
+      break;
+    const Byte b = *src++;
+    if (b != prev)
+    {
+      if (numReps >= kRleModeRepSize)
+        *dest++ = (Byte)(numReps - kRleModeRepSize);
+      *dest++ = b;
+      numReps = 1;
+      prev = b;
+      /*
+      { // speed optimization code:
+        if (dest >= destLim || src == srcLim)
+          break;
+        const Byte b2 = *src++;
+        *dest++ = b2;
+        numReps += (prev == b2);
+        prev = b2;
+      }
+      */
+      continue;
+    }
+    numReps++;
+    if (numReps <= kRleModeRepSize)
+      *dest++ = b;
+    else if (numReps == kRleModeRepSize + 255)
+    {
+      *dest++ = (Byte)(numReps - kRleModeRepSize);
+      numReps = 0;
+    }
+  }
+  _src = src;
+  _dest = dest;
+  _prevByte = prev;
+  _numReps = numReps;
+  // (dest <= destLim + 1)
+}
+
+
+// out: return value is blockSize: size of data filled in buffer[]:
+// (returned_blockSize <= _props.BlockSizeMult * kBlockSizeStep)
 UInt32 CEncoder::ReadRleBlock(Byte *buffer)
 {
+  CRleEncoder rle;
   UInt32 i = 0;
-  Byte prevByte;
-  if (m_InStream.ReadByte(prevByte))
+  if (m_InStream.ReadByte(rle._prevByte))
   {
     NumBlocks++;
-    const UInt32 blockSize = _props.BlockSizeMult * kBlockSizeStep - 1;
-    unsigned numReps = 1;
-    buffer[i++] = prevByte;
-    while (i < blockSize) // "- 1" to support RLE
+    const UInt32 blockSize = _props.BlockSizeMult * kBlockSizeStep - 1; // -1 for RLE
+    rle._destLim = buffer + blockSize;
+    rle._numReps = 1;
+    buffer[i++] = rle._prevByte;
+    while (i < blockSize)
     {
-      Byte b;
-      if (!m_InStream.ReadByte(b))
+      rle._dest = buffer + i;
+      size_t rem;
+      const Byte * const ptr = m_InStream.Lookahead(rem);
+      if (rem == 0)
         break;
-      if (b != prevByte)
-      {
-        if (numReps >= kRleModeRepSize)
-          buffer[i++] = (Byte)(numReps - kRleModeRepSize);
-        buffer[i++] = b;
-        numReps = 1;
-        prevByte = b;
-        continue;
-      }
-      numReps++;
-      if (numReps <= kRleModeRepSize)
-        buffer[i++] = b;
-      else if (numReps == kRleModeRepSize + 255)
-      {
-        buffer[i++] = (Byte)(numReps - kRleModeRepSize);
-        numReps = 0;
-      }
+      rle._src = ptr;
+      rle._srcLim = ptr + rem;
+      rle.Encode();
+      m_InStream.Skip((size_t)(rle._src - ptr));
+      i = (UInt32)(size_t)(rle._dest - buffer);
+      // (i <= blockSize + 1)
     }
-    // it's to support original BZip2 decoder
-    if (numReps >= kRleModeRepSize)
-      buffer[i++] = (Byte)(numReps - kRleModeRepSize);
+    const int n = (int)rle._numReps - (int)kRleModeRepSize;
+    if (n >= 0)
+      buffer[i++] = (Byte)n;
   }
   return i;
 }
 
-void CThreadInfo::WriteBits2(UInt32 value, unsigned numBits) { m_OutStreamCurrent->WriteBits(value, numBits); }
-void CThreadInfo::WriteByte2(Byte b) { WriteBits2(b, 8); }
-void CThreadInfo::WriteBit2(Byte v) { WriteBits2(v, 1); }
-void CThreadInfo::WriteCrc2(UInt32 v)
-{
-  for (unsigned i = 0; i < 4; i++)
-    WriteByte2(((Byte)(v >> (24 - i * 8))));
+
+
+Z7_NO_INLINE
+void CThreadInfo::WriteBits2(UInt32 value, unsigned numBits)
+  { m_OutStreamCurrent.WriteBits(value, numBits); }
+/*
+Z7_NO_INLINE
+void CThreadInfo::WriteByte2(unsigned b)
+  { m_OutStreamCurrent.WriteByte(b); }
+*/
+// void CEncoder::WriteBits(UInt32 value, unsigned numBits) { m_OutStream.WriteBits(value, numBits); }
+Z7_NO_INLINE
+void CEncoder::WriteByte(Byte b) { m_OutStream.WriteByte(b); }
+
+
+#define WRITE_BITS_UPDATE(value, numBits) \
+{ \
+  numBits -= _bitPos; \
+  const UInt32 hi = value >> numBits; \
+  *_buf++ = (Byte)(_curByte | hi); \
+  value -= hi << numBits; \
+  _bitPos = 8; \
+  _curByte = 0; \
 }
 
-void CEncoder::WriteBits(UInt32 value, unsigned numBits) { m_OutStream.WriteBits(value, numBits); }
-void CEncoder::WriteByte(Byte b) { WriteBits(b, 8); }
-// void CEncoder::WriteBit(Byte v) { WriteBits(v, 1); }
-void CEncoder::WriteCrc(UInt32 v)
-{
-  for (unsigned i = 0; i < 4; i++)
-    WriteByte(((Byte)(v >> (24 - i * 8))));
+#if HUFFMAN_LEN > 16
+
+#define WRITE_BITS_HUFF(value2, numBits2) \
+{ \
+  UInt32 value = value2; \
+  unsigned numBits = numBits2; \
+  while (numBits >= _bitPos) { \
+    WRITE_BITS_UPDATE(value, numBits) \
+  } \
+  _bitPos -= numBits; \
+  _curByte |= (value << _bitPos); \
+}
+
+#else // HUFFMAN_LEN <= 16
+
+// numBits2 <= 16 is supported
+#define WRITE_BITS_HUFF(value2, numBits2) \
+{ \
+  UInt32 value = value2; \
+  unsigned numBits = numBits2; \
+  if (numBits >= _bitPos) \
+  { \
+    WRITE_BITS_UPDATE(value, numBits) \
+    if (numBits >= _bitPos) \
+    { \
+      numBits -= _bitPos; \
+      const UInt32 hi = value >> numBits; \
+      *_buf++ = (Byte)hi; \
+      value -= hi << numBits; \
+    } \
+  } \
+  _bitPos -= numBits; \
+  _curByte |= (value << _bitPos); \
+}
+
+#endif
+
+#define WRITE_BITS_8(value2, numBits2) \
+{ \
+  UInt32 value = value2; \
+  unsigned numBits = numBits2; \
+  if (numBits >= _bitPos) \
+  { \
+    WRITE_BITS_UPDATE(value, numBits) \
+  } \
+  _bitPos -= numBits; \
+  _curByte |= (value << _bitPos); \
+}
+
+#define WRITE_BIT_PRE \
+  { _bitPos--; }
+
+#define WRITE_BIT_POST \
+{ \
+  if (_bitPos == 0) \
+  { \
+    *_buf++ = (Byte)_curByte; \
+    _curByte = 0; \
+    _bitPos = 8; \
+  } \
+}
+
+#define WRITE_BIT_0 \
+{ \
+  WRITE_BIT_PRE \
+  WRITE_BIT_POST \
+}
+
+#define WRITE_BIT_1 \
+{ \
+  WRITE_BIT_PRE \
+  _curByte |= 1u << _bitPos; \
+  WRITE_BIT_POST \
 }
 
 
 // blockSize > 0
 void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
 {
-  WriteBit2(0); // Randomised = false
-  
+  // WriteBit2(0); // Randomised = false
   {
-    UInt32 origPtr = BlockSort(m_BlockSorterIndex, block, blockSize);
+    const UInt32 origPtr = BlockSort(m_BlockSorterIndex, block, blockSize);
     // if (m_BlockSorterIndex[origPtr] != 0) throw 1;
     m_BlockSorterIndex[origPtr] = blockSize;
-    WriteBits2(origPtr, kNumOrigBits);
+    WriteBits2(origPtr, kNumOrigBits + 1); // + 1 for additional high bit flag (Randomised = false)
   }
-
-  CMtf8Encoder mtf;
-  unsigned numInUse = 0;
+  Byte mtfBuf[256];
+  // memset(mtfBuf, 0, sizeof(mtfBuf)); // to disable MSVC warning
+  unsigned numInUse;
   {
     Byte inUse[256];
     Byte inUse16[16];
-    UInt32 i;
+    unsigned i;
     for (i = 0; i < 256; i++)
       inUse[i] = 0;
     for (i = 0; i < 16; i++)
       inUse16[i] = 0;
-    for (i = 0; i < blockSize; i++)
-      inUse[block[i]] = 1;
+    {
+      const Byte *       cur = block;
+      block = block + (size_t)blockSize - 1;
+      if (cur != block)
+      {
+        do
+        {
+          const unsigned b0 = cur[0];
+          const unsigned b1 = cur[1];
+          cur += 2;
+          inUse[b0] = 1;
+          inUse[b1] = 1;
+        }
+        while (cur < block);
+      }
+      if (cur == block)
+        inUse[cur[0]] = 1;
+      block -= blockSize; // block pointer is (original_block - 1)
+    }
+    numInUse = 0;
     for (i = 0; i < 256; i++)
       if (inUse[i])
       {
         inUse16[i >> 4] = 1;
-        mtf.Buf[numInUse++] = (Byte)i;
+        mtfBuf[numInUse++] = (Byte)i;
       }
     for (i = 0; i < 16; i++)
       WriteBit2(inUse16[i]);
@@ -311,65 +478,88 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
       if (inUse16[i >> 4])
         WriteBit2(inUse[i]);
   }
-  unsigned alphaSize = numInUse + 2;
+  const unsigned alphaSize = numInUse + 2;
 
-  Byte *mtfs = m_MtfArray;
-  UInt32 mtfArraySize = 0;
   UInt32 symbolCounts[kMaxAlphaSize];
   {
     for (unsigned i = 0; i < kMaxAlphaSize; i++)
       symbolCounts[i] = 0;
+    symbolCounts[(size_t)alphaSize - 1] = 1;
   }
 
+  Byte *mtfs = m_MtfArray;
   {
-    UInt32 rleSize = 0;
-    UInt32 i = 0;
     const UInt32 *bsIndex = m_BlockSorterIndex;
-    block--;
+    const UInt32 *bsIndex_rle = bsIndex;
+    const UInt32 * const bsIndex_end = bsIndex + blockSize;
+    // block--; // backward fix
+    // block pointer is (original_block - 1)
     do
     {
-      unsigned pos = mtf.FindAndMove(block[bsIndex[i]]);
-      if (pos == 0)
-        rleSize++;
-      else
+      const Byte v = block[*bsIndex++];
+      Byte a = mtfBuf[0];
+      if (v != a)
       {
-        while (rleSize != 0)
+        mtfBuf[0] = v;
         {
-          rleSize--;
-          mtfs[mtfArraySize++] = (Byte)(rleSize & 1);
-          symbolCounts[rleSize & 1]++;
-          rleSize >>= 1;
+          UInt32 rleSize = (UInt32)(size_t)(bsIndex - bsIndex_rle) - 1;
+          bsIndex_rle = bsIndex;
+          while (rleSize)
+          {
+            const unsigned sym = (unsigned)(--rleSize & 1);
+            *mtfs++ = (Byte)sym;
+            symbolCounts[sym]++;
+            rleSize >>= 1;
+          }
         }
-        if (pos >= 0xFE)
+        unsigned pos1 = 2; // = real_pos + 1
+        Byte b;
+               b = mtfBuf[1];  mtfBuf[1] = a;  if (v != b)
+             { a = mtfBuf[2];  mtfBuf[2] = b;  if (v == a) pos1 = 3;
+        else { b = mtfBuf[3];  mtfBuf[3] = a;  if (v == b) pos1 = 4;
+        else
+        {
+          Byte *m = mtfBuf + 7;
+          for (;;)
+          {
+            a = m[-3];  m[-3] = b;           if (v == a) { pos1 = (unsigned)(size_t)(m - (mtfBuf + 2)); break; }
+            b = m[-2];  m[-2] = a;           if (v == b) { pos1 = (unsigned)(size_t)(m - (mtfBuf + 1)); break; }
+            a = m[-1];  m[-1] = b;           if (v == a) { pos1 = (unsigned)(size_t)(m - (mtfBuf    )); break; }
+            b = m[ 0];  m[ 0] = a;  m += 4;  if (v == b) { pos1 = (unsigned)(size_t)(m - (mtfBuf + 3)); break; }
+          }
+        }}}
+        symbolCounts[pos1]++;
+        if (pos1 >= 0xff)
         {
-          mtfs[mtfArraySize++] = 0xFF;
-          mtfs[mtfArraySize++] = (Byte)(pos - 0xFE);
+          *mtfs++ = 0xff;
+          // pos1 -= 0xff;
+          pos1++; // we need only low byte
         }
-        else
-          mtfs[mtfArraySize++] = (Byte)(pos + 1);
-        symbolCounts[(size_t)pos + 1]++;
+        *mtfs++ = (Byte)pos1;
       }
     }
-    while (++i < blockSize);
+    while (bsIndex < bsIndex_end);
 
-    while (rleSize != 0)
+    UInt32 rleSize = (UInt32)(size_t)(bsIndex - bsIndex_rle);
+    while (rleSize)
     {
-      rleSize--;
-      mtfs[mtfArraySize++] = (Byte)(rleSize & 1);
-      symbolCounts[rleSize & 1]++;
+      const unsigned sym = (unsigned)(--rleSize & 1);
+      *mtfs++ = (Byte)sym;
+      symbolCounts[sym]++;
       rleSize >>= 1;
     }
-
-    if (alphaSize < 256)
-      mtfs[mtfArraySize++] = (Byte)(alphaSize - 1);
-    else
+    
+    unsigned d = alphaSize - 1;
+    if (alphaSize >= 256)
     {
-      mtfs[mtfArraySize++] = 0xFF;
-      mtfs[mtfArraySize++] = (Byte)(alphaSize - 256);
+      *mtfs++ = 0xff;
+      d = alphaSize; // (-256)
     }
-    symbolCounts[(size_t)alphaSize - 1]++;
+    *mtfs++ = (Byte)d;
   }
 
+  const Byte * const mtf_lim = mtfs;
+
   UInt32 numSymbols = 0;
   {
     for (unsigned i = 0; i < kMaxAlphaSize; i++)
@@ -378,34 +568,30 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
 
   unsigned bestNumTables = kNumTablesMin;
   UInt32 bestPrice = 0xFFFFFFFF;
-  UInt32 startPos = m_OutStreamCurrent->GetPos();
-  Byte startCurByte = m_OutStreamCurrent->GetCurByte();
+  const UInt32 startPos = m_OutStreamCurrent.GetPos();
+  const unsigned startCurByte = m_OutStreamCurrent.GetCurByte();
   for (unsigned nt = kNumTablesMin; nt <= kNumTablesMax + 1; nt++)
   {
     unsigned numTables;
 
     if (m_OptimizeNumTables)
     {
-      m_OutStreamCurrent->SetPos(startPos);
-      m_OutStreamCurrent->SetCurState((startPos & 7), startCurByte);
-      if (nt <= kNumTablesMax)
-        numTables = nt;
-      else
-        numTables = bestNumTables;
+      m_OutStreamCurrent.SetPos(startPos);
+      m_OutStreamCurrent.SetCurState(startPos & 7, startCurByte);
+      numTables = (nt <= kNumTablesMax ? nt : bestNumTables);
     }
     else
     {
-      if (numSymbols < 200)  numTables = 2;
-      else if (numSymbols < 600) numTables = 3;
+           if (numSymbols <  200) numTables = 2;
+      else if (numSymbols <  600) numTables = 3;
       else if (numSymbols < 1200) numTables = 4;
       else if (numSymbols < 2400) numTables = 5;
-      else numTables = 6;
+      else                        numTables = 6;
     }
 
     WriteBits2(numTables, kNumTablesBits);
-    
-    UInt32 numSelectors = (numSymbols + kGroupSize - 1) / kGroupSize;
-    WriteBits2(numSelectors, kNumSelectorsBits);
+    const unsigned numSelectors = (numSymbols + kGroupSize - 1) / kGroupSize;
+    WriteBits2((UInt32)numSelectors, kNumSelectorsBits);
     
     {
       UInt32 remFreq = numSymbols;
@@ -436,28 +622,23 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
     
     for (unsigned pass = 0; pass < kNumHuffPasses; pass++)
     {
+      memset(Freqs, 0, sizeof(Freqs[0]) * numTables);
+      // memset(Freqs, 0, sizeof(Freqs));
       {
-        unsigned t = 0;
-        do
-          memset(Freqs[t], 0, sizeof(Freqs[t]));
-        while (++t < numTables);
-      }
-      
-      {
-        UInt32 mtfPos = 0;
+        mtfs = m_MtfArray;
         UInt32 g = 0;
         do
         {
-          UInt32 symbols[kGroupSize];
+          unsigned symbols[kGroupSize];
           unsigned i = 0;
           do
           {
-            UInt32 symbol = mtfs[mtfPos++];
+            UInt32 symbol = *mtfs++;
             if (symbol >= 0xFF)
-              symbol += mtfs[mtfPos++];
+              symbol += *mtfs++;
             symbols[i] = symbol;
           }
-          while (++i < kGroupSize && mtfPos < mtfArraySize);
+          while (++i < kGroupSize && mtfs < mtf_lim);
           
           UInt32 bestPrice2 = 0xFFFFFFFF;
           unsigned t = 0;
@@ -482,7 +663,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
             freqs[symbols[j]]++;
           while (++j < i);
         }
-        while (mtfPos < mtfArraySize);
+        while (mtfs < mtf_lim);
       }
       
       unsigned t = 0;
@@ -494,11 +675,15 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
           if (freqs[i] == 0)
             freqs[i] = 1;
         while (++i < alphaSize);
-        Huffman_Generate(freqs, Codes[t], Lens[t], kMaxAlphaSize, kMaxHuffmanLenForEncoding);
+        Huffman_Generate(freqs, Codes[t], Lens[t], kMaxAlphaSize, HUFFMAN_LEN);
       }
       while (++t < numTables);
     }
     
+    unsigned _bitPos;  // 0 < _bitPos <= 8 : number of non-filled low bits in _curByte
+    unsigned _curByte; // low (_bitPos) bits are zeros
+                       // high (8 - _bitPos) bits are filled
+    Byte *_buf;
     {
       Byte mtfSel[kNumTablesMax];
       {
@@ -507,81 +692,97 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
           mtfSel[t] = (Byte)t;
         while (++t < numTables);
       }
+
+      _bitPos = m_OutStreamCurrent._bitPos;
+      _curByte = m_OutStreamCurrent._curByte;
+      _buf = m_OutStreamCurrent._buf;
+      // stream.Init_from_Global(m_OutStreamCurrent);
       
-      UInt32 i = 0;
+      const Byte *selectors = m_Selectors;
+      const Byte * const selectors_lim = selectors + numSelectors;
+      Byte prev = 0; // mtfSel[0];
       do
       {
-        Byte sel = m_Selectors[i];
-        unsigned pos;
-        for (pos = 0; mtfSel[pos] != sel; pos++)
-          WriteBit2(1);
-        WriteBit2(0);
-        for (; pos > 0; pos--)
-          mtfSel[pos] = mtfSel[(size_t)pos - 1];
-        mtfSel[0] = sel;
+        const Byte sel = *selectors++;
+        if (prev != sel)
+        {
+          Byte *mtfSel_cur = &mtfSel[1];
+          for (;;)
+          {
+            WRITE_BIT_1
+            const Byte next = *mtfSel_cur;
+            *mtfSel_cur++ = prev;
+            prev = next;
+            if (next == sel)
+              break;
+          }
+          // mtfSel[0] = sel;
+        }
+        WRITE_BIT_0
       }
-      while (++i < numSelectors);
+      while (selectors != selectors_lim);
     }
-    
     {
       unsigned t = 0;
       do
       {
         const Byte *lens = Lens[t];
-        UInt32 len = lens[0];
-        WriteBits2(len, kNumLevelsBits);
+        unsigned len = lens[0];
+        WRITE_BITS_8(len, kNumLevelsBits)
         unsigned i = 0;
         do
         {
-          UInt32 level = lens[i];
+          const unsigned level = lens[i];
           while (len != level)
           {
-            WriteBit2(1);
+            WRITE_BIT_1
             if (len < level)
             {
-              WriteBit2(0);
               len++;
+              WRITE_BIT_0
             }
             else
             {
-              WriteBit2(1);
               len--;
+              WRITE_BIT_1
             }
           }
-          WriteBit2(0);
+          WRITE_BIT_0
         }
         while (++i < alphaSize);
       }
       while (++t < numTables);
     }
-    
     {
-      UInt32 groupSize = 0;
-      UInt32 groupIndex = 0;
+      UInt32 groupSize = 1;
+      const Byte *selectors = m_Selectors;
       const Byte *lens = NULL;
       const UInt32 *codes = NULL;
-      UInt32 mtfPos = 0;
+      mtfs = m_MtfArray;
       do
       {
-        UInt32 symbol = mtfs[mtfPos++];
+        unsigned symbol = *mtfs++;
         if (symbol >= 0xFF)
-          symbol += mtfs[mtfPos++];
-        if (groupSize == 0)
+          symbol += *mtfs++;
+        if (--groupSize == 0)
         {
           groupSize = kGroupSize;
-          unsigned t = m_Selectors[groupIndex++];
+          const unsigned t = *selectors++;
           lens = Lens[t];
           codes = Codes[t];
         }
-        groupSize--;
-        m_OutStreamCurrent->WriteBits(codes[symbol], lens[symbol]);
+        WRITE_BITS_HUFF(codes[symbol], lens[symbol])
       }
-      while (mtfPos < mtfArraySize);
+      while (mtfs < mtf_lim);
     }
+    // Restore_from_Local:
+    m_OutStreamCurrent._bitPos = _bitPos;
+    m_OutStreamCurrent._curByte = _curByte;
+    m_OutStreamCurrent._buf = _buf;
 
     if (!m_OptimizeNumTables)
       break;
-    UInt32 price = m_OutStreamCurrent->GetPos() - startPos;
+    const UInt32 price = m_OutStreamCurrent.GetPos() - startPos;
     if (price <= bestPrice)
     {
       if (nt == kNumTablesMax)
@@ -592,6 +793,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
   }
 }
 
+
 // blockSize > 0
 UInt32 CThreadInfo::EncodeBlockWithHeaders(const Byte *block, UInt32 blockSize)
 {
@@ -603,142 +805,126 @@ UInt32 CThreadInfo::EncodeBlockWithHeaders(const Byte *block, UInt32 blockSize)
   WriteByte2(kBlockSig5);
 
   CBZip2Crc crc;
-  unsigned numReps = 0;
-  Byte prevByte = block[0];
-  UInt32 i = 0;
-  do
+  const Byte * const lim = block + blockSize;
+  unsigned b = *block++;
+  crc.UpdateByte(b);
+  for (;;)
   {
-    Byte b = block[i];
-    if (numReps == kRleModeRepSize)
-    {
-      for (; b > 0; b--)
-        crc.UpdateByte(prevByte);
-      numReps = 0;
-      continue;
-    }
-    if (prevByte == b)
-      numReps++;
-    else
-    {
-      numReps = 1;
-      prevByte = b;
-    }
-    crc.UpdateByte(b);
+    const unsigned prev = b;
+    if (block >= lim) { break; } b = *block++;  crc.UpdateByte(b);  if (prev != b) continue;
+    if (block >= lim) { break; } b = *block++;  crc.UpdateByte(b);  if (prev != b) continue;
+    if (block >= lim) { break; } b = *block++;  crc.UpdateByte(b);  if (prev != b) continue;
+    if (block >= lim) { break; } b = *block++;  if (b) do crc.UpdateByte(prev); while (--b);
+    if (block >= lim) { break; } b = *block++;  crc.UpdateByte(b);
   }
-  while (++i < blockSize);
-  UInt32 crcRes = crc.GetDigest();
-  WriteCrc2(crcRes);
-  EncodeBlock(block, blockSize);
+  const UInt32 crcRes = crc.GetDigest();
+  for (int i = 24; i >= 0; i -= 8)
+    WriteByte2((Byte)(crcRes >> i));
+  EncodeBlock(lim - blockSize, blockSize);
   return crcRes;
 }
 
+
 void CThreadInfo::EncodeBlock2(const Byte *block, UInt32 blockSize, UInt32 numPasses)
 {
-  UInt32 numCrcs = m_NumCrcs;
-  bool needCompare = false;
-
-  UInt32 startBytePos = m_OutStreamCurrent->GetBytePos();
-  UInt32 startPos = m_OutStreamCurrent->GetPos();
-  Byte startCurByte = m_OutStreamCurrent->GetCurByte();
-  Byte endCurByte = 0;
-  UInt32 endPos = 0;
+  const UInt32 numCrcs = m_NumCrcs;
+
+  const UInt32 startBytePos = m_OutStreamCurrent.GetBytePos();
+  const UInt32 startPos = m_OutStreamCurrent.GetPos();
+  const unsigned startCurByte = m_OutStreamCurrent.GetCurByte();
+  unsigned endCurByte = 0;
+  UInt32 endPos = 0; // 0 means no no additional passes
   if (numPasses > 1 && blockSize >= (1 << 10))
   {
-    UInt32 blockSize0 = blockSize / 2; // ????
-    
-    for (; (block[blockSize0] == block[(size_t)blockSize0 - 1]
-            || block[(size_t)blockSize0 - 1] == block[(size_t)blockSize0 - 2])
-          && blockSize0 < blockSize;
-        blockSize0++);
+    UInt32 bs0 = blockSize / 2;
+    for (; bs0 < blockSize &&
+           (block[        bs0    ] ==
+            block[(size_t)bs0 - 1] ||
+            block[(size_t)bs0 - 1] ==
+            block[(size_t)bs0 - 2]);
+      bs0++)
+    {}
     
-    if (blockSize0 < blockSize)
+    if (bs0 < blockSize)
     {
-      EncodeBlock2(block, blockSize0, numPasses - 1);
-      EncodeBlock2(block + blockSize0, blockSize - blockSize0, numPasses - 1);
-      endPos = m_OutStreamCurrent->GetPos();
-      endCurByte = m_OutStreamCurrent->GetCurByte();
-      if ((endPos & 7) > 0)
+      EncodeBlock2(block, bs0, numPasses - 1);
+      EncodeBlock2(block + bs0, blockSize - bs0, numPasses - 1);
+      endPos = m_OutStreamCurrent.GetPos();
+      endCurByte = m_OutStreamCurrent.GetCurByte();
+      // we prepare next byte as identical byte to starting byte for main encoding attempt:
+      if (endPos & 7)
         WriteBits2(0, 8 - (endPos & 7));
-      m_OutStreamCurrent->SetCurState((startPos & 7), startCurByte);
-      needCompare = true;
+      m_OutStreamCurrent.SetCurState((startPos & 7), startCurByte);
     }
   }
 
-  UInt32 startBytePos2 = m_OutStreamCurrent->GetBytePos();
-  UInt32 startPos2 = m_OutStreamCurrent->GetPos();
-  UInt32 crcVal = EncodeBlockWithHeaders(block, blockSize);
-  UInt32 endPos2 = m_OutStreamCurrent->GetPos();
+  const UInt32 startBytePos2 = m_OutStreamCurrent.GetBytePos();
+  const UInt32 startPos2 = m_OutStreamCurrent.GetPos();
+  const UInt32 crcVal = EncodeBlockWithHeaders(block, blockSize);
 
-  if (needCompare)
+  if (endPos)
   {
-    UInt32 size2 = endPos2 - startPos2;
-    if (size2 < endPos - startPos)
-    {
-      UInt32 numBytes = m_OutStreamCurrent->GetBytePos() - startBytePos2;
-      Byte *buffer = m_OutStreamCurrent->GetStream();
-      for (UInt32 i = 0; i < numBytes; i++)
-        buffer[startBytePos + i] = buffer[startBytePos2 + i];
-      m_OutStreamCurrent->SetPos(startPos + endPos2 - startPos2);
-      m_NumCrcs = numCrcs;
-      m_CRCs[m_NumCrcs++] = crcVal;
-    }
-    else
+    const UInt32 size2 = m_OutStreamCurrent.GetPos() - startPos2;
+    if (size2 >= endPos - startPos)
     {
-      m_OutStreamCurrent->SetPos(endPos);
-      m_OutStreamCurrent->SetCurState((endPos & 7), endCurByte);
+      m_OutStreamCurrent.SetPos(endPos);
+      m_OutStreamCurrent.SetCurState((endPos & 7), endCurByte);
+      return;
     }
+    const UInt32 numBytes = m_OutStreamCurrent.GetBytePos() - startBytePos2;
+    Byte * const buffer = m_OutStreamCurrent.GetStream();
+    memmove(buffer + startBytePos, buffer + startBytePos2, numBytes);
+    m_OutStreamCurrent.SetPos(startPos + size2);
+    // we don't call m_OutStreamCurrent.SetCurState() here because
+    // m_OutStreamCurrent._curByte is correct already
   }
-  else
-  {
-    m_NumCrcs = numCrcs;
-    m_CRCs[m_NumCrcs++] = crcVal;
-  }
+  m_CRCs[numCrcs] = crcVal;
+  m_NumCrcs = numCrcs + 1;
 }
 
+
 HRESULT CThreadInfo::EncodeBlock3(UInt32 blockSize)
 {
-  CMsbfEncoderTemp outStreamTemp;
+  CMsbfEncoderTemp &outStreamTemp = m_OutStreamCurrent;
   outStreamTemp.SetStream(m_TempArray);
   outStreamTemp.Init();
-  m_OutStreamCurrent = &outStreamTemp;
-
   m_NumCrcs = 0;
 
   EncodeBlock2(m_Block, blockSize, Encoder->_props.NumPasses);
 
-  #ifndef Z7_ST
+#ifndef Z7_ST
   if (Encoder->MtMode)
     Encoder->ThreadsInfo[m_BlockIndex].CanWriteEvent.Lock();
-  #endif
+#endif
+
   for (UInt32 i = 0; i < m_NumCrcs; i++)
     Encoder->CombinedCrc.Update(m_CRCs[i]);
-  Encoder->WriteBytes(m_TempArray, outStreamTemp.GetPos(), outStreamTemp.GetCurByte());
+  Encoder->WriteBytes(m_TempArray, outStreamTemp.GetPos(), outStreamTemp.GetNonFlushedByteBits());
   HRESULT res = S_OK;
-  #ifndef Z7_ST
+
+#ifndef Z7_ST
   if (Encoder->MtMode)
   {
     UInt32 blockIndex = m_BlockIndex + 1;
     if (blockIndex == Encoder->NumThreads)
       blockIndex = 0;
-
     if (Encoder->Progress)
     {
       const UInt64 packSize = Encoder->m_OutStream.GetProcessedSize();
       res = Encoder->Progress->SetRatioInfo(&m_UnpackSize, &packSize);
     }
-
     Encoder->ThreadsInfo[blockIndex].CanWriteEvent.Set();
   }
-  #endif
+#endif
   return res;
 }
 
-void CEncoder::WriteBytes(const Byte *data, UInt32 sizeInBits, Byte lastByte)
+void CEncoder::WriteBytes(const Byte *data, UInt32 sizeInBits, unsigned lastByteBits)
 {
-  UInt32 bytesSize = (sizeInBits >> 3);
-  for (UInt32 i = 0; i < bytesSize; i++)
-    m_OutStream.WriteBits(data[i], 8);
-  WriteBits(lastByte, (sizeInBits & 7));
+  m_OutStream.WriteBytes(data, sizeInBits >> 3);
+  sizeInBits &= 7;
+  if (sizeInBits)
+    m_OutStream.WriteBits(lastByteBits, sizeInBits);
 }
 
 
@@ -746,11 +932,12 @@ HRESULT CEncoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
     const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
 {
   NumBlocks = 0;
-  #ifndef Z7_ST
+#ifndef Z7_ST
   Progress = progress;
+  ThreadNextGroup_Init(&ThreadNextGroup, _props.NumThreadGroups, 0); // startGroup
   RINOK(Create())
   for (UInt32 t = 0; t < NumThreads; t++)
-  #endif
+#endif
   {
     #ifndef Z7_ST
     CThreadInfo &ti = ThreadsInfo[t];
@@ -823,11 +1010,11 @@ HRESULT CEncoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
     {
       CThreadInfo &ti =
       #ifndef Z7_ST
-      ThreadsInfo[0];
+          ThreadsInfo[0];
       #else
-      ThreadsInfo;
+          ThreadsInfo;
       #endif
-      UInt32 blockSize = ReadRleBlock(ti.m_Block);
+      const UInt32 blockSize = ReadRleBlock(ti.m_Block);
       if (blockSize == 0)
         break;
       RINOK(ti.EncodeBlock3(blockSize))
@@ -845,8 +1032,11 @@ HRESULT CEncoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   WriteByte(kFinSig3);
   WriteByte(kFinSig4);
   WriteByte(kFinSig5);
-
-  WriteCrc(CombinedCrc.GetDigest());
+  {
+    const UInt32 v = CombinedCrc.GetDigest();
+    for (int i = 24; i >= 0; i -= 8)
+      WriteByte((Byte)(v >> i));
+  }
   RINOK(Flush())
   if (!m_InStream.WasFinished())
     return E_FAIL;
@@ -869,14 +1059,21 @@ Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIA
   for (UInt32 i = 0; i < numProps; i++)
   {
     const PROPVARIANT &prop = coderProps[i];
-    PROPID propID = propIDs[i];
+    const PROPID propID = propIDs[i];
 
     if (propID == NCoderPropID::kAffinity)
     {
-      if (prop.vt == VT_UI8)
-        props.Affinity = prop.uhVal.QuadPart;
-      else
+      if (prop.vt != VT_UI8)
+        return E_INVALIDARG;
+      props.Affinity = prop.uhVal.QuadPart;
+      continue;
+    }
+
+    if (propID == NCoderPropID::kNumThreadGroups)
+    {
+      if (prop.vt != VT_UI4)
         return E_INVALIDARG;
+      props.NumThreadGroups = (UInt32)prop.ulVal;
       continue;
     }
 
@@ -884,7 +1081,7 @@ Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIA
       continue;
     if (prop.vt != VT_UI4)
       return E_INVALIDARG;
-    UInt32 v = (UInt32)prop.ulVal;
+    const UInt32 v = (UInt32)prop.ulVal;
     switch (propID)
     {
       case NCoderPropID::kNumPasses: props.NumPasses = v; break;
diff --git a/CPP/7zip/Compress/BZip2Encoder.h b/CPP/7zip/Compress/BZip2Encoder.h
index 4a04fbd..bcb4025 100644
--- a/CPP/7zip/Compress/BZip2Encoder.h
+++ b/CPP/7zip/Compress/BZip2Encoder.h
@@ -3,7 +3,6 @@
 #ifndef ZIP7_INC_COMPRESS_BZIP2_ENCODER_H
 #define ZIP7_INC_COMPRESS_BZIP2_ENCODER_H
 
-#include "../../Common/Defs.h"
 #include "../../Common/MyCom.h"
 
 #ifndef Z7_ST
@@ -23,80 +22,114 @@
 namespace NCompress {
 namespace NBZip2 {
 
-class CMsbfEncoderTemp
+const unsigned kNumPassesMax = 10;
+
+struct CMsbfEncoderTemp
 {
-  UInt32 _pos;
-  unsigned _bitPos;
-  Byte _curByte;
+  unsigned _bitPos;  // 0 < _bitPos <= 8 : number of non-filled low bits in _curByte
+  unsigned _curByte; // low (_bitPos) bits are zeros
+                     // high (8 - _bitPos) bits are filled
   Byte *_buf;
-public:
-  void SetStream(Byte *buf) { _buf = buf;  }
-  Byte *GetStream() const { return _buf; }
+  Byte *_buf_base;
+  void SetStream(Byte *buf) { _buf_base = _buf = buf;  }
+  Byte *GetStream() const { return _buf_base; }
 
   void Init()
   {
-    _pos = 0;
     _bitPos = 8;
     _curByte = 0;
+    _buf = _buf_base;
   }
 
-  void Flush()
-  {
-    if (_bitPos < 8)
-      WriteBits(0, _bitPos);
-  }
-
+  // required condition: (value >> numBits) == 0
+  // numBits == 0 is allowed
   void WriteBits(UInt32 value, unsigned numBits)
   {
-    while (numBits > 0)
+    do
     {
-      unsigned numNewBits = MyMin(numBits, _bitPos);
-      numBits -= numNewBits;
-      
-      _curByte = (Byte)(_curByte << numNewBits);
-      UInt32 newBits = value >> numBits;
-      _curByte |= Byte(newBits);
-      value -= (newBits << numBits);
-      
-      _bitPos -= numNewBits;
-      
-      if (_bitPos == 0)
+      unsigned bp = _bitPos;
+      unsigned curByte = _curByte;
+      if (numBits < bp)
       {
-       _buf[_pos++] = _curByte;
-        _bitPos = 8;
+        bp -= numBits;
+        _curByte = curByte | (value << bp);
+        _bitPos = bp;
+        return;
       }
+      numBits -= bp;
+      const UInt32 hi = value >> numBits;
+      value -= (hi << numBits);
+      Byte *buf = _buf;
+      _bitPos = 8;
+      _curByte = 0;
+      *buf++ = (Byte)(curByte | hi);
+      _buf = buf;
     }
+    while (numBits);
   }
-  
-  UInt32 GetBytePos() const { return _pos ; }
-  UInt32 GetPos() const { return _pos * 8 + (8 - _bitPos); }
-  Byte GetCurByte() const { return _curByte; }
+
+  void WriteBit(unsigned value)
+  {
+    const unsigned bp = _bitPos - 1;
+    const unsigned curByte = _curByte | (value << bp);
+    _curByte = curByte;
+    _bitPos = bp;
+    if (bp == 0)
+    {
+      *_buf++ = (Byte)curByte;
+      _curByte = 0;
+      _bitPos = 8;
+    }
+  }
+
+  void WriteByte(unsigned b)
+  {
+    const unsigned bp = _bitPos;
+    const unsigned a = _curByte | (b >> (8 - bp));
+    _curByte = b << bp;
+    Byte *buf = _buf;
+    *buf++ = (Byte)a;
+    _buf = buf;
+  }
+
+  UInt32 GetBytePos() const { return (UInt32)(size_t)(_buf - _buf_base); }
+  UInt32 GetPos() const { return GetBytePos() * 8 + 8 - _bitPos; }
+  unsigned GetCurByte() const { return _curByte; }
+  unsigned GetNonFlushedByteBits() const { return _curByte >> _bitPos; }
   void SetPos(UInt32 bitPos)
   {
-    _pos = bitPos >> 3;
+    _buf = _buf_base + (bitPos >> 3);
     _bitPos = 8 - ((unsigned)bitPos & 7);
   }
-  void SetCurState(unsigned bitPos, Byte curByte)
+  void SetCurState(unsigned bitPos, unsigned curByte)
   {
     _bitPos = 8 - bitPos;
     _curByte = curByte;
   }
 };
 
-class CEncoder;
 
-const unsigned kNumPassesMax = 10;
+class CEncoder;
 
 class CThreadInfo
 {
+private:
+  CMsbfEncoderTemp m_OutStreamCurrent;
 public:
+  CEncoder *Encoder;
   Byte *m_Block;
 private:
   Byte *m_MtfArray;
   Byte *m_TempArray;
   UInt32 *m_BlockSorterIndex;
 
-  CMsbfEncoderTemp *m_OutStreamCurrent;
+public:
+  bool m_OptimizeNumTables;
+  UInt32 m_NumCrcs;
+  UInt32 m_BlockIndex;
+  UInt64 m_UnpackSize;
+
+  Byte *m_Block_Base;
 
   Byte Lens[kNumTablesMax][kMaxAlphaSize];
   UInt32 Freqs[kNumTablesMax][kMaxAlphaSize];
@@ -105,20 +138,16 @@ private:
   Byte m_Selectors[kNumSelectorsMax];
 
   UInt32 m_CRCs[1 << kNumPassesMax];
-  UInt32 m_NumCrcs;
 
   void WriteBits2(UInt32 value, unsigned numBits);
-  void WriteByte2(Byte b);
-  void WriteBit2(Byte v);
-  void WriteCrc2(UInt32 v);
+  void WriteByte2(unsigned b) { WriteBits2(b, 8); }
+  void WriteBit2(unsigned v)  { m_OutStreamCurrent.WriteBit(v); }
 
   void EncodeBlock(const Byte *block, UInt32 blockSize);
   UInt32 EncodeBlockWithHeaders(const Byte *block, UInt32 blockSize);
   void EncodeBlock2(const Byte *block, UInt32 blockSize, UInt32 numPasses);
 public:
-  bool m_OptimizeNumTables;
-  CEncoder *Encoder;
- #ifndef Z7_ST
+#ifndef Z7_ST
   NWindows::CThread Thread;
 
   NWindows::NSynchronization::CAutoResetEvent StreamWasFinishedEvent;
@@ -127,17 +156,14 @@ public:
   // it's not member of this thread. We just need one event per thread
   NWindows::NSynchronization::CAutoResetEvent CanWriteEvent;
 
-private:
-  UInt32 m_BlockIndex;
-  UInt64 m_UnpackSize;
 public:
   Byte MtPad[1 << 8]; // It's pad for Multi-Threading. Must be >= Cache_Line_Size.
   HRESULT Create();
   void FinishStream(bool needLeave);
   THREAD_FUNC_RET_TYPE ThreadFunc();
- #endif
+#endif
 
-  CThreadInfo(): m_Block(NULL), m_BlockSorterIndex(NULL)  {}
+  CThreadInfo(): m_BlockSorterIndex(NULL), m_Block_Base(NULL) {}
   ~CThreadInfo() { Free(); }
   bool Alloc();
   void Free();
@@ -145,16 +171,19 @@ public:
   HRESULT EncodeBlock3(UInt32 blockSize);
 };
 
+
 struct CEncProps
 {
   UInt32 BlockSizeMult;
   UInt32 NumPasses;
+  UInt32 NumThreadGroups;
   UInt64 Affinity;
   
   CEncProps()
   {
     BlockSizeMult = (UInt32)(Int32)-1;
     NumPasses = (UInt32)(Int32)-1;
+    NumThreadGroups = 0;
     Affinity = 0;
   }
   void Normalize(int level);
@@ -206,6 +235,7 @@ public:
   bool CloseThreads;
   bool StreamWasFinished;
   NWindows::NSynchronization::CManualResetEvent CanStartWaitingEvent;
+  CThreadNextGroup ThreadNextGroup;
 
   HRESULT Result;
   ICompressProgressInfo *Progress;
@@ -218,12 +248,8 @@ public:
   UInt64 GetInProcessedSize() const { return m_InStream.GetProcessedSize(); }
 
   UInt32 ReadRleBlock(Byte *buf);
-  void WriteBytes(const Byte *data, UInt32 sizeInBits, Byte lastByte);
-
-  void WriteBits(UInt32 value, unsigned numBits);
+  void WriteBytes(const Byte *data, UInt32 sizeInBits, unsigned lastByteBits);
   void WriteByte(Byte b);
-  // void WriteBit(Byte v);
-  void WriteCrc(UInt32 v);
 
  #ifndef Z7_ST
   HRESULT Create();
diff --git a/CPP/7zip/Compress/BitlEncoder.h b/CPP/7zip/Compress/BitlEncoder.h
index 67b1428..364f84d 100644
--- a/CPP/7zip/Compress/BitlEncoder.h
+++ b/CPP/7zip/Compress/BitlEncoder.h
@@ -33,6 +33,7 @@ public:
     _bitPos = 8;
     _curByte = 0;
   }
+  Z7_FORCE_INLINE
   void WriteBits(UInt32 value, unsigned numBits)
   {
     while (numBits > 0)
diff --git a/CPP/7zip/Compress/BitmEncoder.h b/CPP/7zip/Compress/BitmEncoder.h
index 978ee1c..f7448cd 100644
--- a/CPP/7zip/Compress/BitmEncoder.h
+++ b/CPP/7zip/Compress/BitmEncoder.h
@@ -8,8 +8,9 @@
 template<class TOutByte>
 class CBitmEncoder
 {
-  unsigned _bitPos;
-  Byte _curByte;
+  unsigned _bitPos;  // 0 < _bitPos <= 8 : number of non-filled low bits in _curByte
+  unsigned _curByte; // low (_bitPos) bits are zeros
+                     // high (8 - _bitPos) bits are filled
   TOutByte _stream;
 public:
   bool Create(UInt32 bufferSize) { return _stream.Create(bufferSize); }
@@ -24,25 +25,65 @@ public:
   HRESULT Flush()
   {
     if (_bitPos < 8)
-      WriteBits(0, _bitPos);
+    {
+      _stream.WriteByte((Byte)_curByte);
+      _bitPos = 8;
+      _curByte = 0;
+    }
     return _stream.Flush();
   }
+
+  // required condition: (value >> numBits) == 0
+  // numBits == 0 is allowed
   void WriteBits(UInt32 value, unsigned numBits)
   {
-    while (numBits > 0)
+    do
     {
-      if (numBits < _bitPos)
+      unsigned bp = _bitPos;
+      unsigned curByte = _curByte;
+      if (numBits < bp)
       {
-        _curByte = (Byte)(_curByte | (value << (_bitPos -= numBits)));
+        bp -= numBits;
+        _curByte = curByte | (value << bp);
+        _bitPos = bp;
         return;
       }
-      numBits -= _bitPos;
-      UInt32 newBits = (value >> numBits);
-      value -= (newBits << numBits);
-      _stream.WriteByte((Byte)(_curByte | newBits));
+      numBits -= bp;
+      const UInt32 hi = (value >> numBits);
+      value -= (hi << numBits);
+      _stream.WriteByte((Byte)(curByte | hi));
       _bitPos = 8;
       _curByte = 0;
     }
+    while (numBits);
+  }
+  void WriteByte(unsigned b)
+  {
+    const unsigned bp = _bitPos;
+    const unsigned a = _curByte | (b >> (8 - bp));
+    _curByte = b << bp;
+   _stream.WriteByte((Byte)a);
+  }
+
+  void WriteBytes(const Byte *data, size_t num)
+  {
+    const unsigned bp = _bitPos;
+#if 1 // 1 for optional speed-optimized code branch
+    if (bp == 8)
+    {
+      _stream.WriteBytes(data, num);
+      return;
+    }
+#endif
+    unsigned c = _curByte;
+    const unsigned bp_rev = 8 - bp;
+    for (size_t i = 0; i < num; i++)
+    {
+      const unsigned b = data[i];
+      _stream.WriteByte((Byte)(c | (b >> bp_rev)));
+      c = b << bp;
+    }
+    _curByte = c;
   }
 };
 
diff --git a/CPP/7zip/Compress/DeflateDecoder.cpp b/CPP/7zip/Compress/DeflateDecoder.cpp
index 73895fe..7993176 100644
--- a/CPP/7zip/Compress/DeflateDecoder.cpp
+++ b/CPP/7zip/Compress/DeflateDecoder.cpp
@@ -117,15 +117,13 @@ bool CCoder::ReadTables(void)
       if (_numDistLevels > kDistTableSize32)
         return false;
     
-    Byte levelLevels[kLevelTableSize];
-    for (unsigned i = 0; i < kLevelTableSize; i++)
-    {
-      const unsigned position = kCodeLengthAlphabetOrder[i];
-      if (i < numLevelCodes)
-        levelLevels[position] = (Byte)ReadBits(kLevelFieldSize);
-      else
-        levelLevels[position] = 0;
-    }
+    const unsigned kLevelTableSize_aligned4 = kLevelTableSize + 1;
+    Byte levelLevels[kLevelTableSize_aligned4];
+    memset (levelLevels, 0, sizeof(levelLevels));
+    unsigned i = 0;
+    do
+      levelLevels[kCodeLengthAlphabetOrder[i++]] = (Byte)ReadBits(kLevelFieldSize);
+    while (i != numLevelCodes);
     
     if (m_InBitStream.ExtraBitsWereRead())
       return false;
diff --git a/CPP/7zip/Compress/DeflateEncoder.cpp b/CPP/7zip/Compress/DeflateEncoder.cpp
index 87b4f83..afc5f12 100644
--- a/CPP/7zip/Compress/DeflateEncoder.cpp
+++ b/CPP/7zip/Compress/DeflateEncoder.cpp
@@ -19,12 +19,16 @@
 #define NO_INLINE
 #endif
 
+#define MAX_HUF_LEN_12  12
+
 namespace NCompress {
 namespace NDeflate {
 namespace NEncoder {
 
+static const unsigned k_CodeValue_Len_Is_Literal_Flag = 1u << 15;
+
 static const unsigned kNumDivPassesMax = 10; // [0, 16); ratio/speed/ram tradeoff; use big value for better compression ratio.
-static const UInt32 kNumTables = (1 << kNumDivPassesMax);
+static const unsigned kNumTables = 1u << kNumDivPassesMax;
 
 static const UInt32 kFixedHuffmanCodeBlockSizeMax = (1 << 8); // [0, (1 << 32)); ratio/speed tradeoff; use big value for better compression ratio.
 static const UInt32 kDivideCodeBlockSizeMin = (1 << 7); // [1, (1 << 32)); ratio/speed tradeoff; use small value for better compression ratio.
@@ -77,7 +81,7 @@ public:
 
 static CFastPosInit g_FastPosInit;
 
-inline UInt32 GetPosSlot(UInt32 pos)
+inline unsigned GetPosSlot(UInt32 pos)
 {
   /*
   if (pos < 0x200)
@@ -162,13 +166,13 @@ HRESULT CCoder::Create()
   // COM_TRY_BEGIN
   if (!m_Values)
   {
-    m_Values = (CCodeValue *)MyAlloc((kMaxUncompressedBlockSize) * sizeof(CCodeValue));
+    m_Values = (CCodeValue *)MyAlloc(kMaxUncompressedBlockSize * sizeof(CCodeValue));
     if (!m_Values)
       return E_OUTOFMEMORY;
   }
   if (!m_Tables)
   {
-    m_Tables = (CTables *)MyAlloc((kNumTables) * sizeof(CTables));
+    m_Tables = (CTables *)MyAlloc(kNumTables * sizeof(CTables));
     if (!m_Tables)
       return E_OUTOFMEMORY;
   }
@@ -268,19 +272,21 @@ NO_INLINE void CCoder::GetMatches()
 
   UInt32 distanceTmp[kMatchMaxLen * 2 + 3];
   
-  const UInt32 numPairs = (UInt32)((_btMode ?
+  const size_t numPairs = (size_t)((_btMode ?
       Bt3Zip_MatchFinder_GetMatches(&_lzInWindow, distanceTmp):
       Hc3Zip_MatchFinder_GetMatches(&_lzInWindow, distanceTmp)) - distanceTmp);
 
-  *m_MatchDistances = (UInt16)numPairs;
+  UInt16 *matchDistances = m_MatchDistances;
+  *matchDistances++ = (UInt16)numPairs;
    
   if (numPairs != 0)
   {
-    UInt32 i;
+    size_t i;
     for (i = 0; i < numPairs; i += 2)
     {
-      m_MatchDistances[(size_t)i + 1] = (UInt16)distanceTmp[i];
-      m_MatchDistances[(size_t)i + 2] = (UInt16)distanceTmp[(size_t)i + 1];
+      matchDistances[0] = (UInt16)distanceTmp[i];
+      matchDistances[1] = (UInt16)distanceTmp[(size_t)i + 1];
+      matchDistances += 2;
     }
     UInt32 len = distanceTmp[(size_t)numPairs - 2];
     if (len == m_NumFastBytes && m_NumFastBytes != m_MatchMaxLen)
@@ -291,11 +297,11 @@ NO_INLINE void CCoder::GetMatches()
       if (numAvail > m_MatchMaxLen)
         numAvail = m_MatchMaxLen;
       for (; len < numAvail && pby[len] == pby2[len]; len++);
-      m_MatchDistances[(size_t)i - 1] = (UInt16)len;
+      matchDistances[-2] = (UInt16)len;
     }
   }
   if (m_IsMultiPass)
-    m_Pos += numPairs + 1;
+    m_Pos += (UInt32)numPairs + 1;
   if (!m_SecondPass)
     m_AdditionalOffset++;
 }
@@ -535,6 +541,7 @@ NO_INLINE void CCoder::WriteBits(UInt32 value, unsigned numBits)
 }
 
 #define WRITE_HF2(codes, lens, i) m_OutStream.WriteBits(codes[i], lens[i])
+#define WRITE_HF2_NO_INLINE(codes, lens, i)   WriteBits(codes[i], lens[i])
 #define WRITE_HF(i) WriteBits(codes[i], lens[i])
 
 NO_INLINE void CCoder::LevelTableCode(const Byte *levels, unsigned numLevels, const Byte *lens, const UInt32 *codes)
@@ -619,17 +626,22 @@ static NO_INLINE UInt32 Huffman_GetPrice(const UInt32 *freqs, const Byte *lens,
   return price;
 }
 
-static NO_INLINE UInt32 Huffman_GetPrice_Spec(const UInt32 *freqs, const Byte *lens, UInt32 num, const Byte *extraBits, UInt32 extraBase)
+static NO_INLINE UInt32 Huffman_GetPrice_Spec(
+    const UInt32 *freqs, const Byte *lens, UInt32 num,
+    const Byte *extraBits, UInt32 extraBase)
 {
-  return Huffman_GetPrice(freqs, lens, num) +
+  return
+    Huffman_GetPrice(freqs, lens, num) +
     Huffman_GetPrice(freqs + extraBase, extraBits, num - extraBase);
 }
 
 NO_INLINE UInt32 CCoder::GetLzBlockPrice() const
 {
   return
-    Huffman_GetPrice_Spec(mainFreqs, m_NewLevels.litLenLevels, kFixedMainTableSize, m_LenDirectBits, kSymbolMatch) +
-    Huffman_GetPrice_Spec(distFreqs, m_NewLevels.distLevels, kDistTableSize64, kDistDirectBits, 0);
+    Huffman_GetPrice_Spec(mainFreqs, m_NewLevels.litLenLevels,
+        kFixedMainTableSize, m_LenDirectBits, kSymbolMatch) +
+    Huffman_GetPrice_Spec(distFreqs, m_NewLevels.distLevels,
+        kDistTableSize64, kDistDirectBits, 0);
 }
 
 NO_INLINE void CCoder::TryBlock()
@@ -658,7 +670,7 @@ NO_INLINE void CCoder::TryBlock()
     CCodeValue &codeValue = m_Values[m_ValueIndex++];
     if (len >= kMatchMinLen)
     {
-      UInt32 newLen = len - kMatchMinLen;
+      const UInt32 newLen = len - kMatchMinLen;
       codeValue.Len = (UInt16)newLen;
       mainFreqs[kSymbolMatch + (size_t)g_LenSlots[newLen]]++;
       codeValue.Pos = (UInt16)pos;
@@ -666,10 +678,10 @@ NO_INLINE void CCoder::TryBlock()
     }
     else
     {
-      Byte b = *(Inline_MatchFinder_GetPointerToCurrentPos(&_lzInWindow) - m_AdditionalOffset);
+      const unsigned b = *(Inline_MatchFinder_GetPointerToCurrentPos(&_lzInWindow) - m_AdditionalOffset);
       mainFreqs[b]++;
-      codeValue.SetAsLiteral();
-      codeValue.Pos = b;
+      codeValue.Len = k_CodeValue_Len_Is_Literal_Flag;
+      codeValue.Pos = (UInt16)b;
     }
     m_AdditionalOffset -= len;
     BlockSizeRes += len;
@@ -704,16 +716,24 @@ NO_INLINE void CCoder::SetPrices(const CLevels &levels)
   }
 }
 
+#if MAX_HUF_LEN_12 > 12
+// Huffman_ReverseBits() now supports 12-bits values only.
+#error Stop_Compiling_Bad_MAX_HUF_LEN_12
+#endif
 static NO_INLINE void Huffman_ReverseBits(UInt32 *codes, const Byte *lens, UInt32 num)
 {
-  for (UInt32 i = 0; i < num; i++)
+  const Byte * const lens_lim = lens + num;
+  do
   {
-    UInt32 x = codes[i];
-    x = ((x & 0x5555) << 1) | ((x & 0xAAAA) >> 1);
-    x = ((x & 0x3333) << 2) | ((x & 0xCCCC) >> 2);
-    x = ((x & 0x0F0F) << 4) | ((x & 0xF0F0) >> 4);
-    codes[i] = (((x & 0x00FF) << 8) | ((x & 0xFF00) >> 8)) >> (16 - lens[i]);
+    // we should change constants, if lens[*] can be larger than 12.
+    UInt32 x = *codes;
+    x = ((x & (0x555     )) << 2) + (x & (0xAAA     ));
+    x = ((x & (0x333 << 1)) << 4) | (x & (0xCCC << 1));
+    x = ((x & (0xF0F << 3)) << 8) | (x & (0x0F0 << 3));
+    // we can use (x) instead of (x & (0xFF << 7)), if we support garabage data after (*lens) bits.
+    *codes++ = (((x & (0xFF << 7)) << 16) | x) >> (*lens ^ 31);
   }
+  while (++lens != lens_lim);
 }
 
 NO_INLINE void CCoder::WriteBlock()
@@ -721,24 +741,28 @@ NO_INLINE void CCoder::WriteBlock()
   Huffman_ReverseBits(mainCodes, m_NewLevels.litLenLevels, kFixedMainTableSize);
   Huffman_ReverseBits(distCodes, m_NewLevels.distLevels, kDistTableSize64);
 
-  for (UInt32 i = 0; i < m_ValueIndex; i++)
+  CCodeValue *values = m_Values;
+  const CCodeValue * const values_lim = values + m_ValueIndex;
+
+  if (values != values_lim)
+  do
   {
-    const CCodeValue &codeValue = m_Values[i];
-    if (codeValue.IsLiteral())
-      WRITE_HF2(mainCodes, m_NewLevels.litLenLevels, codeValue.Pos);
+    const UInt32 len = values->Len;
+    const UInt32 dist = values->Pos;
+    if (len == k_CodeValue_Len_Is_Literal_Flag)
+      WRITE_HF2(mainCodes, m_NewLevels.litLenLevels, dist);
     else
     {
-      UInt32 len = codeValue.Len;
-      UInt32 lenSlot = g_LenSlots[len];
+      const unsigned lenSlot = g_LenSlots[len];
       WRITE_HF2(mainCodes, m_NewLevels.litLenLevels, kSymbolMatch + lenSlot);
       m_OutStream.WriteBits(len - m_LenStart[lenSlot], m_LenDirectBits[lenSlot]);
-      UInt32 dist = codeValue.Pos;
-      UInt32 posSlot = GetPosSlot(dist);
+      const unsigned posSlot = GetPosSlot(dist);
       WRITE_HF2(distCodes, m_NewLevels.distLevels, posSlot);
       m_OutStream.WriteBits(dist - kDistStart[posSlot], kDistDirectBits[posSlot]);
     }
   }
-  WRITE_HF2(mainCodes, m_NewLevels.litLenLevels, kSymbolEndOfBlock);
+  while (++values != values_lim);
+  WRITE_HF2_NO_INLINE(mainCodes, m_NewLevels.litLenLevels, kSymbolEndOfBlock);
 }
 
 static UInt32 GetStorePrice(UInt32 blockSize, unsigned bitPosition)
@@ -787,10 +811,10 @@ NO_INLINE UInt32 CCoder::TryDynBlock(unsigned tableIndex, UInt32 numPasses)
   {
     m_Pos = posTemp;
     TryBlock();
-    unsigned numHuffBits =
-        (m_ValueIndex > 18000 ? 12 :
-        (m_ValueIndex >  7000 ? 11 :
-        (m_ValueIndex >  2000 ? 10 : 9)));
+    const unsigned numHuffBits =
+        m_ValueIndex > 18000 ? MAX_HUF_LEN_12 :
+        m_ValueIndex >  7000 ? 11 :
+        m_ValueIndex >  2000 ? 10 : 9;
     MakeTables(numHuffBits);
     SetPrices(m_NewLevels);
   }
diff --git a/CPP/7zip/Compress/Lzma2Encoder.cpp b/CPP/7zip/Compress/Lzma2Encoder.cpp
index 0dc7e23..ffe1152 100644
--- a/CPP/7zip/Compress/Lzma2Encoder.cpp
+++ b/CPP/7zip/Compress/Lzma2Encoder.cpp
@@ -52,7 +52,15 @@ HRESULT SetLzma2Prop(PROPID propID, const PROPVARIANT &prop, CLzma2EncProps &lzm
     case NCoderPropID::kNumThreads:
       if (prop.vt != VT_UI4)
         return E_INVALIDARG;
-      lzma2Props.numTotalThreads = (int)(prop.ulVal);
+      lzma2Props.numTotalThreads = (int)prop.ulVal;
+      break;
+    case NCoderPropID::kNumThreadGroups:
+      if (prop.vt != VT_UI4)
+        return E_INVALIDARG;
+      // 16-bit value supported by Windows
+      if (prop.ulVal >= (1u << 16))
+        return E_INVALIDARG;
+      lzma2Props.numThreadGroups = (unsigned)prop.ulVal;
       break;
     default:
       RINOK(NLzma::SetLzmaProp(propID, prop, lzma2Props.lzmaProps))
diff --git a/CPP/7zip/Compress/LzmaEncoder.cpp b/CPP/7zip/Compress/LzmaEncoder.cpp
index 08e3ba5..bca2eee 100644
--- a/CPP/7zip/Compress/LzmaEncoder.cpp
+++ b/CPP/7zip/Compress/LzmaEncoder.cpp
@@ -101,6 +101,24 @@ HRESULT SetLzmaProp(PROPID propID, const PROPVARIANT &prop, CLzmaEncProps &ep)
     return S_OK;
   }
 
+  if (propID == NCoderPropID::kAffinityInGroup)
+  {
+    if (prop.vt == VT_UI8)
+      ep.affinityInGroup = prop.uhVal.QuadPart;
+    else
+      return E_INVALIDARG;
+    return S_OK;
+  }
+
+  if (propID == NCoderPropID::kThreadGroup)
+  {
+    if (prop.vt == VT_UI4)
+      ep.affinityGroup = (Int32)(UInt32)prop.ulVal;
+    else
+      return E_INVALIDARG;
+    return S_OK;
+  }
+
   if (propID == NCoderPropID::kHashBits)
   {
     if (prop.vt == VT_UI4)
diff --git a/CPP/7zip/Compress/Mtf8.h b/CPP/7zip/Compress/Mtf8.h
index 1b44d00..5fce30e 100644
--- a/CPP/7zip/Compress/Mtf8.h
+++ b/CPP/7zip/Compress/Mtf8.h
@@ -13,6 +13,18 @@ struct CMtf8Encoder
 
   unsigned FindAndMove(Byte v) throw()
   {
+#if 1
+    Byte b = Buf[0];
+    if (v == b)
+      return 0;
+    Buf[0] = v;
+    for (unsigned pos = 0;;)
+    {
+      Byte a;
+      a = Buf[++pos];  Buf[pos] = b;  if (v == a) return pos;
+      b = Buf[++pos];  Buf[pos] = a;  if (v == b) return pos;
+    }
+#else
     size_t pos;
     for (pos = 0; Buf[pos] != v; pos++);
     const unsigned resPos = (unsigned)pos;
@@ -31,6 +43,7 @@ struct CMtf8Encoder
       Buf[pos] = Buf[pos - 1];
     Buf[0] = v;
     return resPos;
+#endif
   }
 };
 
diff --git a/CPP/7zip/Compress/Rar5Decoder.cpp b/CPP/7zip/Compress/Rar5Decoder.cpp
index 8be24e2..7279b5a 100644
--- a/CPP/7zip/Compress/Rar5Decoder.cpp
+++ b/CPP/7zip/Compress/Rar5Decoder.cpp
@@ -936,31 +936,30 @@ HRESULT CDecoder::ExecuteFilter(const CFilter &f)
 HRESULT CDecoder::WriteBuf()
 {
   DeleteUnusedFilters();
-
   const UInt64 lzSize = _lzSize + _winPos;
 
   for (unsigned i = 0; i < _numFilters;)
   {
-    const CFilter &f = _filters[i];
-    const UInt64 blockStart = f.Start;
     const size_t lzAvail = (size_t)(lzSize - _lzWritten);
     if (lzAvail == 0)
       break;
-    
+    // (lzAvail != 0)
+    const CFilter &f = _filters[i];
+    const UInt64 blockStart = f.Start;
     if (blockStart > _lzWritten)
     {
       const UInt64 rem = blockStart - _lzWritten;
+      // (rem != 0)
       size_t size = lzAvail;
       if (size > rem)
         size = (size_t)rem;
-      if (size != 0) // is it true always ?
-      {
-        RINOK(WriteData(_window + _winPos - lzAvail, size))
-        _lzWritten += size;
-      }
+      // (size != 0)
+      RINOK(WriteData(_window + _winPos - lzAvail, size))
+      _lzWritten += size;
       continue;
     }
-    
+
+    // (blockStart <= _lzWritten)
     const UInt32 blockSize = f.Size;
     size_t offset = (size_t)(_lzWritten - blockStart);
     if (offset == 0)
@@ -987,10 +986,8 @@ HRESULT CDecoder::WriteBuf()
   }
       
   DeleteUnusedFilters();
-
   if (_numFilters)
     return S_OK;
-  
   const size_t lzAvail = (size_t)(lzSize - _lzWritten);
   RINOK(WriteData(_window + _winPos - lzAvail, lzAvail))
   _lzWritten += lzAvail;
@@ -1367,6 +1364,12 @@ enum enum_exit_type
   Z7_HUFF_DECODE_CHECK(sym, huf, kNumHufBits, kNumTableBits, bitStream, { LZ_LOOP_BREAK_ERROR })
 
 
+/*
+  DecodeLZ2() will stop decoding if it reaches limit when (_winPos >= _limit)
+  at return:
+    (_winPos < _limit + kMaxMatchLen)
+    also it can write up to (COPY_CHUNK_SIZE - 1) additional junk bytes after (_winPos).
+*/
 HRESULT CDecoder::DecodeLZ2(const CBitDecoder &bitStream) throw()
 {
 #if 0
@@ -1656,6 +1659,13 @@ decode_error:
 
 
 
+/*
+input conditions:
+  _winPos < _winSize
+return:
+  _winPos <  _winSize is expected, if (return_res == S_OK)
+  _winPos >= _winSize is possible in (return_res != S_OK)
+*/
 HRESULT CDecoder::DecodeLZ()
 {
   CBitDecoder _bitStream;
@@ -1679,6 +1689,8 @@ HRESULT CDecoder::DecodeLZ()
     if (winPos >= limit)
     {
       _winPos = winPos < _winSize ? winPos : _winSize;
+      // _winPos == min(winPos, _winSize)
+      // we will not write data after _winSize
       RINOK(WriteBuf())
       if (_unpackSize_Defined && _writtenFileSize > _unpackSize)
         break; // return S_FALSE;
@@ -1854,7 +1866,15 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
   {
     // if (_winPos > 100) _winPos -= 100; // for debug: corruption
     const UInt64 lzSize = _lzSize + _winPos;
-    if (!_isSolid || !_wasInit
+/*
+    if previous file was decoded with error or for some another cases, then
+        (lzSize > _lzEnd)    is possible
+        (_winPos > _winSize) is possible
+        (_winPos < _winSize + kMaxMatchLen)
+*/
+    if (!_window
+        || !_isSolid
+        || !_wasInit
         || (lzSize < _lzEnd
 #if Z7_RAR_RECOVER_SOLID_LIMIT != 0
          && lzSize + Z7_RAR_RECOVER_SOLID_LIMIT < _lzEnd
@@ -1863,9 +1883,9 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
     {
       if (_isSolid)
         _lzError = LZ_ERROR_TYPE_HEADER;
-      _lzEnd = 0;
       _lzSize = 0;
-      _lzWritten = 0;
+      // _lzEnd = 0;     // it will be set later
+      // _lzWritten = 0; // it will be set later
       _winPos = 0;
       for (unsigned i = 0; i < kNumReps; i++)
         _reps[i] = (size_t)0 - 1;
@@ -1873,51 +1893,67 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
       _tableWasFilled = false;
       _wasInit = true;
     }
-#if Z7_RAR_RECOVER_SOLID_LIMIT != 0
-    else if (lzSize < _lzEnd)
+    else
     {
+      const size_t ws = _winSize;
+      if (_winPos >= ws)
+      {
+        // we must normalize (_winPos) and data in _window,
+        _winPos -= ws;
+        _lzSize += ws;
+        // (_winPos < kMaxMatchLen < _winSize)
+        // if (_window)
+          memcpy(_window, _window + ws, _winPos); // memmove is not required here
+      }
+
+#if Z7_RAR_RECOVER_SOLID_LIMIT != 0
+      if (lzSize < _lzEnd)
+      {
 #if 0
-      return S_FALSE;
+        return S_FALSE;
 #else
-      // we can report that recovering was made:
-      // _lzError = LZ_ERROR_TYPE_HEADER;
-      // We write zeros to area after corruption:
-      if (_window)
-      {
-        UInt64 rem = _lzEnd - lzSize;
-        const size_t ws = _winSize;
-        if (rem >= ws)
+        // we can report that recovering was made:
+        // _lzError = LZ_ERROR_TYPE_HEADER;
+        // We write zeros to area after corruption:
+        // if (_window)
         {
-          My_ZeroMemory(_window, ws);
-          _lzSize = ws;
-          _winPos = 0;
-        }
-        else
-        {
-          const size_t cur = ws - _winPos;
-          if (cur <= rem)
+          UInt64 rem = _lzEnd - lzSize;
+          if (rem >= ws)
           {
-            rem -= cur;
-            My_ZeroMemory(_window + _winPos, cur);
-            _lzSize += _winPos;
+            My_ZeroMemory(_window, ws);
+            _lzSize = ws;
             _winPos = 0;
           }
-          My_ZeroMemory(_window + _winPos, (size_t)rem);
-          _winPos += (size_t)rem;
+          else
+          {
+            // rem < _winSize
+            // _winPos <= ws
+            const size_t cur = ws - _winPos;
+            if (cur <= rem)
+            {
+              rem -= cur;
+              My_ZeroMemory(_window + _winPos, cur);
+              _lzSize = ws;
+              _winPos = 0;
+            }
+            My_ZeroMemory(_window + _winPos, (size_t)rem);
+            _winPos += (size_t)rem;
+          }
         }
-      }
-      // else return S_FALSE;
+        // else return S_FALSE;
 #endif
+      }
     }
 #endif
   }
 
+  // _winPos < _winSize
   // we don't want _lzSize overflow
   if (_lzSize >= DICT_SIZE_MAX)
       _lzSize  = DICT_SIZE_MAX;
   _lzEnd = _lzSize + _winPos;
   // _lzSize <= DICT_SIZE_MAX
-  // _lzEnd  <= DICT_SIZE_MAX * 2
+  // _lzEnd  <  DICT_SIZE_MAX + _winSize
 
   size_t newSize = _dictSize;
   if (newSize < kWinSize_Min)
@@ -1941,10 +1977,11 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
       // If dictionary was increased in solid, we don't want grow.
       return S_FALSE; // E_OUTOFMEMORY
     }
-    // (newSize <= _winSize)
+    // (newSize <= _dictSize_forCheck)
   }
   else
   {
+    // !_isSolid || !_window
     _dictSize_forCheck = newSize;
     {
       size_t newSize_small = newSize;
@@ -1964,7 +2001,7 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
     if (!_window || allocSize > _winSize_Allocated)
     {
       Z7_RAR_FREE_WINDOW
-        _window = NULL;
+      _window = NULL;
       _winSize_Allocated = 0;
       Byte *win = (Byte *)::BigAlloc(allocSize);
       if (!win)
diff --git a/CPP/7zip/Crypto/MyAes.cpp b/CPP/7zip/Crypto/MyAes.cpp
index f84bca8..0ae0e16 100644
--- a/CPP/7zip/Crypto/MyAes.cpp
+++ b/CPP/7zip/Crypto/MyAes.cpp
@@ -153,7 +153,26 @@ Z7_COM7F_IMF2(UInt32, CAesCtrCoder::Filter(Byte *data, UInt32 size))
 #ifndef Z7_EXTRACT_ONLY
 
 #ifdef MY_CPU_X86_OR_AMD64
-  #define USE_HW_AES
+
+  #if defined(__INTEL_COMPILER)
+    #if (__INTEL_COMPILER >= 1110)
+      #define USE_HW_AES
+      #if (__INTEL_COMPILER >= 1900)
+        #define USE_HW_VAES
+      #endif
+    #endif
+  #elif defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 30800) \
+     || defined(Z7_GCC_VERSION)   && (Z7_GCC_VERSION   >= 40400)
+    #define USE_HW_AES
+      #if defined(__clang__) && (__clang_major__ >= 8) \
+          || defined(__GNUC__) && (__GNUC__ >= 8)
+        #define USE_HW_VAES
+      #endif
+  #elif defined(_MSC_VER)
+    #define USE_HW_AES
+    #define USE_HW_VAES
+  #endif
+
 #elif defined(MY_CPU_ARM_OR_ARM64) && defined(MY_CPU_LE)
   
   #if   defined(__ARM_FEATURE_AES) \
@@ -186,15 +205,15 @@ Z7_COM7F_IMF2(UInt32, CAesCtrCoder::Filter(Byte *data, UInt32 size))
     #define SET_AES_FUNC_2(f2) \
       if (algo == 2) if (g_Aes_SupportedFunctions_Flags & k_Aes_SupportedFunctions_HW) \
       { f = f2; }
-  #ifdef MY_CPU_X86_OR_AMD64
+  #ifdef USE_HW_VAES
     #define SET_AES_FUNC_23(f2, f3) \
       SET_AES_FUNC_2(f2) \
       if (algo == 3) if (g_Aes_SupportedFunctions_Flags & k_Aes_SupportedFunctions_HW_256) \
       { f = f3; }
-  #else  // MY_CPU_X86_OR_AMD64
+  #else  // USE_HW_VAES
     #define SET_AES_FUNC_23(f2, f3) \
       SET_AES_FUNC_2(f2)
-  #endif // MY_CPU_X86_OR_AMD64
+  #endif // USE_HW_VAES
 #else  // USE_HW_AES
     #define SET_AES_FUNC_23(f2, f3)
 #endif // USE_HW_AES
diff --git a/CPP/7zip/Crypto/Rar5Aes.cpp b/CPP/7zip/Crypto/Rar5Aes.cpp
index 26c6100..34ea4ff 100644
--- a/CPP/7zip/Crypto/Rar5Aes.cpp
+++ b/CPP/7zip/Crypto/Rar5Aes.cpp
@@ -8,16 +8,17 @@
 #include "../../Windows/Synchronization.h"
 #endif
 
-#include "Rar5Aes.h"
 #include "HmacSha256.h"
+#include "Rar5Aes.h"
+
+#define MY_ALIGN_FOR_SHA256  MY_ALIGN(16)
 
 namespace NCrypto {
 namespace NRar5 {
 
 static const unsigned kNumIterationsLog_Max = 24;
-
-static const unsigned kPswCheckCsumSize = 4;
-static const unsigned kCheckSize = kPswCheckSize + kPswCheckCsumSize;
+static const unsigned kPswCheckCsumSize32 = 1;
+static const unsigned kCheckSize32 = kPswCheckSize32 + kPswCheckCsumSize32;
 
 CKey::CKey():
     _needCalc(true),
@@ -27,15 +28,29 @@ CKey::CKey():
     _salt[i] = 0;
 }
 
+CKey::~CKey()
+{
+  Wipe();
+}
+
+void CKey::Wipe()
+{
+  _password.Wipe();
+  Z7_memset_0_ARRAY(_salt);
+  // Z7_memset_0_ARRAY(_key32);
+  // Z7_memset_0_ARRAY(_check_Calced32);
+  // Z7_memset_0_ARRAY(_hashKey32);
+  CKeyBase::Wipe();
+}
+
 CDecoder::CDecoder(): CAesCbcDecoder(kAesKeySize) {}
 
 static unsigned ReadVarInt(const Byte *p, unsigned maxSize, UInt64 *val)
 {
   *val = 0;
-
   for (unsigned i = 0; i < maxSize && i < 10;)
   {
-    Byte b = p[i];
+    const Byte b = p[i];
     *val |= (UInt64)(b & 0x7F) << (7 * i);
     i++;
     if ((b & 0x80) == 0)
@@ -64,7 +79,7 @@ HRESULT CDecoder::SetDecoderProps(const Byte *p, unsigned size, bool includeIV,
   size -= num;
 
   bool isCheck = IsThereCheck();
-  if (size != 1 + kSaltSize + (includeIV ? AES_BLOCK_SIZE : 0) + (unsigned)(isCheck ? kCheckSize : 0))
+  if (size != 1 + kSaltSize + (includeIV ? AES_BLOCK_SIZE : 0) + (unsigned)(isCheck ? kCheckSize32 * 4 : 0))
     return E_NOTIMPL;
 
   if (_numIterationsLog != p[0])
@@ -93,19 +108,21 @@ HRESULT CDecoder::SetDecoderProps(const Byte *p, unsigned size, bool includeIV,
   
   if (isCheck)
   {
-    memcpy(_check, p, kPswCheckSize);
+    memcpy(_check32, p, sizeof(_check32));
+    MY_ALIGN_FOR_SHA256
     CSha256 sha;
+    MY_ALIGN_FOR_SHA256
     Byte digest[SHA256_DIGEST_SIZE];
     Sha256_Init(&sha);
-    Sha256_Update(&sha, _check, kPswCheckSize);
+    Sha256_Update(&sha, (const Byte *)_check32, sizeof(_check32));
     Sha256_Final(&sha, digest);
-    _canCheck = (memcmp(digest, p + kPswCheckSize, kPswCheckCsumSize) == 0);
+    _canCheck = (memcmp(digest, p + sizeof(_check32), kPswCheckCsumSize32 * 4) == 0);
     if (_canCheck && isService)
     {
       // There was bug in RAR 5.21- : PswCheck field in service records ("QO") contained zeros.
       // so we disable password checking for such bad records.
       _canCheck = false;
-      for (unsigned i = 0; i < kPswCheckSize; i++)
+      for (unsigned i = 0; i < kPswCheckSize32 * 4; i++)
         if (p[i] != 0)
         {
           _canCheck = true;
@@ -132,7 +149,7 @@ void CDecoder::SetPassword(const Byte *data, size_t size)
 Z7_COM7F_IMF(CDecoder::Init())
 {
   CalcKey_and_CheckPassword();
-  RINOK(SetKey(_key, kAesKeySize))
+  RINOK(SetKey((const Byte *)_key32, kAesKeySize))
   RINOK(SetInitVector(_iv, AES_BLOCK_SIZE))
   return CAesCoder::Init();
 }
@@ -140,27 +157,27 @@ Z7_COM7F_IMF(CDecoder::Init())
 
 UInt32 CDecoder::Hmac_Convert_Crc32(UInt32 crc) const
 {
-  MY_ALIGN (16)
+  MY_ALIGN_FOR_SHA256
   NSha256::CHmac ctx;
-  ctx.SetKey(_hashKey, NSha256::kDigestSize);
+  ctx.SetKey((const Byte *)_hashKey32, NSha256::kDigestSize);
   UInt32 v;
-  SetUi32(&v, crc)
+  SetUi32a(&v, crc)
   ctx.Update((const Byte *)&v, 4);
-  MY_ALIGN (16)
+  MY_ALIGN_FOR_SHA256
   UInt32 h[SHA256_NUM_DIGEST_WORDS];
   ctx.Final((Byte *)h);
   crc = 0;
   for (unsigned i = 0; i < SHA256_NUM_DIGEST_WORDS; i++)
-    crc ^= (UInt32)GetUi32(h + i);
+    crc ^= (UInt32)GetUi32a(h + i);
   return crc;
 }
 
 
 void CDecoder::Hmac_Convert_32Bytes(Byte *data) const
 {
-  MY_ALIGN (16)
+  MY_ALIGN_FOR_SHA256
   NSha256::CHmac ctx;
-  ctx.SetKey(_hashKey, NSha256::kDigestSize);
+  ctx.SetKey((const Byte *)_hashKey32, NSha256::kDigestSize);
   ctx.Update(data, NSha256::kDigestSize);
   ctx.Final(data);
 }
@@ -190,30 +207,31 @@ bool CDecoder::CalcKey_and_CheckPassword()
     
     if (_needCalc)
     {
-      Byte pswCheck[SHA256_DIGEST_SIZE];
-
+      MY_ALIGN_FOR_SHA256
+      UInt32 pswCheck[SHA256_NUM_DIGEST_WORDS];
       {
         // Pbkdf HMAC-SHA-256
-
-        MY_ALIGN (16)
+        MY_ALIGN_FOR_SHA256
         NSha256::CHmac baseCtx;
         baseCtx.SetKey(_password, _password.Size());
-        
-        NSha256::CHmac ctx = baseCtx;
+        MY_ALIGN_FOR_SHA256
+        NSha256::CHmac ctx;
+        ctx = baseCtx;
         ctx.Update(_salt, sizeof(_salt));
         
-        MY_ALIGN (16)
-        Byte u[NSha256::kDigestSize];
-        MY_ALIGN (16)
-        Byte key[NSha256::kDigestSize];
+        MY_ALIGN_FOR_SHA256
+        UInt32 u[SHA256_NUM_DIGEST_WORDS];
+        MY_ALIGN_FOR_SHA256
+        UInt32 key[SHA256_NUM_DIGEST_WORDS];
         
-        u[0] = 0;
-        u[1] = 0;
-        u[2] = 0;
-        u[3] = 1;
+        // u[0] = 0;
+        // u[1] = 0;
+        // u[2] = 0;
+        // u[3] = 1;
+        SetUi32a(u, 0x1000000)
         
-        ctx.Update(u, 4);
-        ctx.Final(u);
+        ctx.Update((const Byte *)(const void *)u, 4);
+        ctx.Final((Byte *)(void *)u);
         
         memcpy(key, u, NSha256::kDigestSize);
         
@@ -221,35 +239,24 @@ bool CDecoder::CalcKey_and_CheckPassword()
         
         for (unsigned i = 0; i < 3; i++)
         {
-          UInt32 j = numIterations;
-          
-          for (; j != 0; j--)
+          for (; numIterations != 0; numIterations--)
           {
             ctx = baseCtx;
-            ctx.Update(u, NSha256::kDigestSize);
-            ctx.Final(u);
-            for (unsigned s = 0; s < NSha256::kDigestSize; s++)
+            ctx.Update((const Byte *)(const void *)u, NSha256::kDigestSize);
+            ctx.Final((Byte *)(void *)u);
+            for (unsigned s = 0; s < Z7_ARRAY_SIZE(u); s++)
               key[s] ^= u[s];
           }
           
           // RAR uses additional iterations for additional keys
-          memcpy((i == 0 ? _key : (i == 1 ? _hashKey : pswCheck)), key, NSha256::kDigestSize);
+          memcpy(i == 0 ? _key32 : i == 1 ? _hashKey32 : pswCheck,
+              key, NSha256::kDigestSize);
           numIterations = 16;
         }
       }
-
-      {
-        unsigned i;
-       
-        for (i = 0; i < kPswCheckSize; i++)
-          _check_Calced[i] = pswCheck[i];
-      
-        for (i = kPswCheckSize; i < SHA256_DIGEST_SIZE; i++)
-          _check_Calced[i & (kPswCheckSize - 1)] ^= pswCheck[i];
-      }
-
+     _check_Calced32[0] = pswCheck[0] ^ pswCheck[2] ^ pswCheck[4] ^ pswCheck[6];
+     _check_Calced32[1] = pswCheck[1] ^ pswCheck[3] ^ pswCheck[5] ^ pswCheck[7];
       _needCalc = false;
-      
       {
         MT_LOCK
         g_Key = *this;
@@ -258,7 +265,7 @@ bool CDecoder::CalcKey_and_CheckPassword()
   }
   
   if (IsThereCheck() && _canCheck)
-    return (memcmp(_check_Calced, _check, kPswCheckSize) == 0);
+    return memcmp(_check_Calced32, _check32, sizeof(_check32)) == 0;
   return true;
 }
 
diff --git a/CPP/7zip/Crypto/Rar5Aes.h b/CPP/7zip/Crypto/Rar5Aes.h
index 3cd7992..c6059aa 100644
--- a/CPP/7zip/Crypto/Rar5Aes.h
+++ b/CPP/7zip/Crypto/Rar5Aes.h
@@ -13,7 +13,7 @@ namespace NCrypto {
 namespace NRar5 {
 
 const unsigned kSaltSize = 16;
-const unsigned kPswCheckSize = 8;
+const unsigned kPswCheckSize32 = 2;
 const unsigned kAesKeySize = 32;
 
 namespace NCryptoFlags
@@ -22,48 +22,47 @@ namespace NCryptoFlags
   const unsigned kUseMAC   = 1 << 1;
 }
 
-struct CKey
+struct CKeyBase
 {
-  bool _needCalc;
+protected:
+  UInt32 _key32[kAesKeySize / 4];
+  UInt32 _hashKey32[SHA256_NUM_DIGEST_WORDS];
+  UInt32 _check_Calced32[kPswCheckSize32];
 
-  unsigned _numIterationsLog;
-  Byte _salt[kSaltSize];
-  CByteBuffer _password;
+  void Wipe()
+  {
+    memset(this, 0, sizeof(*this));
+  }
   
-  Byte _key[kAesKeySize];
-  Byte _check_Calced[kPswCheckSize];
-  Byte _hashKey[SHA256_DIGEST_SIZE];
-
-  void CopyCalcedKeysFrom(const CKey &k)
+  void CopyCalcedKeysFrom(const CKeyBase &k)
   {
-    memcpy(_key, k._key, sizeof(_key));
-    memcpy(_check_Calced, k._check_Calced, sizeof(_check_Calced));
-    memcpy(_hashKey, k._hashKey, sizeof(_hashKey));
+    *this = k;
   }
+};
 
+struct CKey: public CKeyBase
+{
+  CByteBuffer _password;
+  bool _needCalc;
+  unsigned _numIterationsLog;
+  Byte _salt[kSaltSize];
+  
   bool IsKeyEqualTo(const CKey &key)
   {
-    return (_numIterationsLog == key._numIterationsLog
+    return _numIterationsLog == key._numIterationsLog
         && memcmp(_salt, key._salt, sizeof(_salt)) == 0
-        && _password == key._password);
+        && _password == key._password;
   }
-  
-  CKey();
 
-  void Wipe()
-  {
-    _password.Wipe();
-    Z7_memset_0_ARRAY(_salt);
-    Z7_memset_0_ARRAY(_key);
-    Z7_memset_0_ARRAY(_check_Calced);
-    Z7_memset_0_ARRAY(_hashKey);
-  }
+  CKey();
+  ~CKey();
+  
+  void Wipe();
 
 #ifdef Z7_CPP_IS_SUPPORTED_default
   // CKey(const CKey &) = default;
   CKey& operator =(const CKey &) = default;
 #endif
-  ~CKey() { Wipe(); }
 };
 
 
@@ -71,11 +70,11 @@ class CDecoder Z7_final:
   public CAesCbcDecoder,
   public CKey
 {
-  Byte _check[kPswCheckSize];
+  UInt32 _check32[kPswCheckSize32];
   bool _canCheck;
   UInt64 Flags;
 
-  bool IsThereCheck() const { return ((Flags & NCryptoFlags::kPswCheck) != 0); }
+  bool IsThereCheck() const { return (Flags & NCryptoFlags::kPswCheck) != 0; }
 public:
   Byte _iv[AES_BLOCK_SIZE];
   
diff --git a/CPP/7zip/Crypto/RarAes.cpp b/CPP/7zip/Crypto/RarAes.cpp
index 878ea3a..e63f82c 100644
--- a/CPP/7zip/Crypto/RarAes.cpp
+++ b/CPP/7zip/Crypto/RarAes.cpp
@@ -111,7 +111,8 @@ static void UpdatePswDataSha1(Byte *data)
   
   for (i = 16; i < 80; i++)
   {
-    WW(i) = rotlFixed(WW((i)-3) ^ WW((i)-8) ^ WW((i)-14) ^ WW((i)-16), 1);
+    const UInt32 t = WW((i)-3) ^ WW((i)-8) ^ WW((i)-14) ^ WW((i)-16);
+    WW(i) = rotlFixed(t, 1);
   }
   
   for (i = 0; i < SHA1_NUM_BLOCK_WORDS; i++)
@@ -128,6 +129,7 @@ void CDecoder::CalcKey()
 
   const unsigned kSaltSize = 8;
   
+  MY_ALIGN (16)
   Byte buf[kPasswordLen_Bytes_MAX + kSaltSize];
   
   if (_password.Size() != 0)
@@ -148,7 +150,7 @@ void CDecoder::CalcKey()
   MY_ALIGN (16)
   Byte digest[NSha1::kDigestSize];
   // rar reverts hash for sha.
-  const UInt32 kNumRounds = ((UInt32)1 << 18);
+  const UInt32 kNumRounds = (UInt32)1 << 18;
   UInt32 pos = 0;
   UInt32 i;
   for (i = 0; i < kNumRounds; i++)
@@ -171,8 +173,14 @@ void CDecoder::CalcKey()
       }
     }
     pos += (UInt32)rawSize;
+#if 1
+    UInt32 pswNum;
+    SetUi32a(&pswNum, i)
+    sha.Update((const Byte *)&pswNum, 3);
+#else
     Byte pswNum[3] = { (Byte)i, (Byte)(i >> 8), (Byte)(i >> 16) };
     sha.Update(pswNum, 3);
+#endif
     pos += 3;
     if (i % (kNumRounds / 16) == 0)
     {
diff --git a/CPP/7zip/Crypto/ZipStrong.cpp b/CPP/7zip/Crypto/ZipStrong.cpp
index 59698d8..c4e8311 100644
--- a/CPP/7zip/Crypto/ZipStrong.cpp
+++ b/CPP/7zip/Crypto/ZipStrong.cpp
@@ -24,30 +24,31 @@ static const UInt16 kAES128 = 0x660E;
   if (method != AES && method != 3DES), probably we need another code.
 */
 
-static void DeriveKey2(const Byte *digest, Byte c, Byte *dest)
+static void DeriveKey2(const UInt32 *digest32, Byte c, UInt32 *dest32)
 {
+  const unsigned kBufSize = 64;
   MY_ALIGN (16)
-  Byte buf[64];
-  memset(buf, c, 64);
-  for (unsigned i = 0; i < NSha1::kDigestSize; i++)
-    buf[i] ^= digest[i];
+  UInt32 buf32[kBufSize / 4];
+  memset(buf32, c, kBufSize);
+  for (unsigned i = 0; i < NSha1::kNumDigestWords; i++)
+    buf32[i] ^= digest32[i];
   MY_ALIGN (16)
   NSha1::CContext sha;
   sha.Init();
-  sha.Update(buf, 64);
-  sha.Final(dest);
+  sha.Update((const Byte *)buf32, kBufSize);
+  sha.Final((Byte *)dest32);
 }
  
 static void DeriveKey(NSha1::CContext &sha, Byte *key)
 {
   MY_ALIGN (16)
-  Byte digest[NSha1::kDigestSize];
-  sha.Final(digest);
+  UInt32 digest32[NSha1::kNumDigestWords];
+  sha.Final((Byte *)digest32);
   MY_ALIGN (16)
-  Byte temp[NSha1::kDigestSize * 2];
-  DeriveKey2(digest, 0x36, temp);
-  DeriveKey2(digest, 0x5C, temp + NSha1::kDigestSize);
-  memcpy(key, temp, 32);
+  UInt32 temp32[NSha1::kNumDigestWords * 2];
+  DeriveKey2(digest32, 0x36, temp32);
+  DeriveKey2(digest32, 0x5C, temp32 + NSha1::kNumDigestWords);
+  memcpy(key, temp32, 32);
 }
 
 void CKeyInfo::SetPassword(const Byte *data, UInt32 size)
@@ -122,24 +123,24 @@ HRESULT CDecoder::Init_and_CheckPassword(bool &passwOK)
   passwOK = false;
   if (_remSize < 16)
     return E_NOTIMPL;
-  Byte *p = _bufAligned;
-  const unsigned format = GetUi16(p);
+  Byte * const p = _bufAligned;
+  const unsigned format = GetUi16a(p);
   if (format != 3)
     return E_NOTIMPL;
-  unsigned algId = GetUi16(p + 2);
+  unsigned algId = GetUi16a(p + 2);
   if (algId < kAES128)
     return E_NOTIMPL;
   algId -= kAES128;
   if (algId > 2)
     return E_NOTIMPL;
-  const unsigned bitLen = GetUi16(p + 4);
-  const unsigned flags = GetUi16(p + 6);
+  const unsigned bitLen = GetUi16a(p + 4);
+  const unsigned flags = GetUi16a(p + 6);
   if (algId * 64 + 128 != bitLen)
     return E_NOTIMPL;
   _key.KeySize = 16 + algId * 8;
   const bool cert = ((flags & 2) != 0);
 
-  if ((flags & 0x4000) != 0)
+  if (flags & 0x4000)
   {
     // Use 3DES for rd data
     return E_NOTIMPL;
@@ -155,7 +156,7 @@ HRESULT CDecoder::Init_and_CheckPassword(bool &passwOK)
       return E_NOTIMPL;
   }
 
-  UInt32 rdSize = GetUi16(p + 8);
+  UInt32 rdSize = GetUi16a(p + 8);
 
   if (rdSize + 16 > _remSize)
     return E_NOTIMPL;
@@ -174,7 +175,7 @@ HRESULT CDecoder::Init_and_CheckPassword(bool &passwOK)
     // PKCS7 padding
     if (rdSize < kPadSize)
       return E_NOTIMPL;
-    if ((rdSize & (kPadSize - 1)) != 0)
+    if (rdSize & (kPadSize - 1))
       return E_NOTIMPL;
   }
 
diff --git a/CPP/7zip/GuiCommon.rc b/CPP/7zip/GuiCommon.rc
index 95654b6..bf8ad8b 100644
--- a/CPP/7zip/GuiCommon.rc
+++ b/CPP/7zip/GuiCommon.rc
@@ -115,5 +115,5 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
       _x + _xSize, _y, 8, 12  // these values are unused
 
 
-#define OPTIONS_PAGE_XC_SIZE 280
+#define OPTIONS_PAGE_XC_SIZE 300
 #define OPTIONS_PAGE_YC_SIZE 280
diff --git a/CPP/7zip/Guid.txt b/CPP/7zip/Guid.txt
index abbaf20..fbae89c 100644
--- a/CPP/7zip/Guid.txt
+++ b/CPP/7zip/Guid.txt
@@ -20,6 +20,8 @@
   10  IFolderArchiveUpdateCallback2
   11  IFolderScanProgress
   12  IFolderSetZoneIdMode
+  13  IFolderSetZoneIdFile
+  14  IFolderArchiveUpdateCallback_MoveArc
   
   20  IFileExtractCallback.h::IGetProp
   30  IFileExtractCallback.h::IFolderExtractToStreamCallback (old)
diff --git a/CPP/7zip/ICoder.h b/CPP/7zip/ICoder.h
index aec2834..20d0ff7 100644
--- a/CPP/7zip/ICoder.h
+++ b/CPP/7zip/ICoder.h
@@ -136,6 +136,9 @@ namespace NCoderPropID
     kAffinity,          // VT_UI8
     kBranchOffset,      // VT_UI4
     kHashBits,          // VT_UI4
+    kNumThreadGroups,   // VT_UI4
+    kThreadGroup,       // VT_UI4
+    kAffinityInGroup,   // VT_UI8
     /*
     // kHash3Bits,          // VT_UI4
     // kHash2Bits,          // VT_UI4
diff --git a/CPP/7zip/Sort.mak b/CPP/7zip/Sort.mak
new file mode 100644
index 0000000..ca0ff59
--- /dev/null
+++ b/CPP/7zip/Sort.mak
@@ -0,0 +1,6 @@
+!IF defined(USE_NO_ASM) || defined(USE_C_SORT) || "$(PLATFORM)" == "ia64" || "$(PLATFORM)" == "mips" || "$(PLATFORM)" == "arm" || "$(PLATFORM)" == "arm64"
+C_OBJS = $(C_OBJS) \
+!ELSE
+ASM_OBJS = $(ASM_OBJS) \
+!ENDIF
+  $O\Sort.obj
diff --git a/CPP/7zip/UI/Agent/Agent.cpp b/CPP/7zip/UI/Agent/Agent.cpp
index eb77f25..46b740a 100644
--- a/CPP/7zip/UI/Agent/Agent.cpp
+++ b/CPP/7zip/UI/Agent/Agent.cpp
@@ -1516,6 +1516,8 @@ Z7_COM7F_IMF(CAgentFolder::Extract(const UInt32 *indices,
     if (_zoneMode != NExtract::NZoneIdMode::kNone)
     {
       ReadZoneFile_Of_BaseFile(us2fs(_agentSpec->_archiveFilePath), extractCallbackSpec->ZoneBuf);
+      if (_zoneBuf.Size() != 0)
+        extractCallbackSpec->ZoneBuf = _zoneBuf;
     }
   #endif
 
diff --git a/CPP/7zip/UI/Agent/Agent.h b/CPP/7zip/UI/Agent/Agent.h
index ea81aa8..a63e459 100644
--- a/CPP/7zip/UI/Agent/Agent.h
+++ b/CPP/7zip/UI/Agent/Agent.h
@@ -60,6 +60,7 @@ class CAgentFolder Z7_final:
   public IArchiveFolderInternal,
   public IInArchiveGetStream,
   public IFolderSetZoneIdMode,
+  public IFolderSetZoneIdFile,
   public IFolderOperations,
   public IFolderSetFlatMode,
   public CMyUnknownImp
@@ -75,6 +76,7 @@ class CAgentFolder Z7_final:
     Z7_COM_QI_ENTRY(IArchiveFolderInternal)
     Z7_COM_QI_ENTRY(IInArchiveGetStream)
     Z7_COM_QI_ENTRY(IFolderSetZoneIdMode)
+    Z7_COM_QI_ENTRY(IFolderSetZoneIdFile)
     Z7_COM_QI_ENTRY(IFolderOperations)
     Z7_COM_QI_ENTRY(IFolderSetFlatMode)
   Z7_COM_QI_END
@@ -91,6 +93,7 @@ class CAgentFolder Z7_final:
   Z7_IFACE_COM7_IMP(IArchiveFolderInternal)
   Z7_IFACE_COM7_IMP(IInArchiveGetStream)
   Z7_IFACE_COM7_IMP(IFolderSetZoneIdMode)
+  Z7_IFACE_COM7_IMP(IFolderSetZoneIdFile)
   Z7_IFACE_COM7_IMP(IFolderOperations)
   Z7_IFACE_COM7_IMP(IFolderSetFlatMode)
 
@@ -106,11 +109,11 @@ public:
   int CompareItems2(UInt32 index1, UInt32 index2, PROPID propID, Int32 propIsRaw);
 
   CAgentFolder():
-      _proxyDirIndex(0),
       _isAltStreamFolder(false),
       _flatMode(false),
-      _loadAltStreams(false) // _loadAltStreams alt streams works in flat mode, but we don't use it now
-      , _zoneMode(NExtract::NZoneIdMode::kNone)
+      _loadAltStreams(false), // _loadAltStreams alt streams works in flat mode, but we don't use it now
+      _proxyDirIndex(0),
+      _zoneMode(NExtract::NZoneIdMode::kNone)
       /* , _replaceAltStreamCharsMode(0) */
       {}
 
@@ -145,21 +148,23 @@ public:
   UString GetFullPrefix(UInt32 index) const; // relative too root folder of archive
 
 public:
+  bool _isAltStreamFolder;
+  bool _flatMode;
+  bool _loadAltStreams; // in Flat mode
   const CProxyArc *_proxy;
   const CProxyArc2 *_proxy2;
   unsigned _proxyDirIndex;
-  bool _isAltStreamFolder;
+  NExtract::NZoneIdMode::EEnum _zoneMode;
+  CByteBuffer _zoneBuf;
+  // Int32 _replaceAltStreamCharsMode;
   // CMyComPtr<IFolderFolder> _parentFolder;
   CMyComPtr<IInFolderArchive> _agent;
   CAgent *_agentSpec;
-
   CRecordVector<CProxyItem> _items;
-  bool _flatMode;
-  bool _loadAltStreams; // in Flat mode
-  // Int32 _replaceAltStreamCharsMode;
-  NExtract::NZoneIdMode::EEnum _zoneMode;
 };
 
+
+
 class CAgent Z7_final:
   public IInFolderArchive,
   public IFolderArcProps,
@@ -213,22 +218,22 @@ public:
   CProxyArc2 *_proxy2;
   CArchiveLink _archiveLink;
 
-  bool ThereIsPathProp;
-  // bool ThereIsAltStreamProp;
-
   UString ArchiveType;
 
   FStringVector _names;
   FString _folderPrefix; // for new files from disk
 
-  bool _updatePathPrefix_is_AltFolder;
   UString _updatePathPrefix;
   CAgentFolder *_agentFolder;
 
-  UString _archiveFilePath;
+  UString _archiveFilePath; // it can be path of non-existing file if file is virtual
+  
   DWORD _attrib;
+  bool _updatePathPrefix_is_AltFolder;
+  bool ThereIsPathProp;
   bool _isDeviceFile;
   bool _isHashHandler;
+  
   FString _hashBaseFolderPrefix;
 
  #ifndef Z7_EXTRACT_ONLY
diff --git a/CPP/7zip/UI/Agent/AgentProxy.cpp b/CPP/7zip/UI/Agent/AgentProxy.cpp
index 176f39b..d04ddab 100644
--- a/CPP/7zip/UI/Agent/AgentProxy.cpp
+++ b/CPP/7zip/UI/Agent/AgentProxy.cpp
@@ -636,7 +636,7 @@ HRESULT CProxyArc2::Load(const CArc &arc, IProgress *progress)
       file.Name = (const wchar_t *)p;
       file.NameLen = 0;
       if (size >= sizeof(wchar_t))
-        file.NameLen = size / sizeof(wchar_t) - 1;
+        file.NameLen = size / (unsigned)sizeof(wchar_t) - 1;
     }
     else
     #endif
diff --git a/CPP/7zip/UI/Agent/ArchiveFolder.cpp b/CPP/7zip/UI/Agent/ArchiveFolder.cpp
index 89b20dc..eea681c 100644
--- a/CPP/7zip/UI/Agent/ArchiveFolder.cpp
+++ b/CPP/7zip/UI/Agent/ArchiveFolder.cpp
@@ -22,6 +22,12 @@ Z7_COM7F_IMF(CAgentFolder::SetZoneIdMode(NExtract::NZoneIdMode::EEnum zoneMode))
   return S_OK;
 }
 
+Z7_COM7F_IMF(CAgentFolder::SetZoneIdFile(const Byte *data, UInt32 size))
+{
+  _zoneBuf.CopyFrom(data, size);
+  return S_OK;
+}
+
 
 Z7_COM7F_IMF(CAgentFolder::CopyTo(Int32 moveMode, const UInt32 *indices, UInt32 numItems,
     Int32 includeAltStreams, Int32 replaceAltStreamCharsMode,
diff --git a/CPP/7zip/UI/Agent/ArchiveFolderOut.cpp b/CPP/7zip/UI/Agent/ArchiveFolderOut.cpp
index 0189224..1da6601 100644
--- a/CPP/7zip/UI/Agent/ArchiveFolderOut.cpp
+++ b/CPP/7zip/UI/Agent/ArchiveFolderOut.cpp
@@ -62,6 +62,33 @@ static bool Delete_EmptyFolder_And_EmptySubFolders(const FString &path)
   return RemoveDir(path);
 }
 
+
+
+struct C_CopyFileProgress_to_FolderCallback_MoveArc Z7_final:
+  public ICopyFileProgress
+{
+  IFolderArchiveUpdateCallback_MoveArc *Callback;
+  HRESULT CallbackResult;
+
+  virtual DWORD CopyFileProgress(UInt64 total, UInt64 current) Z7_override
+  {
+    HRESULT res = Callback->MoveArc_Progress(total, current);
+    CallbackResult = res;
+    // we can ignore E_ABORT here, because we update archive,
+    // and we want to get correct archive after updating
+    if (res == E_ABORT)
+      res = S_OK;
+    return res == S_OK ? PROGRESS_CONTINUE : PROGRESS_CANCEL;
+  }
+
+  C_CopyFileProgress_to_FolderCallback_MoveArc(
+      IFolderArchiveUpdateCallback_MoveArc *callback) :
+    Callback(callback),
+    CallbackResult(S_OK)
+    {}
+};
+
+
 HRESULT CAgentFolder::CommonUpdateOperation(
     AGENT_OP operation,
     bool moveMode,
@@ -159,8 +186,51 @@ HRESULT CAgentFolder::CommonUpdateOperation(
   // now: we reopen archive after close
 
   // m_FolderItem = NULL;
+  _items.Clear();
+  _proxyDirIndex = k_Proxy_RootDirIndex;
+
+  CMyComPtr<IFolderArchiveUpdateCallback_MoveArc> updateCallback_MoveArc;
+  if (progress)
+    progress->QueryInterface(IID_IFolderArchiveUpdateCallback_MoveArc, (void **)&updateCallback_MoveArc);
   
-  const HRESULT res = tempFile.MoveToOriginal(true);
+  HRESULT res;
+  if (updateCallback_MoveArc)
+  {
+    const FString &tempFilePath = tempFile.Get_TempFilePath();
+    UInt64 totalSize = 0;
+    {
+      NFind::CFileInfo fi;
+      if (fi.Find(tempFilePath))
+        totalSize = fi.Size;
+    }
+    RINOK(updateCallback_MoveArc->MoveArc_Start(
+        fs2us(tempFilePath),
+        fs2us(tempFile.Get_OriginalFilePath()),
+        totalSize,
+        1)) // updateMode
+
+    C_CopyFileProgress_to_FolderCallback_MoveArc prox(updateCallback_MoveArc);
+    res = tempFile.MoveToOriginal(
+        true, // deleteOriginal
+        &prox);
+    if (res == S_OK)
+    {
+      res = updateCallback_MoveArc->MoveArc_Finish();
+      // we don't return after E_ABORT here, because
+      // we want to reopen new archive still.
+    }
+    else if (prox.CallbackResult != S_OK)
+      res = prox.CallbackResult;
+
+    // if updating callback returned E_ABORT,
+    // then openCallback still can return E_ABORT also.
+    // So ReOpen() will return with E_ABORT.
+    // But we want to open archive still.
+    // And Before_ArcReopen() call will clear user break status in that case.
+    RINOK(updateCallback_MoveArc->Before_ArcReopen())
+  }
+  else
+    res = tempFile.MoveToOriginal(true); // deleteOriginal
 
   // RINOK(res);
   if (res == S_OK)
@@ -189,10 +259,10 @@ HRESULT CAgentFolder::CommonUpdateOperation(
   }
    
   // CAgent::ReOpen() deletes _proxy and _proxy2
-  _items.Clear();
+  // _items.Clear();
   _proxy = NULL;
   _proxy2 = NULL;
-  _proxyDirIndex = k_Proxy_RootDirIndex;
+  // _proxyDirIndex = k_Proxy_RootDirIndex;
   _isAltStreamFolder = false;
   
   
diff --git a/CPP/7zip/UI/Agent/IFolderArchive.h b/CPP/7zip/UI/Agent/IFolderArchive.h
index 55f1423..12b900f 100644
--- a/CPP/7zip/UI/Agent/IFolderArchive.h
+++ b/CPP/7zip/UI/Agent/IFolderArchive.h
@@ -103,5 +103,21 @@ Z7_IFACE_CONSTR_FOLDERARC(IFolderScanProgress, 0x11)
 
 Z7_IFACE_CONSTR_FOLDERARC(IFolderSetZoneIdMode, 0x12)
 
+#define Z7_IFACEM_IFolderSetZoneIdFile(x) \
+  x(SetZoneIdFile(const Byte *data, UInt32 size)) \
+
+Z7_IFACE_CONSTR_FOLDERARC(IFolderSetZoneIdFile, 0x13)
+
+
+// if the caller calls Before_ArcReopen(), the callee must
+// clear user break status, because the caller want to open archive still.
+#define Z7_IFACEM_IFolderArchiveUpdateCallback_MoveArc(x) \
+  x(MoveArc_Start(const wchar_t *srcTempPath, const wchar_t *destFinalPath, UInt64 size, Int32 updateMode)) \
+  x(MoveArc_Progress(UInt64 totalSize, UInt64 currentSize)) \
+  x(MoveArc_Finish()) \
+  x(Before_ArcReopen()) \
+
+Z7_IFACE_CONSTR_FOLDERARC(IFolderArchiveUpdateCallback_MoveArc, 0x14)
+
 Z7_PURE_INTERFACES_END
 #endif
diff --git a/CPP/7zip/UI/Client7z/makefile.gcc b/CPP/7zip/UI/Client7z/makefile.gcc
index 3f97205..0f89cb0 100644
--- a/CPP/7zip/UI/Client7z/makefile.gcc
+++ b/CPP/7zip/UI/Client7z/makefile.gcc
@@ -24,7 +24,6 @@ else
 
 SYS_OBJS = \
   $O/MyWindows.o \
-  $O/TimeUtils.o \
 
 endif
 
@@ -53,12 +52,16 @@ WIN_OBJS = \
   $O/FileName.o \
   $O/PropVariant.o \
   $O/PropVariantConv.o \
+  $O/TimeUtils.o \
 
 7ZIP_COMMON_OBJS = \
   $O/FileStreams.o \
 
+C_OBJS = \
+  $O/Alloc.o \
 
 OBJS = \
+  $(C_OBJS) \
   $(COMMON_OBJS) \
   $(WIN_OBJS) \
   $(SYS_OBJS) \
diff --git a/CPP/7zip/UI/Common/ArchiveCommandLine.cpp b/CPP/7zip/UI/Common/ArchiveCommandLine.cpp
index 556b25a..7fe18fb 100644
--- a/CPP/7zip/UI/Common/ArchiveCommandLine.cpp
+++ b/CPP/7zip/UI/Common/ArchiveCommandLine.cpp
@@ -63,17 +63,46 @@ EXTERN_C_END
 
 #else
 
-// #define MY_isatty_fileno(x) (isatty(fileno(x)))
-// #define MY_IS_TERMINAL(x) (MY_isatty_fileno(x) != 0);
-static inline bool MY_IS_TERMINAL(FILE *x)
+static bool MY_IS_TERMINAL(FILE *x)
 {
-  return (
-    #if defined(_MSC_VER) && (_MSC_VER >= 1400)
-      _isatty(_fileno(x))
-    #else
-      isatty(fileno(x))
-    #endif
-      != 0);
+#ifdef _WIN32
+  /*
+crt/stdio.h:
+typedef struct _iobuf FILE;
+#define stdin  (&_iob[0])
+#define stdout (&_iob[1])
+#define stderr (&_iob[2])
+*/
+  // fprintf(stderr, "\nMY_IS_TERMINAL = %p", x);
+  const int fd = _fileno(x);
+  /* (fd) is 0, 1 or 2 in console program.
+     docs: If stdout or stderr is not associated with
+     an output stream (for example, in a Windows application
+     without a console window), the file descriptor returned is -2.
+     In previous versions, the file descriptor returned was -1.
+  */
+  if (fd < 0) // is not associated with an output stream application (without a console window)
+    return false;
+  // fprintf(stderr, "\n\nstderr _fileno(%p) = %d", x, fd);
+  if (!_isatty(fd))
+    return false;
+  // fprintf(stderr, "\nisatty_val = true");
+  const HANDLE h = (HANDLE)_get_osfhandle(fd);
+  /* _get_osfhandle() returns intptr_t in new SDK, or long in MSVC6.
+     Also it can return (INVALID_HANDLE_VALUE).
+     docs: _get_osfhandle also returns the special value -2 when
+     the file descriptor is not associated with a stream
+     in old msvcrt.dll: it returns (-1) for incorrect value
+  */
+  // fprintf(stderr, "\n_get_osfhandle() = %p", (void *)h);
+  if (h == NULL || h == INVALID_HANDLE_VALUE)
+    return false;
+  DWORD st;
+  // fprintf(stderr, "\nGetConsoleMode() = %u", (unsigned)GetConsoleMode(h, &st));
+  return GetConsoleMode(h, &st) != 0;
+#else
+  return isatty(fileno(x)) != 0;
+#endif
 }
 
 #endif
@@ -312,7 +341,7 @@ static const CSwitchForm kSwitchForms[] =
   { "spf", SWFRM_STRING_SINGL(0) },
   
   { "snh", SWFRM_MINUS },
-  { "snld", SWFRM_MINUS },
+  { "snld", SWFRM_STRING },
   { "snl", SWFRM_MINUS },
   { "sni", SWFRM_SIMPLE },
 
@@ -1088,7 +1117,7 @@ void CArcCmdLineParser::Parse1(const UStringVector &commandStrings,
     const UString &s = parser[NKey::kLargePages].PostStrings[0];
     if (s.IsEmpty())
       slp = 1;
-    else if (s != L"-")
+    else if (!s.IsEqualTo("-"))
     {
       if (!StringToUInt32(s, slp))
         throw CArcCmdLineException("Unsupported switch postfix for -slp", s);
@@ -1338,7 +1367,7 @@ void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)
     const UString &s = parser[NKey::kFullPathMode].PostStrings[0];
     if (!s.IsEmpty())
     {
-      if (s == L"2")
+      if (s.IsEqualTo("2"))
         censorPathMode = NWildcard::k_FullPath;
       else
         throw CArcCmdLineException("Unsupported -spf:", s);
@@ -1400,6 +1429,7 @@ void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)
   const bool isExtractGroupCommand = options.Command.IsFromExtractGroup();
   const bool isExtractOrList = isExtractGroupCommand || options.Command.CommandType == NCommandType::kList;
   const bool isRename = options.Command.CommandType == NCommandType::kRename;
+  options.UpdateOptions.RenameMode = isRename;
 
   if ((isExtractOrList || isRename) && options.StdInMode)
     thereIsArchiveName = false;
@@ -1449,14 +1479,8 @@ void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)
   
   SetBoolPair(parser, NKey::kStoreOwnerId, options.StoreOwnerId);
   SetBoolPair(parser, NKey::kStoreOwnerName, options.StoreOwnerName);
-
-  CBoolPair symLinks_AllowDangerous;
-  SetBoolPair(parser, NKey::kSymLinks_AllowDangerous, symLinks_AllowDangerous);
-  
-
   /*
   bool supportSymLink = options.SymLinks.Val;
-  
   if (!options.SymLinks.Def)
   {
     if (isExtractOrList)
@@ -1464,7 +1488,6 @@ void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)
     else
       supportSymLink = false;
   }
-
   #ifdef ENV_HAVE_LSTAT
   if (supportSymLink)
     global_use_lstat = 1;
@@ -1473,7 +1496,6 @@ void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)
   #endif
   */
 
-
   if (isExtractOrList)
   {
     CExtractOptionsBase &eo = options.ExtractOptions;
@@ -1497,7 +1519,15 @@ void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)
       if (!options.SymLinks.Def)
         nt.SymLinks.Val = true;
 
-      nt.SymLinks_AllowDangerous = symLinks_AllowDangerous;
+      if (parser[NKey::kSymLinks_AllowDangerous].ThereIs)
+      {
+        const UString &s = parser[NKey::kSymLinks_AllowDangerous].PostStrings[0];
+        UInt32 v = 9; // default value for "-snld" instead of default = 5 without "-snld".
+        if (!s.IsEmpty())
+          if (!StringToUInt32(s, v))
+            throw CArcCmdLineException("Unsupported switch postfix -snld", s);
+        nt.SymLinks_DangerousLevel = (unsigned)v;
+      }
 
       nt.ReplaceColonForAltStream = parser[NKey::kReplaceColonForAltStream].ThereIs;
       nt.WriteToAltStreamIfColon = parser[NKey::kWriteToAltStreamIfColon].ThereIs;
@@ -1516,9 +1546,9 @@ void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)
       const UString &s = parser[NKey::kZoneFile].PostStrings[0];
       if (!s.IsEmpty())
       {
-             if (s == L"0") eo.ZoneMode = NExtract::NZoneIdMode::kNone;
-        else if (s == L"1") eo.ZoneMode = NExtract::NZoneIdMode::kAll;
-        else if (s == L"2") eo.ZoneMode = NExtract::NZoneIdMode::kOffice;
+             if (s.IsEqualTo("0")) eo.ZoneMode = NExtract::NZoneIdMode::kNone;
+        else if (s.IsEqualTo("1")) eo.ZoneMode = NExtract::NZoneIdMode::kAll;
+        else if (s.IsEqualTo("2")) eo.ZoneMode = NExtract::NZoneIdMode::kOffice;
         else
           throw CArcCmdLineException("Unsupported -snz:", s);
       }
diff --git a/CPP/7zip/UI/Common/ArchiveExtractCallback.cpp b/CPP/7zip/UI/Common/ArchiveExtractCallback.cpp
index 2d32694..6631629 100644
--- a/CPP/7zip/UI/Common/ArchiveExtractCallback.cpp
+++ b/CPP/7zip/UI/Common/ArchiveExtractCallback.cpp
@@ -6,12 +6,10 @@
 #undef printf
 
 // #include <stdio.h>
-// #include "../../../../C/CpuTicks.h"
 
 #include "../../../../C/Alloc.h"
 #include "../../../../C/CpuArch.h"
 
-
 #include "../../../Common/ComTry.h"
 #include "../../../Common/IntToString.h"
 #include "../../../Common/StringConvert.h"
@@ -33,6 +31,8 @@
 #include "../../Common/FilePathAutoRename.h"
 #include "../../Common/StreamUtils.h"
 
+#include "../../Archive/Common/ItemNameUtils.h"
+
 #include "../Common/ExtractingFilePath.h"
 #include "../Common/PropIDUtils.h"
 
@@ -54,6 +54,23 @@ static const char * const kCantSetFileLen = "Cannot set length for output file";
 #ifdef SUPPORT_LINKS
 static const char * const kCantCreateHardLink = "Cannot create hard link";
 static const char * const kCantCreateSymLink = "Cannot create symbolic link";
+static const char * const k_HardLink_to_SymLink_Ignored = "Hard link to symbolic link was ignored";
+static const char * const k_CantDelete_File_for_SymLink = "Cannot delete file for symbolic link creation";
+static const char * const k_CantDelete_Dir_for_SymLink = "Cannot delete directory for symbolic link creation";
+#endif
+
+static const unsigned k_LinkDataSize_LIMIT = 1 << 12;
+
+#ifdef SUPPORT_LINKS
+#if WCHAR_PATH_SEPARATOR != L'/'
+  // we convert linux slashes to windows slashes for further processing.
+  // also we convert linux backslashes to BackslashReplacement character.
+  #define REPLACE_SLASHES_from_Linux_to_Sys(s) \
+    { NArchive::NItemName::ReplaceToWinSlashes(s, true); }  // useBackslashReplacement
+      // { s.Replace(L'/', WCHAR_PATH_SEPARATOR); }
+#else
+  #define REPLACE_SLASHES_from_Linux_to_Sys(s)
+#endif
 #endif
 
 #ifndef Z7_SFX
@@ -140,21 +157,25 @@ static bool FindExt2(const char *p, const UString &name)
 }
 
 
-static const FChar * const k_ZoneId_StreamName = FTEXT(":Zone.Identifier");
+static const char * const k_ZoneId_StreamName_With_Colon_Prefix = ":Zone.Identifier";
 
-void ReadZoneFile_Of_BaseFile(CFSTR fileName2, CByteBuffer &buf)
+bool Is_ZoneId_StreamName(const wchar_t *s)
 {
-  FString fileName (fileName2);
-  fileName += k_ZoneId_StreamName;
+  return StringsAreEqualNoCase_Ascii(s, k_ZoneId_StreamName_With_Colon_Prefix + 1);
+}
 
+void ReadZoneFile_Of_BaseFile(CFSTR fileName, CByteBuffer &buf)
+{
   buf.Free();
+  FString path (fileName);
+  path += k_ZoneId_StreamName_With_Colon_Prefix;
   NIO::CInFile file;
-  if (!file.Open(fileName))
+  if (!file.Open(path))
     return;
   UInt64 fileSize;
   if (!file.GetLength(fileSize))
     return;
-  if (fileSize == 0 || fileSize >= ((UInt32)1 << 16))
+  if (fileSize == 0 || fileSize >= (1u << 15))
     return;
   buf.Alloc((size_t)fileSize);
   size_t processed;
@@ -166,7 +187,7 @@ void ReadZoneFile_Of_BaseFile(CFSTR fileName2, CByteBuffer &buf)
 bool WriteZoneFile_To_BaseFile(CFSTR fileName, const CByteBuffer &buf)
 {
   FString path (fileName);
-  path += k_ZoneId_StreamName;
+  path += k_ZoneId_StreamName_With_Colon_Prefix;
   NIO::COutFile file;
   if (!file.Create_ALWAYS(path))
     return false;
@@ -213,7 +234,7 @@ HRESULT CArchiveExtractCallback::PrepareHardLinks(const CRecordVector<UInt32> *r
   if (!_arc->Ask_INode)
     return S_OK;
   
-  IInArchive *archive = _arc->Archive;
+  IInArchive * const archive = _arc->Archive;
   CRecordVector<CHardLinkNode> &hardIDs = _hardLinks.IDs;
 
   {
@@ -275,16 +296,13 @@ HRESULT CArchiveExtractCallback::PrepareHardLinks(const CRecordVector<UInt32> *r
 
 
 CArchiveExtractCallback::CArchiveExtractCallback():
-    _arc(NULL),
-    Write_CTime(true),
-    Write_ATime(true),
-    Write_MTime(true),
+    // Write_CTime(true),
+    // Write_ATime(true),
+    // Write_MTime(true),
     Is_elimPrefix_Mode(false),
+    _arc(NULL),
     _multiArchives(false)
 {
-  LocalProgressSpec = new CLocalProgress();
-  _localProgress = LocalProgressSpec;
-
   #ifdef Z7_USE_SECURITY_CODE
   _saclEnabled = InitLocalPrivileges();
   #endif
@@ -293,9 +311,9 @@ CArchiveExtractCallback::CArchiveExtractCallback():
 
 void CArchiveExtractCallback::InitBeforeNewArchive()
 {
- #if defined(_WIN32) && !defined(UNDER_CE)
+#if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
   ZoneBuf.Free();
- #endif
+#endif
 }
 
 void CArchiveExtractCallback::Init(
@@ -312,37 +330,31 @@ void CArchiveExtractCallback::Init(
   _outFileStream.Release();
   _bufPtrSeqOutStream.Release();
   
-  #ifdef SUPPORT_LINKS
+#ifdef SUPPORT_LINKS
   _hardLinks.Clear();
-  #endif
+  _postLinks.Clear();
+#endif
 
-  #ifdef SUPPORT_ALT_STREAMS
+#ifdef SUPPORT_ALT_STREAMS
   _renamedFiles.Clear();
-  #endif
+#endif
 
   _ntOptions = ntOptions;
   _wildcardCensor = wildcardCensor;
-
   _stdOutMode = stdOutMode;
   _testMode = testMode;
-  
-  // _progressTotal = 0;
-  // _progressTotal_Defined = false;
-  
   _packTotal = packSize;
   _progressTotal = packSize;
-  _progressTotal_Defined = true;
-
+  // _progressTotal = 0;
+  // _progressTotal_Defined = false;
+  // _progressTotal_Defined = true;
   _extractCallback2 = extractCallback2;
-  
   /*
   _compressProgress.Release();
   _extractCallback2.QueryInterface(IID_ICompressProgressInfo, &_compressProgress);
-  
   _callbackMessage.Release();
   _extractCallback2.QueryInterface(IID_IArchiveExtractCallbackMessage2, &_callbackMessage);
   */
-  
   _folderArchiveExtractCallback2.Release();
   _extractCallback2.QueryInterface(IID_IFolderArchiveExtractCallback2, &_folderArchiveExtractCallback2);
 
@@ -390,7 +402,7 @@ Z7_COM7F_IMF(CArchiveExtractCallback::SetTotal(UInt64 size))
 {
   COM_TRY_BEGIN
   _progressTotal = size;
-  _progressTotal_Defined = true;
+  // _progressTotal_Defined = true;
   if (!_multiArchives && _extractCallback2)
     return _extractCallback2->SetTotal(size);
   return S_OK;
@@ -430,7 +442,7 @@ Z7_COM7F_IMF(CArchiveExtractCallback::SetCompleted(const UInt64 *completeValue))
   if (_multiArchives)
   {
     packCur = LocalProgressSpec->InSize;
-    if (completeValue && _progressTotal_Defined)
+    if (completeValue /* && _progressTotal_Defined */)
       packCur += MyMultDiv64(*completeValue, _progressTotal, _packTotal);
     completeValue = &packCur;
   }
@@ -443,12 +455,13 @@ Z7_COM7F_IMF(CArchiveExtractCallback::SetCompleted(const UInt64 *completeValue))
 Z7_COM7F_IMF(CArchiveExtractCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
 {
   COM_TRY_BEGIN
-  return _localProgress->SetRatioInfo(inSize, outSize);
+  return LocalProgressSpec.Interface()->SetRatioInfo(inSize, outSize);
   COM_TRY_END
 }
 
 
-void CArchiveExtractCallback::CreateComplexDirectory(const UStringVector &dirPathParts, FString &fullPath)
+void CArchiveExtractCallback::CreateComplexDirectory(
+    const UStringVector &dirPathParts, bool isFinal, FString &fullPath)
 {
   // we use (_item.IsDir) in this function
 
@@ -480,7 +493,7 @@ void CArchiveExtractCallback::CreateComplexDirectory(const UStringVector &dirPat
     const UString &s = dirPathParts[i];
     fullPath += us2fs(s);
 
-    const bool isFinalDir = (i == dirPathParts.Size() - 1 && _item.IsDir);
+    const bool isFinalDir = (i == dirPathParts.Size() - 1 && isFinal && _item.IsDir);
     
     if (fullPath.IsEmpty())
     {
@@ -541,7 +554,7 @@ static void AddPathToMessage(UString &s, const FString &path)
   s += fs2us(path);
 }
 
-HRESULT CArchiveExtractCallback::SendMessageError(const char *message, const FString &path)
+HRESULT CArchiveExtractCallback::SendMessageError(const char *message, const FString &path) const
 {
   UString s (message);
   AddPathToMessage(s, path);
@@ -549,7 +562,7 @@ HRESULT CArchiveExtractCallback::SendMessageError(const char *message, const FSt
 }
 
 
-HRESULT CArchiveExtractCallback::SendMessageError_with_Error(HRESULT errorCode, const char *message, const FString &path)
+HRESULT CArchiveExtractCallback::SendMessageError_with_Error(HRESULT errorCode, const char *message, const FString &path) const
 {
   UString s (message);
   if (errorCode != S_OK)
@@ -561,13 +574,13 @@ HRESULT CArchiveExtractCallback::SendMessageError_with_Error(HRESULT errorCode,
   return _extractCallback2->MessageError(s);
 }
 
-HRESULT CArchiveExtractCallback::SendMessageError_with_LastError(const char *message, const FString &path)
+HRESULT CArchiveExtractCallback::SendMessageError_with_LastError(const char *message, const FString &path) const
 {
   const HRESULT errorCode = GetLastError_noZero_HRESULT();
   return SendMessageError_with_Error(errorCode, message, path);
 }
 
-HRESULT CArchiveExtractCallback::SendMessageError2(HRESULT errorCode, const char *message, const FString &path1, const FString &path2)
+HRESULT CArchiveExtractCallback::SendMessageError2(HRESULT errorCode, const char *message, const FString &path1, const FString &path2) const
 {
   UString s (message);
   if (errorCode != 0)
@@ -580,15 +593,32 @@ HRESULT CArchiveExtractCallback::SendMessageError2(HRESULT errorCode, const char
   return _extractCallback2->MessageError(s);
 }
 
+HRESULT CArchiveExtractCallback::SendMessageError2_with_LastError(
+    const char *message, const FString &path1, const FString &path2) const
+{
+  const HRESULT errorCode = GetLastError_noZero_HRESULT();
+  return SendMessageError2(errorCode, message, path1, path2);
+}
+
 #ifndef Z7_SFX
 
+Z7_CLASS_IMP_COM_1(
+  CGetProp
+  , IGetProp
+)
+public:
+  UInt32 IndexInArc;
+  const CArc *Arc;
+  // UString BaseName; // relative path
+};
+
 Z7_COM7F_IMF(CGetProp::GetProp(PROPID propID, PROPVARIANT *value))
 {
   /*
-  if (propID == kpidName)
+  if (propID == kpidBaseName)
   {
     COM_TRY_BEGIN
-    NCOM::CPropVariant prop = Name;
+    NCOM::CPropVariant prop = BaseName;
     prop.Detach(value);
     return S_OK;
     COM_TRY_END
@@ -600,38 +630,25 @@ Z7_COM7F_IMF(CGetProp::GetProp(PROPID propID, PROPVARIANT *value))
 #endif // Z7_SFX
 
 
-#ifdef SUPPORT_LINKS
-
-static UString GetDirPrefixOf(const UString &src)
-{
-  UString s (src);
-  if (!s.IsEmpty())
-  {
-    if (IsPathSepar(s.Back()))
-      s.DeleteBack();
-    int pos = s.ReverseFind_PathSepar();
-    s.DeleteFrom((unsigned)(pos + 1));
-  }
-  return s;
-}
-
-#endif // SUPPORT_LINKS
-
 struct CLinkLevelsInfo
 {
   bool IsAbsolute;
+  bool ParentDirDots_after_NonParent;
   int LowLevel;
   int FinalLevel;
 
-  void Parse(const UString &path);
+  void Parse(const UString &path, bool isWSL);
 };
 
-void CLinkLevelsInfo::Parse(const UString &path)
+void CLinkLevelsInfo::Parse(const UString &path, bool isWSL)
 {
-  IsAbsolute = NName::IsAbsolutePath(path);
-
+  IsAbsolute = isWSL ?
+      IS_PATH_SEPAR(path[0]) :
+      NName::IsAbsolutePath(path);
   LowLevel = 0;
   FinalLevel = 0;
+  ParentDirDots_after_NonParent = false;
+  bool nonParentDir = false;
 
   UStringVector parts;
   SplitPathToParts(path, parts);
@@ -646,32 +663,41 @@ void CLinkLevelsInfo::Parse(const UString &path)
         IsAbsolute = true;
       continue;
     }
-    if (s == L".")
+    if (s.IsEqualTo("."))
       continue;
-    if (s == L"..")
+    if (s.IsEqualTo(".."))
     {
+      if (IsAbsolute || nonParentDir)
+        ParentDirDots_after_NonParent = true;
       level--;
       if (LowLevel > level)
-        LowLevel = level;
+          LowLevel = level;
     }
     else
+    {
+      nonParentDir = true;
       level++;
+    }
   }
   
   FinalLevel = level;
 }
 
 
-bool IsSafePath(const UString &path);
-bool IsSafePath(const UString &path)
+static bool IsSafePath(const UString &path, bool isWSL)
 {
   CLinkLevelsInfo levelsInfo;
-  levelsInfo.Parse(path);
+  levelsInfo.Parse(path, isWSL);
   return !levelsInfo.IsAbsolute
       && levelsInfo.LowLevel >= 0
       && levelsInfo.FinalLevel > 0;
 }
 
+bool IsSafePath(const UString &path);
+bool IsSafePath(const UString &path)
+{
+  return IsSafePath(path, false); // isWSL
+}
 
 bool CensorNode_CheckPath2(const NWildcard::CCensorNode &node, const CReadArcItem &item, bool &include);
 bool CensorNode_CheckPath2(const NWildcard::CCensorNode &node, const CReadArcItem &item, bool &include)
@@ -787,159 +813,113 @@ HRESULT CArchiveExtractCallback::MyCopyFile(ISequentialOutStream *outStream)
 
 HRESULT CArchiveExtractCallback::ReadLink()
 {
-  IInArchive *archive = _arc->Archive;
+  IInArchive * const archive = _arc->Archive;
   const UInt32 index = _index;
-  _link.Clear();
-
+  // _link.Clear(); // _link.Clear() was called already.
   {
     NCOM::CPropVariant prop;
     RINOK(archive->GetProperty(index, kpidHardLink, &prop))
     if (prop.vt == VT_BSTR)
     {
-      _link.isHardLink = true;
-      // _link.isCopyLink = false;
+      _link.LinkType = k_LinkType_HardLink;
       _link.isRelative = false; // RAR5, TAR: hard links are from root folder of archive
-      _link.linkPath.SetFromBstr(prop.bstrVal);
+      _link.LinkPath.SetFromBstr(prop.bstrVal);
+      // 7-Zip 24-: tar handler returned original path (with linux slash in most case)
+      // 7-Zip 24-: rar5 handler returned path with system slash.
+      // 7-Zip 25+: tar/rar5 handlers return linux path in most cases.
     }
     else if (prop.vt != VT_EMPTY)
       return E_FAIL;
   }
-  
   /*
   {
     NCOM::CPropVariant prop;
     RINOK(archive->GetProperty(index, kpidCopyLink, &prop));
     if (prop.vt == VT_BSTR)
     {
-      _link.isHardLink = false;
-      _link.isCopyLink = true;
+      _link.LinkType = k_LinkType_CopyLink;
       _link.isRelative = false; // RAR5: copy links are from root folder of archive
-      _link.linkPath.SetFromBstr(prop.bstrVal);
+      _link.LinkPath.SetFromBstr(prop.bstrVal);
     }
     else if (prop.vt != VT_EMPTY)
       return E_FAIL;
   }
   */
-
   {
     NCOM::CPropVariant prop;
     RINOK(archive->GetProperty(index, kpidSymLink, &prop))
     if (prop.vt == VT_BSTR)
     {
-      _link.isHardLink = false;
-      // _link.isCopyLink = false;
-      _link.isRelative = true; // RAR5, TAR: symbolic links can be relative
-      _link.linkPath.SetFromBstr(prop.bstrVal);
+      _link.LinkType = k_LinkType_PureSymLink;
+      _link.isRelative = true; // RAR5, TAR: symbolic links are relative by default
+      _link.LinkPath.SetFromBstr(prop.bstrVal);
+      // 7-Zip 24-: (tar, cpio, xar, ext, iso) handlers returned returned original path (with linux slash in most case)
+      // 7-Zip 24-: rar5 handler returned path with system slash.
+      // 7-Zip 25+: all handlers return linux path in most cases.
     }
     else if (prop.vt != VT_EMPTY)
       return E_FAIL;
   }
 
-  NtReparse_Data = NULL;
-  NtReparse_Size = 0;
-
-  if (_link.linkPath.IsEmpty() && _arc->GetRawProps)
+  // linux path separator in (_link.LinkPath) is expected for most cases,
+  // if new handler code is used, and if data in archive is correct.
+  // NtReparse_Data = NULL;
+  // NtReparse_Size = 0;
+  if (!_link.LinkPath.IsEmpty())
+  {
+    REPLACE_SLASHES_from_Linux_to_Sys(_link.LinkPath)
+  }
+  else if (_arc->GetRawProps)
   {
     const void *data;
-    UInt32 dataSize;
-    UInt32 propType;
-    
-    _arc->GetRawProps->GetRawProp(_index, kpidNtReparse, &data, &dataSize, &propType);
-    
-    // if (dataSize == 1234567) // for debug: unpacking without reparse
-    if (dataSize != 0)
+    UInt32 dataSize, propType;
+    if (_arc->GetRawProps->GetRawProp(_index, kpidNtReparse, &data, &dataSize, &propType) == S_OK
+        // && dataSize == 1234567 // for debug: unpacking without reparse
+        && dataSize)
     {
       if (propType != NPropDataType::kRaw)
         return E_FAIL;
-  
       // 21.06: we need kpidNtReparse in linux for wim archives created in Windows
-      // #ifdef _WIN32
-
-      NtReparse_Data = data;
-      NtReparse_Size = dataSize;
-
-      CReparseAttr reparse;
-      bool isOkReparse = reparse.Parse((const Byte *)data, dataSize);
-      if (isOkReparse)
-      {
-        _link.isHardLink = false;
-        // _link.isCopyLink = false;
-        _link.linkPath = reparse.GetPath();
-        _link.isJunction = reparse.IsMountPoint();
-
-        if (reparse.IsSymLink_WSL())
-        {
-          _link.isWSL = true;
-          _link.isRelative = reparse.IsRelative_WSL();
-        }
-        else
-          _link.isRelative = reparse.IsRelative_Win();
-
-        // const AString s = GetAnsiString(_link.linkPath);
-        // printf("\n_link.linkPath: %s\n", s.Ptr());
-
-        #ifndef _WIN32
-        _link.linkPath.Replace(L'\\', WCHAR_PATH_SEPARATOR);
-        #endif
-      }
-      // #endif
+      // NtReparse_Data = data;
+      // NtReparse_Size = dataSize;
+      // we ignore error code here, if there is failure of parsing:
+      _link.Parse_from_WindowsReparseData((const Byte *)data, dataSize);
     }
   }
 
-  if (_link.linkPath.IsEmpty())
+  if (_link.LinkPath.IsEmpty())
     return S_OK;
-
+  // (_link.LinkPath) uses system path separator.
+  // windows: (_link.LinkPath) doesn't contain linux separator (slash).
   {
-    #ifdef _WIN32
-    _link.linkPath.Replace(L'/', WCHAR_PATH_SEPARATOR);
-    #endif
-
-    // rar5 uses "\??\" prefix for absolute links
-    if (_link.linkPath.IsPrefixedBy(WSTRING_PATH_SEPARATOR L"??" WSTRING_PATH_SEPARATOR))
-    {
-      _link.isRelative = false;
-      _link.linkPath.DeleteFrontal(4);
-    }
-    
-    for (;;)
-    // while (NName::IsAbsolutePath(linkPath))
+    // _link.LinkPath = "\\??\\r:\\1\\2"; // for debug
+    // rar5+ returns kpidSymLink absolute link path with "\??\" prefix.
+    // we normalize such prefix:
+    if (_link.LinkPath.IsPrefixedBy(STRING_PATH_SEPARATOR "??" STRING_PATH_SEPARATOR))
     {
-      unsigned n = NName::GetRootPrefixSize(_link.linkPath);
-      if (n == 0)
-        break;
       _link.isRelative = false;
-      _link.linkPath.DeleteFrontal(n);
-    }
-  }
-
-  if (_link.linkPath.IsEmpty())
-    return S_OK;
-
-  if (!_link.isRelative && _removePathParts.Size() != 0)
-  {
-    UStringVector pathParts;
-    SplitPathToParts(_link.linkPath, pathParts);
-    bool badPrefix = false;
-    FOR_VECTOR (i, _removePathParts)
-    {
-      if (CompareFileNames(_removePathParts[i], pathParts[i]) != 0)
+       // we normalize prefix from "\??\" to "\\?\":
+      _link.LinkPath.ReplaceOneCharAtPos(1, WCHAR_PATH_SEPARATOR);
+      _link.isWindowsPath = true;
+      if (_link.LinkPath.IsPrefixedBy_Ascii_NoCase(
+          STRING_PATH_SEPARATOR
+          STRING_PATH_SEPARATOR "?"
+          STRING_PATH_SEPARATOR "UNC"
+          STRING_PATH_SEPARATOR))
       {
-        badPrefix = true;
-        break;
+         // we normalize prefix from "\\?\UNC\path" to "\\path":
+        _link.LinkPath.DeleteFrontal(6);
+        _link.LinkPath.ReplaceOneCharAtPos(0, WCHAR_PATH_SEPARATOR);
+      }
+      else
+      {
+        const unsigned k_prefix_Size = 4;
+        if (NName::IsDrivePath(_link.LinkPath.Ptr(k_prefix_Size)))
+          _link.LinkPath.DeleteFrontal(k_prefix_Size);
       }
     }
-    if (!badPrefix)
-      pathParts.DeleteFrontal(_removePathParts.Size());
-    _link.linkPath = MakePathFromParts(pathParts);
-  }
-
-  /*
-  if (!_link.linkPath.IsEmpty())
-  {
-    printf("\n_link %s to -> %s\n", GetOemString(_item.Path).Ptr(), GetOemString(_link.linkPath).Ptr());
   }
-  */
-
+  _link.Normalize_to_RelativeSafe(_removePathParts);
   return S_OK;
 }
 
@@ -949,7 +929,7 @@ HRESULT CArchiveExtractCallback::ReadLink()
 #ifndef _WIN32
 
 static HRESULT GetOwner(IInArchive *archive,
-    UInt32 index, UInt32 pidName, UInt32 pidId, COwnerInfo &res)
+    UInt32 index, UInt32 pidName, UInt32 pidId, CProcessedFileInfo::COwnerInfo &res)
 {
   {
     NWindows::NCOM::CPropVariant prop;
@@ -957,7 +937,7 @@ static HRESULT GetOwner(IInArchive *archive,
     if (prop.vt == VT_UI4)
     {
       res.Id_Defined = true;
-      res.Id = prop.ulVal; // for debug
+      res.Id = prop.ulVal;
       // res.Id++; // for debug
       // if (pidId == kpidGroupId) res.Id += 7; // for debug
       // res.Id = 0; // for debug
@@ -989,7 +969,7 @@ static HRESULT GetOwner(IInArchive *archive,
 
 HRESULT CArchiveExtractCallback::Read_fi_Props()
 {
-  IInArchive *archive = _arc->Archive;
+  IInArchive * const archive = _arc->Archive;
   const UInt32 index = _index;
 
   _fi.Attrib_Defined = false;
@@ -1081,35 +1061,35 @@ void CArchiveExtractCallback::CorrectPathParts()
 }
 
 
-void CArchiveExtractCallback::GetFiTimesCAM(CFiTimesCAM &pt)
+static void GetFiTimesCAM(const CProcessedFileInfo &fi, CFiTimesCAM &pt, const CArc &arc)
 {
   pt.CTime_Defined = false;
   pt.ATime_Defined = false;
   pt.MTime_Defined = false;
 
-  if (Write_MTime)
+  // if (Write_MTime)
   {
-    if (_fi.MTime.Def)
+    if (fi.MTime.Def)
     {
-      _fi.MTime.Write_To_FiTime(pt.MTime);
+      fi.MTime.Write_To_FiTime(pt.MTime);
       pt.MTime_Defined = true;
     }
-    else if (_arc->MTime.Def)
+    else if (arc.MTime.Def)
     {
-      _arc->MTime.Write_To_FiTime(pt.MTime);
+      arc.MTime.Write_To_FiTime(pt.MTime);
       pt.MTime_Defined = true;
     }
   }
 
-  if (Write_CTime && _fi.CTime.Def)
+  if (/* Write_CTime && */ fi.CTime.Def)
   {
-    _fi.CTime.Write_To_FiTime(pt.CTime);
+    fi.CTime.Write_To_FiTime(pt.CTime);
     pt.CTime_Defined = true;
   }
 
-  if (Write_ATime && _fi.ATime.Def)
+  if (/* Write_ATime && */ fi.ATime.Def)
   {
-    _fi.ATime.Write_To_FiTime(pt.ATime);
+    fi.ATime.Write_To_FiTime(pt.ATime);
     pt.ATime_Defined = true;
   }
 }
@@ -1120,6 +1100,7 @@ void CArchiveExtractCallback::CreateFolders()
   // 21.04 : we don't change original (_item.PathParts) here
   UStringVector pathParts = _item.PathParts;
 
+  bool isFinal = true;
   // bool is_DirOp = false;
   if (!pathParts.IsEmpty())
   {
@@ -1129,12 +1110,15 @@ void CArchiveExtractCallback::CreateFolders()
                  but if we create dir item here, it's not problem. */
     if (!_item.IsDir
         #ifdef SUPPORT_LINKS
-        #ifndef WIN32
-          || !_link.linkPath.IsEmpty()
-        #endif
+        // #ifndef WIN32
+          || !_link.LinkPath.IsEmpty()
+        // #endif
         #endif
        )
+    {
       pathParts.DeleteBack();
+      isFinal = false; // last path part was excluded
+    }
     // else is_DirOp = true;
   }
     
@@ -1158,7 +1142,7 @@ void CArchiveExtractCallback::CreateFolders()
   */
 
   FString fullPathNew;
-  CreateComplexDirectory(pathParts, fullPathNew);
+  CreateComplexDirectory(pathParts, isFinal, fullPathNew);
 
   /*
   if (is_DirOp)
@@ -1179,12 +1163,12 @@ void CArchiveExtractCallback::CreateFolders()
     return;
 
   CDirPathTime pt;
-  GetFiTimesCAM(pt);
+  GetFiTimesCAM(_fi, pt, *_arc);
  
   if (pt.IsSomeTimeDefined())
   {
     pt.Path = fullPathNew;
-    pt.SetDirTime();
+    pt.SetDirTime_to_FS_2();
     _extractedFolders.Add(pt);
   }
 }
@@ -1269,8 +1253,7 @@ HRESULT CArchiveExtractCallback::CheckExistFile(FString &fullProcessedPath, bool
       // MyMoveFile can rename folders. So it's OK to use it for folders too
       if (!MyMoveFile(fullProcessedPath, existPath))
       {
-        HRESULT errorCode = GetLastError_noZero_HRESULT();
-        RINOK(SendMessageError2(errorCode, kCantRenameFile, existPath, fullProcessedPath))
+        RINOK(SendMessageError2_with_LastError(kCantRenameFile, existPath, fullProcessedPath))
         return E_FAIL;
       }
     }
@@ -1302,7 +1285,7 @@ HRESULT CArchiveExtractCallback::CheckExistFile(FString &fullProcessedPath, bool
   {
     #if defined(_WIN32) && !defined(UNDER_CE)
     // we need to clear READ-ONLY of parent before creating alt stream
-    int colonPos = NName::FindAltStreamColon(fullProcessedPath);
+    const int colonPos = NName::FindAltStreamColon(fullProcessedPath);
     if (colonPos >= 0 && fullProcessedPath[(unsigned)colonPos + 1] != 0)
     {
       FString parentFsPath (fullProcessedPath);
@@ -1311,7 +1294,11 @@ HRESULT CArchiveExtractCallback::CheckExistFile(FString &fullProcessedPath, bool
       if (parentFi.Find(parentFsPath))
       {
         if (parentFi.IsReadOnly())
+        {
+          _altStream_NeedRestore_Attrib_for_parentFsPath = parentFsPath;
+          _altStream_NeedRestore_AttribVal = parentFi.Attrib;
           SetFileAttrib(parentFsPath, parentFi.Attrib & ~(DWORD)FILE_ATTRIBUTE_READONLY);
+        }
       }
     }
     #endif // defined(_WIN32) && !defined(UNDER_CE)
@@ -1323,9 +1310,11 @@ HRESULT CArchiveExtractCallback::CheckExistFile(FString &fullProcessedPath, bool
 
 
 
-
-
-
+/*
+return:
+  needExit = false: caller will     use (outStreamLoc) and _hashStreamSpec
+  needExit = true : caller will not use (outStreamLoc) and _hashStreamSpec.
+*/
 HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream> &outStreamLoc, bool &needExit)
 {
   needExit = true;
@@ -1333,7 +1322,7 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
   RINOK(Read_fi_Props())
 
   #ifdef SUPPORT_LINKS
-  IInArchive *archive = _arc->Archive;
+  IInArchive * const archive = _arc->Archive;
   #endif
 
   const UInt32 index = _index;
@@ -1379,7 +1368,7 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
     if (isAnti)
       RemoveDir(_diskFilePath);
     #ifdef SUPPORT_LINKS
-    if (_link.linkPath.IsEmpty())
+    if (_link.LinkPath.IsEmpty())
     #endif
     {
       if (!isAnti)
@@ -1408,18 +1397,21 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
 
   #ifdef SUPPORT_LINKS
   
-  if (!_link.linkPath.IsEmpty())
+  if (!_link.LinkPath.IsEmpty())
   {
     #ifndef UNDER_CE
     {
       bool linkWasSet = false;
-      RINOK(SetFromLinkPath(fullProcessedPath, _link, linkWasSet))
+      RINOK(SetLink(fullProcessedPath, _link, linkWasSet))
+/*
+      // we don't set attributes for placeholder.
       if (linkWasSet)
       {
-        _isSymLinkCreated = _link.IsSymLink();
+        _isSymLinkCreated = _link.Is_AnySymLink();
         SetAttrib();
         // printf("\nlinkWasSet %s\n", GetAnsiString(_diskFilePath));
       }
+*/
     }
     #endif // UNDER_CE
 
@@ -1445,16 +1437,17 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
           hl = fullProcessedPath;
         else
         {
-          if (!MyCreateHardLink(fullProcessedPath, hl))
-          {
-            const HRESULT errorCode = GetLastError_noZero_HRESULT();
-            RINOK(SendMessageError2(errorCode, kCantCreateHardLink, fullProcessedPath, hl))
+          bool link_was_Created = false;
+          RINOK(CreateHardLink2(fullProcessedPath, hl, link_was_Created))
+          if (!link_was_Created)
             return S_OK;
-          }
-          
           // printf("\nHard linkWasSet Archive_Get_HardLinkNode %s\n", GetAnsiString(_diskFilePath));
           // _needSetAttrib = true; // do we need to set attribute ?
           SetAttrib();
+          /* if we set (needExit = false) here, _hashStreamSpec will be used,
+             and hash will be calulated for all hard links files (it's slower).
+             But "Test" operation also calculates hashes.
+          */
           needExit = false;
           return S_OK;
         }
@@ -1483,7 +1476,7 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
 
   bool is_SymLink_in_Data = false;
 
-  if (_curSize_Defined && _curSize > 0 && _curSize < (1 << 12))
+  if (_curSize_Defined && _curSize && _curSize < k_LinkDataSize_LIMIT)
   {
     if (_fi.IsLinuxSymLink())
     {
@@ -1505,7 +1498,7 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
     _bufPtrSeqOutStream_Spec->Init(_outMemBuf, _outMemBuf.Size());
     outStreamLoc = _bufPtrSeqOutStream;
   }
-  else // not reprase
+  else // not reparse
   {
     if (_ntOptions.PreAllocateOutFile && !_isSplit && _curSize_Defined && _curSize > (1 << 12))
     {
@@ -1560,7 +1553,7 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
       RINOK(outFileStream_Loc->Seek((Int64)_position, STREAM_SEEK_SET, NULL))
     }
     outStreamLoc = outFileStream_Loc;
-  } // if not reprase
+  } // if not reparse
 
   _outFileStream = outFileStream_Loc;
       
@@ -1607,37 +1600,36 @@ Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index, ISequentialOutStre
   _bufPtrSeqOutStream.Release();
 
   _encrypted = false;
-  _position = 0;
   _isSplit = false;
-  
-  _curSize = 0;
   _curSize_Defined = false;
   _fileLength_WasSet = false;
-  _fileLength_that_WasSet = 0;
-  _index = index;
-
-  _diskFilePath.Empty();
-
   _isRenamed = false;
-  
   // _fi.Clear();
-
-  // _is_SymLink_in_Data = false;
+  _extractMode = false;
   _is_SymLink_in_Data_Linux = false;
-  
   _needSetAttrib = false;
   _isSymLinkCreated = false;
   _itemFailure = false;
-
   _some_pathParts_wereRemoved = false;
   // _op_WasReported = false;
 
+  _position = 0;
+  _curSize = 0;
+  _fileLength_that_WasSet = 0;
+  _index = index;
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+  _altStream_NeedRestore_AttribVal = 0;
+  _altStream_NeedRestore_Attrib_for_parentFsPath.Empty();
+#endif
+
+  _diskFilePath.Empty();
+
   #ifdef SUPPORT_LINKS
   // _copyFile_Path.Empty();
   _link.Clear();
   #endif
 
-  _extractMode = false;
 
   switch (askExtractMode)
   {
@@ -1653,7 +1645,7 @@ Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index, ISequentialOutStre
   }
 
 
-  IInArchive *archive = _arc->Archive;
+  IInArchive * const archive = _arc->Archive;
 
   RINOK(GetItem(index))
 
@@ -1669,10 +1661,9 @@ Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index, ISequentialOutStre
     }
   }
 
-  #ifdef SUPPORT_LINKS
+#ifdef SUPPORT_LINKS
   RINOK(ReadLink())
-  #endif // SUPPORT_LINKS
-  
+#endif
   
   RINOK(Archive_GetItemBoolProp(archive, index, kpidEncrypted, _encrypted))
 
@@ -1692,6 +1683,19 @@ Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index, ISequentialOutStre
       return S_OK;
   }
 
+#if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
+  if (askExtractMode == NArchive::NExtract::NAskMode::kExtract
+      && !_testMode
+      && _item.IsAltStream
+      && ZoneBuf.Size() != 0
+      && Is_ZoneId_StreamName(_item.AltStreamName))
+    if (ZoneMode != NExtract::NZoneIdMode::kOffice
+        || _item.PathParts.IsEmpty()
+        || FindExt2(kOfficeExtensions, _item.PathParts.Back()))
+      return S_OK;
+#endif
+
+
   #ifndef Z7_SFX
   if (_use_baseParentFolder_mode)
   {
@@ -1810,15 +1814,11 @@ Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index, ISequentialOutStre
 
   if (ExtractToStreamCallback)
   {
-    if (!GetProp)
-    {
-      GetProp_Spec = new CGetProp;
-      GetProp = GetProp_Spec;
-    }
-    GetProp_Spec->Arc = _arc;
-    GetProp_Spec->IndexInArc = index;
+    CMyComPtr2_Create<IGetProp, CGetProp> GetProp;
+    GetProp->Arc = _arc;
+    GetProp->IndexInArc = index;
     UString name (MakePathFromParts(pathParts));
-    
+    // GetProp->BaseName = name;
     #ifdef SUPPORT_ALT_STREAMS
     if (_item.IsAltStream)
     {
@@ -1972,7 +1972,7 @@ HRESULT CArchiveExtractCallback::CloseFile()
  #endif
 
   CFiTimesCAM t;
-  GetFiTimesCAM(t);
+  GetFiTimesCAM(_fi, t, *_arc);
 
   // #ifdef _WIN32
   if (t.IsSomeTimeDefined())
@@ -1984,94 +1984,290 @@ HRESULT CArchiveExtractCallback::CloseFile()
 
   RINOK(_outFileStreamSpec->Close())
   _outFileStream.Release();
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+  if (!_altStream_NeedRestore_Attrib_for_parentFsPath.IsEmpty())
+  {
+    SetFileAttrib(_altStream_NeedRestore_Attrib_for_parentFsPath, _altStream_NeedRestore_AttribVal);
+    _altStream_NeedRestore_Attrib_for_parentFsPath.Empty();
+  }
+#endif
+
   return hres;
 }
 
 
 #ifdef SUPPORT_LINKS
 
+static bool CheckLinkPath_in_FS_for_pathParts(const FString &path, const UStringVector &v)
+{
+  FString path2 = path;
+  FOR_VECTOR (i, v)
+  {
+    // if (i == v.Size() - 1) path = path2; // we don't need last part in returned path
+    path2 += us2fs(v[i]);
+    NFind::CFileInfo fi;
+    // printf("\nCheckLinkPath_in_FS_for_pathParts(): %s\n", GetOemString(path2).Ptr());
+    if (fi.Find(path2) && fi.IsOsSymLink())
+      return false;
+    path2.Add_PathSepar();
+  }
+  return true;
+}
+
+/*
+link.isRelative / relative_item_PathPrefix
+   false        / empty
+   true         / item path without last part
+*/
+static bool CheckLinkPath_in_FS(
+    const FString &pathPrefix_in_FS,
+    const CPostLink &postLink,
+    const UString &relative_item_PathPrefix)
+{
+  const CLinkInfo &link = postLink.LinkInfo;
+  if (postLink.item_PathParts.IsEmpty() || link.LinkPath.IsEmpty())
+    return false;
+  FString path;
+  {
+    const UString &s = postLink.item_PathParts[0];
+    if (!s.IsEmpty() && !NName::IsAbsolutePath(s))
+      path = pathPrefix_in_FS; // item_PathParts is relative. So we use absolutre prefix
+  }
+  if (!CheckLinkPath_in_FS_for_pathParts(path, postLink.item_PathParts))
+    return false;
+  path += us2fs(relative_item_PathPrefix);
+  UStringVector v;
+  SplitPathToParts(link.LinkPath, v);
+  // we check target paths:
+  return CheckLinkPath_in_FS_for_pathParts(path, v);
+}
 
-HRESULT CArchiveExtractCallback::SetFromLinkPath(
-    const FString &fullProcessedPath,
-    const CLinkInfo &linkInfo,
-    bool &linkWasSet)
+static const unsigned k_DangLevel_MAX_for_Link_over_Link = 9;
+
+HRESULT CArchiveExtractCallback::CreateHardLink2(
+    const FString &newFilePath, const FString &existFilePath, bool &link_was_Created) const
+{
+  link_was_Created = false;
+  if (_ntOptions.SymLinks_DangerousLevel <= k_DangLevel_MAX_for_Link_over_Link)
+  {
+    NFind::CFileInfo fi;
+    if (fi.Find(existFilePath) && fi.IsOsSymLink())
+      return SendMessageError2(0, k_HardLink_to_SymLink_Ignored, newFilePath, existFilePath);
+  }
+  if (!MyCreateHardLink(newFilePath, existFilePath))
+    return SendMessageError2_with_LastError(kCantCreateHardLink, newFilePath, existFilePath);
+  link_was_Created = true;
+  return S_OK;
+}
+
+
+
+HRESULT CArchiveExtractCallback::SetLink(
+    const FString &fullProcessedPath_from,
+    const CLinkInfo &link,
+    bool &linkWasSet) // placeholder was created
 {
   linkWasSet = false;
-  if (!_ntOptions.SymLinks.Val && !linkInfo.isHardLink)
+  if (link.LinkPath.IsEmpty())
+    return S_OK;
+  if (!_ntOptions.SymLinks.Val && link.Is_AnySymLink())
     return S_OK;
+  CPostLink postLink;
+  postLink.Index_in_Arc = _index;
+  postLink.item_IsDir = _item.IsDir;
+  postLink.item_Path = _item.Path;
+  postLink.item_PathParts = _item.PathParts;
+  postLink.item_FileInfo = _fi;
+  postLink.fullProcessedPath_from = fullProcessedPath_from;
+  postLink.LinkInfo = link;
+  _postLinks.Add(postLink);
+  
+  // file doesn't exist in most cases. So we don't check for error.
+  DeleteLinkFileAlways_or_RemoveEmptyDir(fullProcessedPath_from, false); // checkThatFileIsEmpty = false
 
-  UString relatPath;
+  NIO::COutFile outFile;
+  if (!outFile.Create_NEW(fullProcessedPath_from))
+    return SendMessageError("Cannot create temporary link file", fullProcessedPath_from);
+#if 0 // 1 for debug
+  // here we can write link path to temporary link file placeholder,
+  // but empty placeholder is better, because we don't want to get any non-eampty data instead of link file.
+  AString s;
+  ConvertUnicodeToUTF8(link.LinkPath, s);
+  outFile.WriteFull(s, s.Len());
+#endif
+  linkWasSet = true;
+  return S_OK;
+}
 
-  /* if (linkInfo.isRelative)
-       linkInfo.linkPath is final link path that must be stored to file link field
-     else
-       linkInfo.linkPath is path from root of archive. So we must add _dirPathPrefix_Full before linkPath.
-  */
-     
-  if (linkInfo.isRelative)
-    relatPath = GetDirPrefixOf(_item.Path);
-  relatPath += linkInfo.linkPath;
-  
-  if (!IsSafePath(relatPath))
+
+// if file/dir is symbolic link it will remove only link itself
+HRESULT CArchiveExtractCallback::DeleteLinkFileAlways_or_RemoveEmptyDir(
+    const FString &path, bool checkThatFileIsEmpty) const
+{
+  NFile::NFind::CFileInfo fi;
+  if (fi.Find(path)) // followLink = false
   {
-    return SendMessageError2(
-          0, // errorCode
-          "Dangerous link path was ignored",
-          us2fs(_item.Path),
-          us2fs(linkInfo.linkPath)); // us2fs(relatPath)
+    if (fi.IsDir())
+    {
+      if (RemoveDirAlways_if_Empty(path))
+        return S_OK;
+    }
+    else
+    {
+      // link file placeholder must be empty
+      if (checkThatFileIsEmpty && !fi.IsOsSymLink() && fi.Size != 0)
+        return SendMessageError("Temporary link file is not empty", path);
+      if (DeleteFileAlways(path))
+        return S_OK;
+    }
+    if (GetLastError() != ERROR_FILE_NOT_FOUND)
+      return SendMessageError_with_LastError(
+          fi.IsDir() ?
+            k_CantDelete_Dir_for_SymLink:
+            k_CantDelete_File_for_SymLink,
+          path);
   }
+  return S_OK;
+}
+
+
+/*
+in:
+  link.LinkPath : must be relative (non-absolute) path in any case !!!
+  link.isRelative / target path that must stored as created link:
+       == false   / _dirPathPrefix_Full + link.LinkPath
+       == true    / link.LinkPath
+*/
+static HRESULT SetLink2(const CArchiveExtractCallback &callback,
+    const CPostLink &postLink, bool &linkWasSet)
+{
+  const CLinkInfo &link = postLink.LinkInfo;
+  const FString &fullProcessedPath_from = postLink.fullProcessedPath_from; // full file path in FS (fullProcessedPath_from)
 
-  FString existPath;
-  if (linkInfo.isHardLink /* || linkInfo.IsCopyLink */ || !linkInfo.isRelative)
+  const unsigned level = callback._ntOptions.SymLinks_DangerousLevel;
+  if (level < 20)
   {
-    if (!NName::GetFullPath(_dirPathPrefix_Full, us2fs(relatPath), existPath))
+    /*
+    We want to use additional check for links that can link to directory.
+      - linux: all symbolic links are files.
+      - windows: we can have file/directory symbolic link,
+        but file symbolic link works like directory link in windows.
+    So we use additional check for all relative links.
+
+    We don't allow decreasing of final level of link.
+    So if some another extracted file will use this link,
+    then number of real path parts (after link redirection) cannot be
+    smaller than number of requested path parts from archive records.
+    
+    here we check only (link.LinkPath) without (_item.PathParts).
+    */
+    CLinkLevelsInfo li;
+    li.Parse(link.LinkPath, link.Is_WSL());
+    bool isDang;
+    UString relativePathPrefix;
+    if (li.IsAbsolute // unexpected
+        || li.ParentDirDots_after_NonParent
+        || (level <= 5 && link.isRelative && li.FinalLevel < 1) // final level lower
+        || (level <= 5 && link.isRelative && li.LowLevel < 0)   // negative temporary levels
+       )
+      isDang = true;
+    else // if (!isDang)
     {
-      RINOK(SendMessageError("Incorrect path", us2fs(relatPath)))
-    }
+      UString path;
+      if (link.isRelative)
+      {
+        // item_PathParts : parts that will be created in output folder.
+        // we want to get directory prefix of link item.
+        // so we remove file name (last non-empty part) from PathParts:
+        UStringVector v = postLink.item_PathParts;
+        while (!v.IsEmpty())
+        {
+          const unsigned len = v.Back().Len();
+          v.DeleteBack();
+          if (len)
+            break;
+        }
+        path = MakePathFromParts(v);
+        NName::NormalizeDirPathPrefix(path);
+        relativePathPrefix = path;
+      }
+      path += link.LinkPath;
+      /*
+      path is calculated virtual target path of link
+      path is relative to root folder of extracted items
+      if (!link.isRelative), then (path == link.LinkPath)
+      */
+      isDang = false;
+      if (!IsSafePath(path, link.Is_WSL()))
+        isDang = true;
+    }
+    const char *message = NULL;
+    if (isDang)
+      message = "Dangerous link path was ignored";
+    else if (level <= k_DangLevel_MAX_for_Link_over_Link
+        && !CheckLinkPath_in_FS(callback._dirPathPrefix_Full,
+            postLink, relativePathPrefix))
+      message = "Dangerous link via another link was ignored";
+    if (message)
+       return callback.SendMessageError2(0, // errorCode
+            message, us2fs(postLink.item_Path), us2fs(link.LinkPath));
+  }
+
+  FString target; // target path that will be stored to link field
+  if (link.Is_HardLink() /* || link.IsCopyLink */ || !link.isRelative)
+  {
+    // isRelative == false
+    // all hard links and absolute symbolic links
+    // relatPath == link.LinkPath
+    // we get absolute link path for target:
+    if (!NName::GetFullPath(callback._dirPathPrefix_Full, us2fs(link.LinkPath), target))
+      return callback.SendMessageError("Incorrect link path", us2fs(link.LinkPath));
+    // (target) is (_dirPathPrefix_Full + relatPath)
   }
   else
   {
-    existPath = us2fs(linkInfo.linkPath);
-    // printf("\nlinkPath = : %s\n", GetOemString(linkInfo.linkPath).Ptr());
+    // link.isRelative == true
+    // relative symbolic links only
+    target = us2fs(link.LinkPath);
   }
-    
-  if (existPath.IsEmpty())
-    return SendMessageError("Empty link", fullProcessedPath);
+  if (target.IsEmpty())
+    return callback.SendMessageError("Empty link", fullProcessedPath_from);
 
-  if (linkInfo.isHardLink /* || linkInfo.IsCopyLink */)
+  if (link.Is_HardLink() /* || link.IsCopyLink */)
   {
-    // if (linkInfo.isHardLink)
+    // if (link.isHardLink)
     {
-      if (!MyCreateHardLink(fullProcessedPath, existPath))
+      RINOK(callback.DeleteLinkFileAlways_or_RemoveEmptyDir(fullProcessedPath_from, true)) // checkThatFileIsEmpty
       {
-        const HRESULT errorCode = GetLastError_noZero_HRESULT();
-        RINOK(SendMessageError2(errorCode, kCantCreateHardLink, fullProcessedPath, existPath))
+        // RINOK(SendMessageError_with_LastError(k_Cant_DeleteTempLinkFile, fullProcessedPath_from))
       }
+      return callback.CreateHardLink2(fullProcessedPath_from, target, linkWasSet);
       /*
       RINOK(PrepareOperation(NArchive::NExtract::NAskMode::kExtract))
       _op_WasReported = true;
       RINOK(SetOperationResult(NArchive::NExtract::NOperationResult::kOK))
-      */
       linkWasSet = true;
       return S_OK;
+      */
     }
     /*
     // IsCopyLink
     {
       NFind::CFileInfo fi;
-      if (!fi.Find(existPath))
+      if (!fi.Find(target))
       {
-        RINOK(SendMessageError2("Cannot find the file for copying", existPath, fullProcessedPath));
+        RINOK(SendMessageError2("Cannot find the file for copying", target, fullProcessedPath));
       }
       else
       {
         if (_curSize_Defined && _curSize == fi.Size)
-          _copyFile_Path = existPath;
+          _copyFile_Path = target;
         else
         {
-          RINOK(SendMessageError2("File size collision for file copying", existPath, fullProcessedPath));
+          RINOK(SendMessageError2("File size collision for file copying", target, fullProcessedPath));
         }
-        // RINOK(MyCopyFile(existPath, fullProcessedPath));
+        // RINOK(MyCopyFile(target, fullProcessedPath));
       }
     }
     */
@@ -2085,127 +2281,227 @@ HRESULT CArchiveExtractCallback::SetFromLinkPath(
     // Windows before Vista doesn't support symbolic links.
     // we could convert such symbolic links to Junction Points
     // isJunction = true;
-    // convertToAbs = true;
   }
   */
 
-  if (!_ntOptions.SymLinks_AllowDangerous.Val)
-  {
-    #ifdef _WIN32
-    if (_item.IsDir)
-    #endif
-    if (linkInfo.isRelative)
-      {
-        CLinkLevelsInfo levelsInfo;
-        levelsInfo.Parse(linkInfo.linkPath);
-        if (levelsInfo.FinalLevel < 1 || levelsInfo.IsAbsolute)
-        {
-          return SendMessageError2(
-            0, // errorCode
-            "Dangerous symbolic link path was ignored",
-            us2fs(_item.Path),
-            us2fs(linkInfo.linkPath));
-        }
-      }
-  }
+#ifdef _WIN32
+  const bool isDir = (postLink.item_IsDir || link.LinkType == k_LinkType_Junction);
+#endif
 
-  
-  #ifdef _WIN32
-  
+ 
+#ifdef _WIN32
   CByteBuffer data;
-  // printf("\nFillLinkData(): %s\n", GetOemString(existPath).Ptr());
-  if (!FillLinkData(data, fs2us(existPath), !linkInfo.isJunction, linkInfo.isWSL))
-    return SendMessageError("Cannot fill link data", us2fs(_item.Path));
-
-  /*
-  if (NtReparse_Size != data.Size() || memcmp(NtReparse_Data, data, data.Size()) != 0)
+  // printf("\nFillLinkData(): %s\n", GetOemString(target).Ptr());
+  if (link.Is_WSL())
   {
-    SendMessageError("reconstructed Reparse is different", fs2us(existPath));
+    Convert_WinPath_to_WslLinuxPath(target, !link.isRelative);
+    FillLinkData_WslLink(data, fs2us(target));
   }
+  else
+    FillLinkData_WinLink(data, fs2us(target), link.LinkType != k_LinkType_Junction);
+  if (data.Size() == 0)
+    return callback.SendMessageError("Cannot fill link data", us2fs(postLink.item_Path));
+  /*
+  if (NtReparse_Size != data.Size() || memcmp(NtReparse_Data, data, data.Size()) != 0)
+    SendMessageError("reconstructed Reparse is different", fs2us(target));
   */
-  
-  CReparseAttr attr;
-  if (!attr.Parse(data, data.Size()))
   {
-    RINOK(SendMessageError("Internal error for symbolic link file", us2fs(_item.Path)))
-    return S_OK;
-  }
-  if (!NFile::NIO::SetReparseData(fullProcessedPath, _item.IsDir, data, (DWORD)data.Size()))
-  {
-    RINOK(SendMessageError_with_LastError(kCantCreateSymLink, fullProcessedPath))
-    return S_OK;
+    // we check that reparse data is correct, but we ignore attr.MinorError.
+    CReparseAttr attr;
+    if (!attr.Parse(data, data.Size()))
+      return callback.SendMessageError("Internal error for symbolic link file", us2fs(postLink.item_Path));
   }
-  linkWasSet = true;
-
-  return S_OK;
-  
-  
-  #else // ! _WIN32
+#endif
 
-  if (!NFile::NIO::SetSymLink(fullProcessedPath, existPath))
+  RINOK(callback.DeleteLinkFileAlways_or_RemoveEmptyDir(fullProcessedPath_from, true)) // checkThatFileIsEmpty
+#ifdef _WIN32
+  if (!NFile::NIO::SetReparseData(fullProcessedPath_from, isDir, data, (DWORD)data.Size()))
+#else // ! _WIN32
+  if (!NFile::NIO::SetSymLink(fullProcessedPath_from, target))
+#endif // ! _WIN32
   {
-    RINOK(SendMessageError_with_LastError(kCantCreateSymLink, fullProcessedPath))
-    return S_OK;
+    return callback.SendMessageError_with_LastError(kCantCreateSymLink, fullProcessedPath_from);
   }
   linkWasSet = true;
-
   return S_OK;
-
-  #endif // ! _WIN32
 }
 
 
-bool CLinkInfo::Parse(const Byte *data, size_t dataSize, bool isLinuxData)
-{
-  Clear();
-  // this->isLinux = isLinuxData;
-  
-  if (isLinuxData)
-  {
-    isJunction = false;
-    isHardLink = false;
-    AString utf;
-    if (dataSize >= (1 << 12))
-      return false;
-    utf.SetFrom_CalcLen((const char *)data, (unsigned)dataSize);
-    UString u;
-    if (!ConvertUTF8ToUnicode(utf, u))
-      return false;
-    linkPath = u;
-    
-    // in linux symbolic data: we expect that linux separator '/' is used
-    // if windows link was created, then we also must use linux separator
-    if (u.IsEmpty())
-      return false;
-    const wchar_t c = u[0];
-    isRelative = !IS_PATH_SEPAR(c);
-    return true;
-  }
 
+bool CLinkInfo::Parse_from_WindowsReparseData(const Byte *data, size_t dataSize)
+{
   CReparseAttr reparse;
   if (!reparse.Parse(data, dataSize))
     return false;
-  isHardLink = false;
-  // isCopyLink = false;
-  linkPath = reparse.GetPath();
-  isJunction = reparse.IsMountPoint();
-  
+  // const AString s = GetAnsiString(LinkPath);
+  // printf("\nlinkPath: %s\n", s.Ptr());
+  LinkPath = reparse.GetPath();
   if (reparse.IsSymLink_WSL())
   {
-    isWSL = true;
-    isRelative = reparse.IsRelative_WSL();
+    LinkType = k_LinkType_WSL;
+    isRelative = reparse.IsRelative_WSL(); // detected from LinkPath[0]
+    // LinkPath is original raw name converted to UString from AString
+    // Linux separator '/' is expected here.
+    REPLACE_SLASHES_from_Linux_to_Sys(LinkPath)
   }
   else
-    isRelative = reparse.IsRelative_Win();
-    
-  // FIXME !!!
-  #ifndef _WIN32
-  linkPath.Replace(L'\\', WCHAR_PATH_SEPARATOR);
-  #endif
-  
+  {
+    LinkType = reparse.IsMountPoint() ? k_LinkType_Junction : k_LinkType_PureSymLink;
+    isRelative = reparse.IsRelative_Win(); // detected by (Flags == Z7_WIN_SYMLINK_FLAG_RELATIVE)
+    isWindowsPath = true;
+    // LinkPath is original windows link path from raparse data with \??\ prefix removed.
+    // windows '\\' separator is expected here.
+    // linux '/' separator is not expected here.
+    // we translate both types of separators to system separator.
+    LinkPath.Replace(
+#if WCHAR_PATH_SEPARATOR == L'\\'
+        L'/'
+#else
+        L'\\'
+#endif
+        , WCHAR_PATH_SEPARATOR);
+  }
+  // (LinkPath) uses system path separator.
+  // windows: (LinkPath) doesn't contain linux separator (slash).
+  return true;
+}
+
+
+bool CLinkInfo::Parse_from_LinuxData(const Byte *data, size_t dataSize)
+{
+  // Clear(); // *this object was cleared by constructor already.
+  LinkType = k_LinkType_PureSymLink;
+  AString utf;
+  if (dataSize >= k_LinkDataSize_LIMIT)
+    return false;
+  utf.SetFrom_CalcLen((const char *)data, (unsigned)dataSize);
+  UString u;
+  if (!ConvertUTF8ToUnicode(utf, u))
+    return false;
+  if (u.IsEmpty())
+    return false;
+  const wchar_t c = u[0];
+  isRelative = (c != L'/');
+  // linux path separator is expected
+  REPLACE_SLASHES_from_Linux_to_Sys(u)
+  LinkPath = u;
+  // (LinkPath) uses system path separator.
+  // windows: (LinkPath) doesn't contain linux separator (slash).
   return true;
 }
     
+
+// in/out:          (LinkPath) uses system path separator
+// in/out: windows: (LinkPath) doesn't contain linux separator (slash).
+// out: (LinkPath) is relative path, and LinkPath[0] is not path separator
+// out: isRelative changed to false, if any prefix was removed.
+// note: absolute windows links "c:\" to root will be reduced to empty string:
+void CLinkInfo::Remove_AbsPathPrefixes()
+{
+  while (!LinkPath.IsEmpty())
+  {
+    unsigned n = 0;
+    if (!Is_WSL())
+    {
+      n =
+#ifndef _WIN32
+      isWindowsPath ?
+        NName::GetRootPrefixSize_WINDOWS(LinkPath) :
+#endif
+        NName::GetRootPrefixSize(LinkPath);
+/*
+      // "c:path" will be ignored later as "Dangerous absolute path"
+      // so check is not required
+      if (n == 0
+#ifndef _WIN32
+          && isWindowsPath
+#endif
+          && NName::IsDrivePath2(LinkPath))
+        n = 2;
+*/
+    }
+    if (n == 0)
+    {
+      if (!IS_PATH_SEPAR(LinkPath[0]))
+        break;
+      n = 1;
+    }
+    isRelative = false; // (LinkPath) will be treated as relative to root folder of archive
+    LinkPath.DeleteFrontal(n);
+  }
+}
+
+
+/*
+  it removes redundant separators, if there are double separators,
+  but it keeps double separators at start of string //name/.
+  in/out:    system path separator is used
+    windows: slash character (linux separator) is not treated as separator
+    windows: (path) doesn't contain linux separator (slash).
+*/
+static void RemoveRedundantPathSeparators(UString &path)
+{
+  wchar_t *dest = path.GetBuf();
+  const wchar_t * const start = dest;
+  const wchar_t *src = dest;
+  for (;;)
+  {
+    wchar_t c = *src++;
+    if (c == 0)
+      break;
+    // if (IS_PATH_SEPAR(c)) // for Windows: we can change (/) to (\).
+    if (c == WCHAR_PATH_SEPARATOR)
+    {
+      if (dest - start >= 2 && dest[-1] == WCHAR_PATH_SEPARATOR)
+        continue;
+      // c = WCHAR_PATH_SEPARATOR; // for Windows: we can change (/) to (\).
+    }
+    *dest++ = c;
+  }
+  *dest = 0;
+  path.ReleaseBuf_SetLen((unsigned)(dest - path.Ptr()));
+}
+
+
+// in/out: (LinkPath) uses system path separator
+// in/out: windows: (LinkPath) doesn't contain linux separator (slash).
+// out: (LinkPath) is relative path, and LinkPath[0] is not path separator
+void CLinkInfo::Normalize_to_RelativeSafe(UStringVector &removePathParts)
+{
+  // We WILL NOT WRITE original absolute link path from archive to filesystem.
+  // So here we remove all root prefixes from (LinkPath).
+  // If we see any absolute root prefix, then we suppose that this prefix is virtual prefix
+  // that shows that link is relative to root folder of archive
+  RemoveRedundantPathSeparators(LinkPath);
+  // LinkPath = "\\\\?\\r:test\\test2"; // for debug
+  Remove_AbsPathPrefixes();
+  // (LinkPath) now is relative:
+  //  if (isRelative == false), then (LinkPath) is relative to root folder of archive
+  //  if (isRelative == true ), then (LinkPath) is relative to current item
+  if (LinkPath.IsEmpty() || isRelative || removePathParts.Size() == 0)
+    return;
+
+  // if LinkPath is prefixed by _removePathParts, we remove these paths
+  UStringVector pathParts;
+  SplitPathToParts(LinkPath, pathParts);
+  bool badPrefix = false;
+  {
+    FOR_VECTOR (i, removePathParts)
+    {
+      if (i >= pathParts.Size()
+        || CompareFileNames(removePathParts[i], pathParts[i]) != 0)
+      {
+        badPrefix = true;
+        break;
+      }
+    }
+  }
+  if (!badPrefix)
+    pathParts.DeleteFrontal(removePathParts.Size());
+  LinkPath = MakePathFromParts(pathParts);
+  Remove_AbsPathPrefixes();
+}
+
 #endif // SUPPORT_LINKS
 
 
@@ -2213,12 +2509,12 @@ HRESULT CArchiveExtractCallback::CloseReparseAndFile()
 {
   HRESULT res = S_OK;
 
-  #ifdef SUPPORT_LINKS
+#ifdef SUPPORT_LINKS
 
   size_t reparseSize = 0;
   bool repraseMode = false;
   bool needSetReparse = false;
-  CLinkInfo linkInfo;
+  CLinkInfo link;
   
   if (_bufPtrSeqOutStream)
   {
@@ -2232,15 +2528,19 @@ HRESULT CArchiveExtractCallback::CloseReparseAndFile()
       needSetReparse = reparse.Parse(_outMemBuf, reparseSize, errorCode);
       if (needSetReparse)
       {
-        UString linkPath = reparse.GetPath();
+        UString LinkPath = reparse.GetPath();
         #ifndef _WIN32
-        linkPath.Replace(L'\\', WCHAR_PATH_SEPARATOR);
+        LinkPath.Replace(L'\\', WCHAR_PATH_SEPARATOR);
         #endif
       }
       */
-      needSetReparse = linkInfo.Parse(_outMemBuf, reparseSize, _is_SymLink_in_Data_Linux);
+      needSetReparse = _is_SymLink_in_Data_Linux ?
+          link.Parse_from_LinuxData(_outMemBuf, reparseSize) :
+          link.Parse_from_WindowsReparseData(_outMemBuf, reparseSize);
       if (!needSetReparse)
         res = SendMessageError_with_LastError("Incorrect reparse stream", us2fs(_item.Path));
+      // (link.LinkPath) uses system path separator.
+      // windows: (link.LinkPath) doesn't contain linux separator (slash).
     }
     else
     {
@@ -2255,25 +2555,21 @@ HRESULT CArchiveExtractCallback::CloseReparseAndFile()
     _bufPtrSeqOutStream.Release();
   }
 
-  #endif // SUPPORT_LINKS
-
+#endif // SUPPORT_LINKS
 
   const HRESULT res2 = CloseFile();
-
   if (res == S_OK)
     res = res2;
-
   RINOK(res)
 
-  #ifdef SUPPORT_LINKS
+#ifdef SUPPORT_LINKS
   if (repraseMode)
   {
     _curSize = reparseSize;
     _curSize_Defined = true;
-    
-    #ifdef SUPPORT_LINKS
     if (needSetReparse)
     {
+      // empty file was created so we must delete it.
       // in Linux   : we must delete empty file before symbolic link creation
       // in Windows : we can create symbolic link even without file deleting
       if (!DeleteFileAlways(_diskFilePath))
@@ -2281,42 +2577,57 @@ HRESULT CArchiveExtractCallback::CloseReparseAndFile()
         RINOK(SendMessageError_with_LastError("can't delete file", _diskFilePath))
       }
       {
-        /*
-        // for DEBUG ONLY: we can extract sym links as WSL links
-        // to eliminate (non-admin) errors for sym links.
-        #ifdef _WIN32
-        if (!linkInfo.isHardLink && !linkInfo.isJunction)
-          linkInfo.isWSL = true;
-        #endif
-        */
         bool linkWasSet = false;
-        RINOK(SetFromLinkPath(_diskFilePath, linkInfo, linkWasSet))
+        // link.LinkPath = "r:\\1\\2"; // for debug
+        // link.isJunction = true; // for debug
+        link.Normalize_to_RelativeSafe(_removePathParts);
+        RINOK(SetLink(_diskFilePath, link, linkWasSet))
+/*
+        // we don't set attributes for placeholder.
         if (linkWasSet)
-          _isSymLinkCreated = linkInfo.IsSymLink();
+          _isSymLinkCreated = true; // link.IsSymLink();
         else
+*/
           _needSetAttrib = false;
       }
-      /*
-      if (!NFile::NIO::SetReparseData(_diskFilePath, _item.IsDir, ))
-      {
-        res = SendMessageError_with_LastError(kCantCreateSymLink, _diskFilePath);
-      }
-      */
     }
-    #endif
   }
-  #endif
+#endif // SUPPORT_LINKS
   return res;
 }
 
 
-void CArchiveExtractCallback::SetAttrib()
+static void SetAttrib_Base(const FString &path, const CProcessedFileInfo &fi,
+    const CArchiveExtractCallback &callback)
 {
- #ifndef _WIN32
+#ifndef _WIN32
+  if (fi.Owner.Id_Defined &&
+      fi.Group.Id_Defined)
+  {
+    if (my_chown(path, fi.Owner.Id, fi.Group.Id) != 0)
+      callback.SendMessageError_with_LastError("Cannot set owner", path);
+  }
+#endif
+
+  if (fi.Attrib_Defined)
+  {
+    // const AString s = GetAnsiString(_diskFilePath);
+    // printf("\nSetFileAttrib_PosixHighDetect: %s: hex:%x\n", s.Ptr(), _fi.Attrib);
+    if (!SetFileAttrib_PosixHighDetect(path, fi.Attrib))
+    {
+      // do we need error message here in Windows and in posix?
+      callback.SendMessageError_with_LastError("Cannot set file attribute", path);
+    }
+  }
+}
+
+void CArchiveExtractCallback::SetAttrib() const
+{
+#ifndef _WIN32
   // Linux now doesn't support permissions for symlinks
   if (_isSymLinkCreated)
     return;
- #endif
+#endif
 
   if (_itemFailure
       || _diskFilePath.IsEmpty()
@@ -2324,29 +2635,39 @@ void CArchiveExtractCallback::SetAttrib()
       || !_extractMode)
     return;
 
- #ifndef _WIN32
-  if (_fi.Owner.Id_Defined &&
-      _fi.Group.Id_Defined)
-  {
-    if (my_chown(_diskFilePath, _fi.Owner.Id, _fi.Group.Id) != 0)
-    {
-      SendMessageError_with_LastError("Cannot set owner", _diskFilePath);
-    }
-  }
- #endif
+  SetAttrib_Base(_diskFilePath, _fi, *this);
+}
 
-  if (_fi.Attrib_Defined)
+
+#ifdef Z7_USE_SECURITY_CODE
+HRESULT CArchiveExtractCallback::SetSecurityInfo(UInt32 indexInArc, const FString &path) const
+{
+  if (!_stdOutMode && _extractMode && _ntOptions.NtSecurity.Val && _arc->GetRawProps)
   {
-    // const AString s = GetAnsiString(_diskFilePath);
-    // printf("\nSetFileAttrib_PosixHighDetect: %s: hex:%x\n", s.Ptr(), _fi.Attrib);
-    bool res = SetFileAttrib_PosixHighDetect(_diskFilePath, _fi.Attrib);
-    if (!res)
+    const void *data;
+    UInt32 dataSize;
+    UInt32 propType;
+    _arc->GetRawProps->GetRawProp(indexInArc, kpidNtSecure, &data, &dataSize, &propType);
+    if (dataSize != 0)
     {
-      // do we need error message here in Windows and in posix?
-      SendMessageError_with_LastError("Cannot set file attribute", _diskFilePath);
+      if (propType != NPropDataType::kRaw)
+        return E_FAIL;
+      if (CheckNtSecure((const Byte *)data, dataSize))
+      {
+        SECURITY_INFORMATION securInfo = DACL_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | OWNER_SECURITY_INFORMATION;
+        if (_saclEnabled)
+          securInfo |= SACL_SECURITY_INFORMATION;
+        // if (!
+        ::SetFileSecurityW(fs2us(path), securInfo, (PSECURITY_DESCRIPTOR)(void *)(const Byte *)(data));
+        {
+          // RINOK(SendMessageError_with_LastError("SetFileSecurity FAILS", path))
+        }
+      }
     }
   }
+  return S_OK;
 }
+#endif // Z7_USE_SECURITY_CODE
 
 
 Z7_COM7F_IMF(CArchiveExtractCallback::SetOperationResult(Int32 opRes))
@@ -2384,27 +2705,9 @@ Z7_COM7F_IMF(CArchiveExtractCallback::SetOperationResult(Int32 opRes))
 
   RINOK(CloseReparseAndFile())
   
-  #ifdef Z7_USE_SECURITY_CODE
-  if (!_stdOutMode && _extractMode && _ntOptions.NtSecurity.Val && _arc->GetRawProps)
-  {
-    const void *data;
-    UInt32 dataSize;
-    UInt32 propType;
-    _arc->GetRawProps->GetRawProp(_index, kpidNtSecure, &data, &dataSize, &propType);
-    if (dataSize != 0)
-    {
-      if (propType != NPropDataType::kRaw)
-        return E_FAIL;
-      if (CheckNtSecure((const Byte *)data, dataSize))
-      {
-        SECURITY_INFORMATION securInfo = DACL_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | OWNER_SECURITY_INFORMATION;
-        if (_saclEnabled)
-          securInfo |= SACL_SECURITY_INFORMATION;
-        ::SetFileSecurityW(fs2us(_diskFilePath), securInfo, (PSECURITY_DESCRIPTOR)(void *)(const Byte *)(data));
-      }
-    }
-  }
-  #endif // Z7_USE_SECURITY_CODE
+#ifdef Z7_USE_SECURITY_CODE
+  RINOK(SetSecurityInfo(_index, _diskFilePath))
+#endif
 
   if (!_curSize_Defined)
     GetUnpackSize();
@@ -2648,15 +2951,58 @@ void CDirPathSortPair::SetNumSlashes(const FChar *s)
 }
 
 
-bool CDirPathTime::SetDirTime() const
+bool CFiTimesCAM::SetDirTime_to_FS(CFSTR path) const
 {
-  return NDir::SetDirTime(Path,
+  // it's same function for dir and for file
+  return NDir::SetDirTime(path,
       CTime_Defined ? &CTime : NULL,
       ATime_Defined ? &ATime : NULL,
       MTime_Defined ? &MTime : NULL);
 }
 
 
+#ifdef SUPPORT_LINKS
+
+bool CFiTimesCAM::SetLinkFileTime_to_FS(CFSTR path) const
+{
+  // it's same function for dir and for file
+  return NDir::SetLinkFileTime(path,
+      CTime_Defined ? &CTime : NULL,
+      ATime_Defined ? &ATime : NULL,
+      MTime_Defined ? &MTime : NULL);
+}
+
+HRESULT CArchiveExtractCallback::SetPostLinks() const
+{
+  FOR_VECTOR (i, _postLinks)
+  {
+    const CPostLink &link = _postLinks[i];
+    bool linkWasSet = false;
+    RINOK(SetLink2(*this, link, linkWasSet))
+    if (linkWasSet)
+    {
+#ifdef _WIN32
+      //  Linux now doesn't support permissions for symlinks
+      SetAttrib_Base(link.fullProcessedPath_from, link.item_FileInfo, *this);
+#endif
+
+      CFiTimesCAM pt;
+      GetFiTimesCAM(link.item_FileInfo, pt, *_arc);
+      if (pt.IsSomeTimeDefined())
+        pt.SetLinkFileTime_to_FS(link.fullProcessedPath_from);
+
+#ifdef Z7_USE_SECURITY_CODE
+      // we set security information after timestamps setting
+      RINOK(SetSecurityInfo(link.Index_in_Arc, link.fullProcessedPath_from))
+#endif
+    }
+  }
+  return S_OK;
+}
+
+#endif
+
+
 HRESULT CArchiveExtractCallback::SetDirsTimes()
 {
   if (!_arc)
@@ -2680,7 +3026,7 @@ HRESULT CArchiveExtractCallback::SetDirsTimes()
   for (i = 0; i < pairs.Size(); i++)
   {
     const CDirPathTime &dpt = _extractedFolders[pairs[i].Index];
-    if (!dpt.SetDirTime())
+    if (!dpt.SetDirTime_to_FS_2())
     {
       // result = E_FAIL;
       // do we need error message here in Windows and in posix?
@@ -2712,10 +3058,20 @@ HRESULT CArchiveExtractCallback::SetDirsTimes()
 
 HRESULT CArchiveExtractCallback::CloseArc()
 {
+  // we call CloseReparseAndFile() here because we can have non-closed file in some cases?
   HRESULT res = CloseReparseAndFile();
-  const HRESULT res2 = SetDirsTimes();
-  if (res == S_OK)
-    res = res2;
+#ifdef SUPPORT_LINKS
+  {
+    const HRESULT res2 = SetPostLinks();
+    if (res == S_OK)
+      res = res2;
+  }
+#endif
+  {
+    const HRESULT res2 = SetDirsTimes();
+    if (res == S_OK)
+      res = res2;
+  }
   _arc = NULL;
   return res;
 }
diff --git a/CPP/7zip/UI/Common/ArchiveExtractCallback.h b/CPP/7zip/UI/Common/ArchiveExtractCallback.h
index 7eb2f67..3c62763 100644
--- a/CPP/7zip/UI/Common/ArchiveExtractCallback.h
+++ b/CPP/7zip/UI/Common/ArchiveExtractCallback.h
@@ -52,7 +52,6 @@ struct CExtractNtOptions
 {
   CBoolPair NtSecurity;
   CBoolPair SymLinks;
-  CBoolPair SymLinks_AllowDangerous;
   CBoolPair HardLinks;
   CBoolPair AltStreams;
   bool ReplaceColonForAltStream;
@@ -66,6 +65,8 @@ struct CExtractNtOptions
   bool PreserveATime;
   bool OpenShareForWrite;
 
+  unsigned SymLinks_DangerousLevel;
+
   UInt64 MemLimit;
 
   CExtractNtOptions():
@@ -74,10 +75,10 @@ struct CExtractNtOptions
       ExtractOwner(false),
       PreserveATime(false),
       OpenShareForWrite(false),
+      SymLinks_DangerousLevel(5),
       MemLimit((UInt64)(Int64)-1)
   {
     SymLinks.Val = true;
-    SymLinks_AllowDangerous.Val = false;
     HardLinks.Val = true;
     AltStreams.Val = true;
 
@@ -90,25 +91,10 @@ struct CExtractNtOptions
   }
 };
 
-#ifndef Z7_SFX
-
-Z7_CLASS_IMP_COM_1(
-  CGetProp
-  , IGetProp
-)
-public:
-  UInt32 IndexInArc;
-  const CArc *Arc;
-  // UString Name; // relative path
-};
-
-#endif
 
 #ifndef Z7_SFX
 #ifndef UNDER_CE
-
 #define SUPPORT_LINKS
-
 #endif
 #endif
 
@@ -181,53 +167,79 @@ struct CFiTimesCAM
       ATime_Defined |
       MTime_Defined;
   }
+  bool SetDirTime_to_FS(CFSTR path) const;
+#ifdef SUPPORT_LINKS
+  bool SetLinkFileTime_to_FS(CFSTR path) const;
+#endif
 };
 
 struct CDirPathTime: public CFiTimesCAM
 {
   FString Path;
   
-  bool SetDirTime() const;
+  bool SetDirTime_to_FS_2() const { return SetDirTime_to_FS(Path); }
 };
 
 
 #ifdef SUPPORT_LINKS
 
+enum ELinkType
+{
+  k_LinkType_HardLink,
+  k_LinkType_PureSymLink,
+  k_LinkType_Junction,
+  k_LinkType_WSL
+  // , k_LinkType_CopyLink;
+};
+
+
 struct CLinkInfo
 {
-  // bool isCopyLink;
-  bool isHardLink;
-  bool isJunction;
+  ELinkType LinkType;
   bool isRelative;
-  bool isWSL;
-  UString linkPath;
+    //  if (isRelative == false), then (LinkPath) is relative to root folder of archive
+    //  if (isRelative == true ), then (LinkPath) is relative to current item
+  bool isWindowsPath;
+  UString LinkPath;
+
+  bool Is_HardLink() const { return LinkType == k_LinkType_HardLink; }
+  bool Is_AnySymLink() const { return LinkType != k_LinkType_HardLink; }
 
-  bool IsSymLink() const { return !isHardLink; }
+  bool Is_WSL() const { return LinkType == k_LinkType_WSL; }
 
   CLinkInfo():
-    // IsCopyLink(false),
-    isHardLink(false),
-    isJunction(false),
+    LinkType(k_LinkType_PureSymLink),
     isRelative(false),
-    isWSL(false)
+    isWindowsPath(false)
     {}
 
   void Clear()
   {
-    // IsCopyLink = false;
-    isHardLink = false;
-    isJunction = false;
+    LinkType = k_LinkType_PureSymLink;
     isRelative = false;
-    isWSL = false;
-    linkPath.Empty();
+    isWindowsPath = false;
+    LinkPath.Empty();
   }
 
-  bool Parse(const Byte *data, size_t dataSize, bool isLinuxData);
+  bool Parse_from_WindowsReparseData(const Byte *data, size_t dataSize);
+  bool Parse_from_LinuxData(const Byte *data, size_t dataSize);
+  void Normalize_to_RelativeSafe(UStringVector &removePathParts);
+private:
+  void Remove_AbsPathPrefixes();
 };
 
 #endif // SUPPORT_LINKS
 
 
+
+struct CProcessedFileInfo
+{
+  CArcTime CTime;
+  CArcTime ATime;
+  CArcTime MTime;
+  UInt32 Attrib;
+  bool Attrib_Defined;
+  
 #ifndef _WIN32
 
 struct COwnerInfo
@@ -244,7 +256,75 @@ struct COwnerInfo
   }
 };
 
+  COwnerInfo Owner;
+  COwnerInfo Group;
+#endif
+
+  void Clear()
+  {
+#ifndef _WIN32
+    Attrib_Defined = false;
+    Owner.Clear();
 #endif
+  }
+
+    bool IsReparse() const
+    {
+      return (Attrib_Defined && (Attrib & FILE_ATTRIBUTE_REPARSE_POINT) != 0);
+    }
+    
+    bool IsLinuxSymLink() const
+    {
+      return (Attrib_Defined && MY_LIN_S_ISLNK(Attrib >> 16));
+    }
+
+    void SetFromPosixAttrib(UInt32 a)
+    {
+      // here we set only part of combined attribute required by SetFileAttrib() call
+      #ifdef _WIN32
+      // Windows sets FILE_ATTRIBUTE_NORMAL, if we try to set 0 as attribute.
+      Attrib = MY_LIN_S_ISDIR(a) ?
+          FILE_ATTRIBUTE_DIRECTORY :
+          FILE_ATTRIBUTE_ARCHIVE;
+      if ((a & 0222) == 0) // (& S_IWUSR) in p7zip
+        Attrib |= FILE_ATTRIBUTE_READONLY;
+      // 22.00 : we need type bits for (MY_LIN_S_IFLNK) for IsLinuxSymLink()
+      a &= MY_LIN_S_IFMT;
+      if (a == MY_LIN_S_IFLNK)
+        Attrib |= (a << 16);
+      #else
+      Attrib = (a << 16) | FILE_ATTRIBUTE_UNIX_EXTENSION;
+      #endif
+      Attrib_Defined = true;
+    }
+};
+
+
+#ifdef SUPPORT_LINKS
+
+struct CPostLink
+{
+  UInt32 Index_in_Arc;
+  bool item_IsDir;                // _item.IsDir
+  UString item_Path;              // _item.Path;
+  UStringVector item_PathParts;   // _item.PathParts;
+  CProcessedFileInfo item_FileInfo; // _fi
+  FString fullProcessedPath_from; // full file path in FS
+  CLinkInfo LinkInfo;
+};
+
+/*
+struct CPostLinks
+{
+  void Clear()
+  {
+    Links.Clear();
+  }
+};
+*/
+
+#endif // SUPPORT_LINKS
+
 
 
 class CArchiveExtractCallback Z7_final:
@@ -282,114 +362,78 @@ class CArchiveExtractCallback Z7_final:
   Z7_IFACE_COM7_IMP(IArchiveRequestMemoryUseCallback)
 #endif
 
+  // bool Write_CTime;
+  // bool Write_ATime;
+  // bool Write_MTime;
+  bool _stdOutMode;
+  bool _testMode;
+  bool _removePartsForAltStreams;
+public:
+  bool Is_elimPrefix_Mode;
+private:
+
   const CArc *_arc;
+public:
   CExtractNtOptions _ntOptions;
-
+private:
+  bool _encrypted;
   bool _isSplit;
+  bool _curSize_Defined;
+  bool _fileLength_WasSet;
 
+  bool _isRenamed;
   bool _extractMode;
-
-  bool Write_CTime;
-  bool Write_ATime;
-  bool Write_MTime;
-  bool _keepAndReplaceEmptyDirPrefixes; // replace them to "_";
-
-  bool _encrypted;
-
-  // bool _is_SymLink_in_Data;
-  bool _is_SymLink_in_Data_Linux; // false = WIN32, true = LINUX
-
+  bool _is_SymLink_in_Data_Linux; // false = WIN32, true = LINUX.
+      // _is_SymLink_in_Data_Linux is detected from Windows/Linux part of attributes of file.
   bool _needSetAttrib;
   bool _isSymLinkCreated;
   bool _itemFailure;
-
   bool _some_pathParts_wereRemoved;
-public:
-  bool Is_elimPrefix_Mode;
-
-private:
-  bool _curSize_Defined;
-  bool _fileLength_WasSet;
 
-  bool _removePartsForAltStreams;
-
-  bool _stdOutMode;
-  bool _testMode;
   bool _multiArchives;
+  bool _keepAndReplaceEmptyDirPrefixes; // replace them to "_";
+#if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
+  bool _saclEnabled;
+#endif
 
   NExtract::NPathMode::EEnum _pathMode;
   NExtract::NOverwriteMode::EEnum _overwriteMode;
 
-  const NWildcard::CCensorNode *_wildcardCensor; // we need wildcard for single pass mode (stdin)
   CMyComPtr<IFolderArchiveExtractCallback> _extractCallback2;
+  const NWildcard::CCensorNode *_wildcardCensor; // we need wildcard for single pass mode (stdin)
   // CMyComPtr<ICompressProgressInfo> _compressProgress;
   // CMyComPtr<IArchiveExtractCallbackMessage2> _callbackMessage;
   CMyComPtr<IFolderArchiveExtractCallback2> _folderArchiveExtractCallback2;
   CMyComPtr<ICryptoGetTextPassword> _cryptoGetTextPassword;
 
   FString _dirPathPrefix;
+public:
   FString _dirPathPrefix_Full;
+private:
 
   #ifndef Z7_SFX
 
   CMyComPtr<IFolderExtractToStreamCallback> ExtractToStreamCallback;
-  CGetProp *GetProp_Spec;
-  CMyComPtr<IGetProp> GetProp;
   CMyComPtr<IArchiveRequestMemoryUseCallback> _requestMemoryUseCallback;
   
   #endif
 
   CReadArcItem _item;
   FString _diskFilePath;
-  UInt64 _position;
-
-  struct CProcessedFileInfo
-  {
-    CArcTime CTime;
-    CArcTime ATime;
-    CArcTime MTime;
-    UInt32 Attrib;
-    bool Attrib_Defined;
 
-   #ifndef _WIN32
-    COwnerInfo Owner;
-    COwnerInfo Group;
-   #endif
-
-    bool IsReparse() const
-    {
-      return (Attrib_Defined && (Attrib & FILE_ATTRIBUTE_REPARSE_POINT) != 0);
-    }
-    
-    bool IsLinuxSymLink() const
-    {
-      return (Attrib_Defined && MY_LIN_S_ISLNK(Attrib >> 16));
-    }
+  CProcessedFileInfo _fi;
 
-    void SetFromPosixAttrib(UInt32 a)
-    {
-      // here we set only part of combined attribute required by SetFileAttrib() call
-      #ifdef _WIN32
-      // Windows sets FILE_ATTRIBUTE_NORMAL, if we try to set 0 as attribute.
-      Attrib = MY_LIN_S_ISDIR(a) ?
-          FILE_ATTRIBUTE_DIRECTORY :
-          FILE_ATTRIBUTE_ARCHIVE;
-      if ((a & 0222) == 0) // (& S_IWUSR) in p7zip
-        Attrib |= FILE_ATTRIBUTE_READONLY;
-      // 22.00 : we need type bits for (MY_LIN_S_IFLNK) for IsLinuxSymLink()
-      a &= MY_LIN_S_IFMT;
-      if (a == MY_LIN_S_IFLNK)
-        Attrib |= (a << 16);
-      #else
-      Attrib = (a << 16) | FILE_ATTRIBUTE_UNIX_EXTENSION;
-      #endif
-      Attrib_Defined = true;
-    }
-  } _fi;
-
-  UInt32 _index;
+  UInt64 _position;
   UInt64 _curSize;
   UInt64 _fileLength_that_WasSet;
+  UInt32 _index;
+
+// #ifdef SUPPORT_ALT_STREAMS
+#if defined(_WIN32) && !defined(UNDER_CE)
+  DWORD _altStream_NeedRestore_AttribVal;
+  FString _altStream_NeedRestore_Attrib_for_parentFsPath;
+#endif
+// #endif
 
   COutFileStream *_outFileStreamSpec;
   CMyComPtr<ISequentialOutStream> _outFileStream;
@@ -398,9 +442,7 @@ private:
   CBufPtrSeqOutStream *_bufPtrSeqOutStream_Spec;
   CMyComPtr<ISequentialOutStream> _bufPtrSeqOutStream;
 
-
  #ifndef Z7_SFX
-  
   COutStreamWithHash *_hashStreamSpec;
   CMyComPtr<ISequentialOutStream> _hashStream;
   bool _hashStreamWasUsed;
@@ -411,11 +453,9 @@ private:
 
   UStringVector _removePathParts;
 
-  CMyComPtr<ICompressProgressInfo> _localProgress;
   UInt64 _packTotal;
-  
   UInt64 _progressTotal;
-  bool _progressTotal_Defined;
+  // bool _progressTotal_Defined;
 
   CObjectVector<CDirPathTime> _extractedFolders;
   
@@ -423,31 +463,28 @@ private:
   // CObjectVector<NWindows::NFile::NDir::CDelayedSymLink> _delayedSymLinks;
   #endif
 
-  #if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
-  bool _saclEnabled;
-  #endif
-
-  void CreateComplexDirectory(const UStringVector &dirPathParts, FString &fullPath);
+  void CreateComplexDirectory(
+      const UStringVector &dirPathParts, bool isFinal, FString &fullPath);
   HRESULT GetTime(UInt32 index, PROPID propID, CArcTime &ft);
   HRESULT GetUnpackSize();
 
   FString Hash_GetFullFilePath();
 
-  void SetAttrib();
+  void SetAttrib() const;
 
 public:
-  HRESULT SendMessageError(const char *message, const FString &path);
-  HRESULT SendMessageError_with_Error(HRESULT errorCode, const char *message, const FString &path);
-  HRESULT SendMessageError_with_LastError(const char *message, const FString &path);
-  HRESULT SendMessageError2(HRESULT errorCode, const char *message, const FString &path1, const FString &path2);
+  HRESULT SendMessageError(const char *message, const FString &path) const;
+  HRESULT SendMessageError_with_Error(HRESULT errorCode, const char *message, const FString &path) const;
+  HRESULT SendMessageError_with_LastError(const char *message, const FString &path) const;
+  HRESULT SendMessageError2(HRESULT errorCode, const char *message, const FString &path1, const FString &path2) const;
+  HRESULT SendMessageError2_with_LastError(const char *message, const FString &path1, const FString &path2) const;
 
-public:
-  #if defined(_WIN32) && !defined(UNDER_CE)
+#if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
   NExtract::NZoneIdMode::EEnum ZoneMode;
   CByteBuffer ZoneBuf;
-  #endif
+#endif
 
-  CLocalProgress *LocalProgressSpec;
+  CMyComPtr2_Create<ICompressProgressInfo, CLocalProgress> LocalProgressSpec;
 
   UInt64 NumFolders;
   UInt64 NumFiles;
@@ -468,11 +505,11 @@ public:
     _multiArchives = multiArchives;
     _pathMode = pathMode;
     _overwriteMode = overwriteMode;
-   #if defined(_WIN32) && !defined(UNDER_CE)
+#if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
      ZoneMode = zoneMode;
-   #else
+#else
      UNUSED_VAR(zoneMode)
-   #endif
+#endif
     _keepAndReplaceEmptyDirPrefixes = keepAndReplaceEmptyDirPrefixes;
     NumFolders = NumFiles = NumAltStreams = UnpackSize = AltStreams_UnpackSize = 0;
   }
@@ -503,23 +540,32 @@ public:
       UInt64 packSize);
 
 
-  #ifdef SUPPORT_LINKS
+#ifdef SUPPORT_LINKS
 
 private:
   CHardLinks _hardLinks;
+  CObjectVector<CPostLink> _postLinks;
   CLinkInfo _link;
+  // const void *NtReparse_Data;
+  // UInt32 NtReparse_Size;
 
   // FString _copyFile_Path;
   // HRESULT MyCopyFile(ISequentialOutStream *outStream);
-  HRESULT Link(const FString &fullProcessedPath);
   HRESULT ReadLink();
+  HRESULT SetLink(
+      const FString &fullProcessedPath_from,
+      const CLinkInfo &linkInfo,
+      bool &linkWasSet);
+  HRESULT SetPostLinks() const;
 
 public:
-  // call PrepareHardLinks() after Init()
+  HRESULT CreateHardLink2(const FString &newFilePath,
+      const FString &existFilePath, bool &link_was_Created) const;
+  HRESULT DeleteLinkFileAlways_or_RemoveEmptyDir(const FString &path, bool checkThatFileIsEmpty) const;
   HRESULT PrepareHardLinks(const CRecordVector<UInt32> *realIndices);  // NULL means all items
+#endif
 
-  #endif
-
+private:
 
   #ifdef SUPPORT_ALT_STREAMS
   CObjectVector<CIndexToPathPair> _renamedFiles;
@@ -527,6 +573,7 @@ public:
 
   // call it after Init()
 
+public:
   #ifndef Z7_SFX
   void SetBaseParentFolderIndex(UInt32 indexInArc)
   {
@@ -548,28 +595,16 @@ private:
 
   HRESULT Read_fi_Props();
   void CorrectPathParts();
-  void GetFiTimesCAM(CFiTimesCAM &pt);
   void CreateFolders();
   
-  bool _isRenamed;
   HRESULT CheckExistFile(FString &fullProcessedPath, bool &needExit);
   HRESULT GetExtractStream(CMyComPtr<ISequentialOutStream> &outStreamLoc, bool &needExit);
   HRESULT GetItem(UInt32 index);
 
   HRESULT CloseFile();
   HRESULT CloseReparseAndFile();
-  HRESULT CloseReparseAndFile2();
   HRESULT SetDirsTimes();
-
-  const void *NtReparse_Data;
-  UInt32 NtReparse_Size;
-
-  #ifdef SUPPORT_LINKS
-  HRESULT SetFromLinkPath(
-      const FString &fullProcessedPath,
-      const CLinkInfo &linkInfo,
-      bool &linkWasSet);
-  #endif
+  HRESULT SetSecurityInfo(UInt32 indexInArc, const FString &path) const;
 };
 
 
@@ -599,7 +634,8 @@ struct CArchiveExtractCallback_Closer
 
 bool CensorNode_CheckPath(const NWildcard::CCensorNode &node, const CReadArcItem &item);
 
-void ReadZoneFile_Of_BaseFile(CFSTR fileName2, CByteBuffer &buf);
+bool Is_ZoneId_StreamName(const wchar_t *s);
+void ReadZoneFile_Of_BaseFile(CFSTR fileName, CByteBuffer &buf);
 bool WriteZoneFile_To_BaseFile(CFSTR fileName, const CByteBuffer &buf);
 
 #endif
diff --git a/CPP/7zip/UI/Common/Bench.cpp b/CPP/7zip/UI/Common/Bench.cpp
index e1ca846..eb24e7f 100644
--- a/CPP/7zip/UI/Common/Bench.cpp
+++ b/CPP/7zip/UI/Common/Bench.cpp
@@ -871,14 +871,27 @@ struct CAffinityMode
   unsigned NumCoreThreads;
   unsigned NumCores;
   // unsigned DivideNum;
+
+#ifdef _WIN32
+  unsigned NumGroups;
+#endif
+
   UInt32 Sizes[NUM_CPU_LEVELS_MAX];
 
   void SetLevels(unsigned numCores, unsigned numCoreThreads);
   DWORD_PTR GetAffinityMask(UInt32 bundleIndex, CCpuSet *cpuSet) const;
   bool NeedAffinity() const { return NumBundleThreads != 0; }
 
+#ifdef _WIN32
+  bool NeedGroupsMode() const { return NumGroups > 1; }
+#endif
+
   WRes CreateThread_WithAffinity(NWindows::CThread &thread, THREAD_FUNC_TYPE startAddress, LPVOID parameter, UInt32 bundleIndex) const
   {
+#ifdef _WIN32
+    if (NeedGroupsMode()) // we need fix for bundleIndex usage
+      return thread.Create_With_Group(startAddress, parameter, bundleIndex % NumGroups);
+#endif
     if (NeedAffinity())
     {
       CCpuSet cpuSet;
@@ -892,6 +905,9 @@ struct CAffinityMode
     NumBundleThreads(0),
     NumLevels(0),
     NumCoreThreads(1)
+#ifdef _WIN32
+    , NumGroups(0)
+#endif
     // DivideNum(1)
     {}
 };
@@ -1288,22 +1304,28 @@ HRESULT CEncoderInfo::Generate()
     if (scp)
     {
       const UInt64 reduceSize = kBufferSize;
-      
-      /* in posix new thread uses same affinity as parent thread,
+      /* in posix : new thread uses same affinity as parent thread,
          so we don't need to send affinity to coder in posix */
-      UInt64 affMask;
-      #if !defined(Z7_ST) && defined(_WIN32)
+      UInt64 affMask = 0;
+      UInt32 affinityGroup = (UInt32)(Int32)-1;
+      // UInt64 affinityInGroup = 0;
+#if !defined(Z7_ST) && defined(_WIN32)
       {
         CCpuSet cpuSet;
-        affMask = AffinityMode.GetAffinityMask(EncoderIndex, &cpuSet);
+        if (AffinityMode.NeedGroupsMode()) // we need fix for affinityInGroup also
+          affinityGroup = EncoderIndex % AffinityMode.NumGroups;
+        else
+          affMask = AffinityMode.GetAffinityMask(EncoderIndex, &cpuSet);
       }
-      #else
-        affMask = 0;
-      #endif
-      // affMask <<= 3; // debug line: to test no affinity in coder;
-      // affMask = 0;
-
-      RINOK(method.SetCoderProps_DSReduce_Aff(scp, &reduceSize, (affMask != 0 ? &affMask : NULL)))
+#endif
+      // affMask <<= 3; // debug line: to test no affinity in coder
+      // affMask = 0; // for debug
+      // affinityGroup = 0; // for debug
+      // affinityInGroup = 1; // for debug
+      RINOK(method.SetCoderProps_DSReduce_Aff(scp, &reduceSize,
+          affMask != 0 ? &affMask : NULL,
+          affinityGroup != (UInt32)(Int32)-1 ? &affinityGroup : NULL,
+          /* affinityInGroup != 0 ? &affinityInGroup : */ NULL))
     }
     else
     {
@@ -2298,6 +2320,28 @@ HRESULT CCrcInfo_Base::Generate(const Byte *data, size_t size)
 }
 
 
+#if 1
+#define HashUpdate(hf, data, size)  hf->Update(data, size)
+#else
+// for debug:
+static void HashUpdate(IHasher *hf, const void *data, UInt32 size)
+{
+  for (;;)
+  {
+    if (size == 0)
+      return;
+    UInt32 size2 = (size * 0x85EBCA87) % size / 8;
+    // UInt32 size2 = size / 2;
+    if (size2 == 0)
+      size2 = 1;
+    hf->Update(data, size2);
+    data = (const void *)((const Byte *)data + size2);
+    size -= size2;
+  }
+}
+#endif
+
+
 HRESULT CCrcInfo_Base::CrcProcess(UInt64 numIterations,
     const UInt32 *checkSum, IHasher *hf,
     IBenchPrintCallback *callback)
@@ -2328,7 +2372,7 @@ HRESULT CCrcInfo_Base::CrcProcess(UInt64 numIterations,
       const size_t rem = size - pos;
       const UInt32 kStep = ((UInt32)1 << 31);
       const UInt32 curSize = (rem < kStep) ? (UInt32)rem : kStep;
-      hf->Update(buf + pos, curSize);
+      HashUpdate(hf, buf + pos, curSize);
       pos += curSize;
     }
     while (pos != size);
@@ -2742,14 +2786,20 @@ static const CBenchHash g_Hash[] =
   {  2,   128 *ARM_CRC_MUL, 0x21e207bb, "CRC32:32" },
   {  2,    64 *ARM_CRC_MUL, 0x21e207bb, "CRC32:64" },
   { 10,   256, 0x41b901d1, "CRC64" },
-  { 10,    64, 0x43eac94f, "XXH64" },
-  
-  { 10, 5100,       0x7913ba03, "SHA256:1" },
-  {  2, CMPLX((32 * 4 + 1) * 4 + 4), 0x7913ba03, "SHA256:2" },
-  
-  { 10, 2340,       0xff769021, "SHA1:1" },
+  {  5,    64, 0x43eac94f, "XXH64" },
+  {  2,  2340, 0x3398a904, "MD5" },
+  { 10,  2340,                       0xff769021, "SHA1:1" },
   {  2, CMPLX((20 * 6 + 1) * 4 + 4), 0xff769021, "SHA1:2" },
-  
+  { 10,  5100,                       0x7913ba03, "SHA256:1" },
+  {  2, CMPLX((32 * 4 + 1) * 4 + 4), 0x7913ba03, "SHA256:2" },
+  {  5,  3200,                       0xe7aeb394, "SHA512:1" },
+  {  2, CMPLX((40 * 4 + 1) * 4 + 4), 0xe7aeb394, "SHA512:2" },
+  // { 10, 3428,       0x1cc99b18, "SHAKE128" },
+  // { 10, 4235,       0x74eaddc3, "SHAKE256" },
+  // { 10, 4000,       0xdf3e6863, "SHA3-224" },
+  {  5, 4200,       0xcecac10d, "SHA3-256" },
+  // { 10, 5538,       0x4e5d9163, "SHA3-384" },
+  // { 10, 8000,       0x96a58289, "SHA3-512" },
   {  2,  4096, 0x85189d02, "BLAKE2sp:1" },
   {  2,  1024, 0x85189d02, "BLAKE2sp:2" }, // sse2-way4-fast
   {  2,   512, 0x85189d02, "BLAKE2sp:3" }  // avx2-way8-fast
@@ -2934,7 +2984,7 @@ AString GetProcessThreadsInfo(const NSystem::CProcessAffinity &ti)
 {
   AString s;
   // s.Add_UInt32(ti.numProcessThreads);
-  unsigned numSysThreads = ti.GetNumSystemThreads();
+  const unsigned numSysThreads = ti.GetNumSystemThreads();
   if (ti.GetNumProcessThreads() != numSysThreads)
   {
     // if (ti.numProcessThreads != ti.numSysThreads)
@@ -2964,6 +3014,35 @@ AString GetProcessThreadsInfo(const NSystem::CProcessAffinity &ti)
     }
     #endif
   }
+#ifdef _WIN32
+  if (ti.Groups.GroupSizes.Size() > 1 ||
+      (ti.Groups.GroupSizes.Size() == 1
+       && ti.Groups.NumThreadsTotal != numSysThreads))
+  {
+    s += " : ";
+    s.Add_UInt32(ti.Groups.GroupSizes.Size());
+    s += " groups : ";
+    if (ti.Groups.NumThreadsTotal == numSysThreads)
+    {
+      s.Add_UInt32(ti.Groups.NumThreadsTotal);
+      s += " c : ";
+    }
+    UInt32 minSize, maxSize;
+    ti.Groups.Get_GroupSize_Min_Max(minSize, maxSize);
+    if (minSize == maxSize)
+    {
+      s.Add_UInt32(ti.Groups.GroupSizes[0]);
+      s += " c/g";
+    }
+    else
+    FOR_VECTOR (i, ti.Groups.GroupSizes)
+    {
+      if (i != 0)
+        s.Add_Char(' ');
+      s.Add_UInt32(ti.Groups.GroupSizes[i]);
+    }
+  }
+#endif
   return s;
 }
 
@@ -3687,7 +3766,7 @@ HRESULT Bench(
     return E_FAIL;
 
   UInt32 numCPUs = 1;
-  UInt64 ramSize = (UInt64)(sizeof(size_t)) << 29;
+  size_t ramSize = (size_t)sizeof(size_t) << 29;
 
   NSystem::CProcessAffinity threadsInfo;
   threadsInfo.InitST();
@@ -3725,9 +3804,13 @@ HRESULT Bench(
   UInt64 complexInCommands = kComplexInCommands;
   UInt32 numThreads_Start = 1;
   
-  #ifndef Z7_ST
+#ifndef Z7_ST
   CAffinityMode affinityMode;
-  #endif
+#ifdef _WIN32
+  if (threadsInfo.IsGroupMode && threadsInfo.Groups.GroupSizes.Size() > 1)
+    affinityMode.NumGroups = threadsInfo.Groups.GroupSizes.Size();
+#endif
+#endif
 
 
   COneMethodInfo method;
@@ -4580,6 +4663,8 @@ HRESULT Bench(
 
   if (!dictIsDefined && !onlyHashBench)
   {
+    // we use dicSizeLog and dicSizeLog_Main for data size.
+    // also we use it to reduce dictionary size of LZMA encoder via NCoderPropID::kReduceSize.
     const unsigned dicSizeLog_Main = (totalBenchMode ? 24 : 25);
     unsigned dicSizeLog = dicSizeLog_Main;
     
@@ -4831,7 +4916,7 @@ HRESULT Bench(
         if (AreSameMethodNames(benchMethod, methodName))
         {
           if (benchProps.IsEmpty()
-              || (benchProps == "x5" && method.PropsString.IsEmpty())
+              || (benchProps.IsEqualTo("x5") && method.PropsString.IsEmpty())
               || method.PropsString.IsPrefixedBy_Ascii_NoCase(benchProps))
           {
             callback.BenchProps.EncComplex = h.EncComplex;
diff --git a/CPP/7zip/UI/Common/EnumDirItems.cpp b/CPP/7zip/UI/Common/EnumDirItems.cpp
index 0758547..cada2e6 100644
--- a/CPP/7zip/UI/Common/EnumDirItems.cpp
+++ b/CPP/7zip/UI/Common/EnumDirItems.cpp
@@ -671,7 +671,7 @@ static HRESULT EnumerateForItem(
   }
   
   #if defined(_WIN32)
-  if (needAltStreams && dirItems.ScanAltStreams)
+  if (needAltStreams && dirItems.ScanAltStreams && !fi.IsAltStream)
   {
     RINOK(EnumerateAltStreams(fi, curNode, phyParent, logParent,
         phyPrefix + fi.Name,    // with (fi.Name)
@@ -929,7 +929,7 @@ static HRESULT EnumerateDirItems(
         }
         
         #if defined(_WIN32)
-        if (needAltStreams && dirItems.ScanAltStreams)
+        if (needAltStreams && dirItems.ScanAltStreams && !fi.IsAltStream)
         {
           UStringVector pathParts;
           pathParts.Add(fs2us(fi.Name));
@@ -1213,11 +1213,13 @@ HRESULT CDirItems::FillFixedReparse()
       // continue; // for debug
       if (!item.Has_Attrib_ReparsePoint())
         continue;
-
+      /*
+      We want to get properties of target file instead of properies of symbolic link.
+      Probably this code is unused, because
+      CFileInfo::Find(with followLink = true) called Fill_From_ByHandleFileInfo() already.
+      */
       // if (item.IsDir()) continue;
-
       const FString phyPath = GetPhyPath(i);
-
       NFind::CFileInfo fi;
       if (fi.Fill_From_ByHandleFileInfo(phyPath)) // item.IsDir()
       {
@@ -1228,38 +1230,13 @@ HRESULT CDirItems::FillFixedReparse()
         item.Attrib = fi.Attrib;
         continue;
       }
-
-      /*
-      // we request properties of target file instead of properies of symbolic link
-      // here we also can manually parse unsupported links (like WSL links)
-      NIO::CInFile inFile;
-      if (inFile.Open(phyPath))
-      {
-        BY_HANDLE_FILE_INFORMATION info;
-        if (inFile.GetFileInformation(&info))
-        {
-          // Stat.FilesSize doesn't contain item.Size already
-          // Stat.FilesSize -= item.Size;
-          item.Size = (((UInt64)info.nFileSizeHigh) << 32) + info.nFileSizeLow;
-          Stat.FilesSize += item.Size;
-          item.CTime = info.ftCreationTime;
-          item.ATime = info.ftLastAccessTime;
-          item.MTime = info.ftLastWriteTime;
-          item.Attrib = info.dwFileAttributes;
-          continue;
-        }
-      }
-      */
-
       RINOK(AddError(phyPath))
       continue;
     }
 
-    // (SymLinks == true) here
-
+    // (SymLinks == true)
     if (item.ReparseData.Size() == 0)
       continue;
-
     // if (item.Size == 0)
     {
       // 20.03: we use Reparse Data instead of real data
@@ -1277,7 +1254,7 @@ HRESULT CDirItems::FillFixedReparse()
     /* imagex/WIM reduces absolute paths in links (raparse data),
        if we archive non root folder. We do same thing here */
 
-    bool isWSL = false;
+    // bool isWSL = false;
     if (attr.IsSymLink_WSL())
     {
       // isWSL = true;
@@ -1314,21 +1291,27 @@ HRESULT CDirItems::FillFixedReparse()
       continue;
     if (rootPrefixSize == prefix.Len())
       continue; // simple case: paths are from root
-
     if (link.Len() <= prefix.Len())
       continue;
-
     if (CompareFileNames(link.Left(prefix.Len()), prefix) != 0)
       continue;
 
     UString newLink = prefix.Left(rootPrefixSize);
     newLink += link.Ptr(prefix.Len());
 
-    CByteBuffer data;
-    bool isSymLink = !attr.IsMountPoint();
-    if (!FillLinkData(data, newLink, isSymLink, isWSL))
+    CByteBuffer &data = item.ReparseData2;
+/*
+    if (isWSL)
+    {
+      Convert_WinPath_to_WslLinuxPath(newLink, true); // is absolute : change it
+      FillLinkData_WslLink(data, newLink);
+    }
+    else
+*/
+      FillLinkData_WinLink(data, newLink, !attr.IsMountPoint());
+    if (data.Size() == 0)
       continue;
-    item.ReparseData2 = data;
+    // item.ReparseData2 = data;
   }
   return S_OK;
 }
diff --git a/CPP/7zip/UI/Common/Extract.cpp b/CPP/7zip/UI/Common/Extract.cpp
index 010b01c..0301976 100644
--- a/CPP/7zip/UI/Common/Extract.cpp
+++ b/CPP/7zip/UI/Common/Extract.cpp
@@ -389,7 +389,7 @@ HRESULT Extract(
       {
         UString s = arcPath.Ptr(pos + 1);
         int index = codecs->FindFormatForExtension(s);
-        if (index >= 0 && s == L"001")
+        if (index >= 0 && s.IsEqualTo("001"))
         {
           s = arcPath.Left(pos);
           pos = s.ReverseFind(L'.');
diff --git a/CPP/7zip/UI/Common/ExtractingFilePath.cpp b/CPP/7zip/UI/Common/ExtractingFilePath.cpp
index 88da4ad..5ca5e66 100644
--- a/CPP/7zip/UI/Common/ExtractingFilePath.cpp
+++ b/CPP/7zip/UI/Common/ExtractingFilePath.cpp
@@ -208,7 +208,7 @@ void Correct_FsPath(bool absIsAllowed, bool keepAndReplaceEmptyPrefixes, UString
       if (parts.Size() > 1 && parts[1].IsEmpty())
       {
         i = 2;
-        if (parts.Size() > 2 && parts[2] == L"?")
+        if (parts.Size() > 2 && parts[2].IsEqualTo("?"))
         {
           i = 3;
           if (parts.Size() > 3 && NWindows::NFile::NName::IsDrivePath2(parts[3]))
diff --git a/CPP/7zip/UI/Common/HashCalc.cpp b/CPP/7zip/UI/Common/HashCalc.cpp
index f3d65ef..f026f80 100644
--- a/CPP/7zip/UI/Common/HashCalc.cpp
+++ b/CPP/7zip/UI/Common/HashCalc.cpp
@@ -62,7 +62,7 @@ HRESULT CHashBundle::SetMethods(DECL_EXTERNAL_CODECS_LOC_VARS const UStringVecto
     if (m.MethodName.IsEmpty())
       m.MethodName = k_DefaultHashMethod;
     
-    if (m.MethodName == "*")
+    if (m.MethodName.IsEqualTo("*"))
     {
       CRecordVector<CMethodId> tempMethods;
       GetHashMethods(EXTERNAL_CODECS_LOC_VARS tempMethods);
@@ -431,6 +431,19 @@ static void WriteLine(CDynLimBuf &hashFileString,
 }
 
 
+static void Convert_TagName_to_MethodName(AString &method)
+{
+  // we need to convert at least SHA512/256 to SHA512-256, and SHA512/224 to SHA512-224
+  // but we convert any '/' to '-'.
+  method.Replace('/', '-');
+}
+
+static void Convert_MethodName_to_TagName(AString &method)
+{
+  if (method.IsPrefixedBy_Ascii_NoCase("SHA512-2"))
+    method.ReplaceOneCharAtPos(6, '/');
+}
+
 
 static void WriteLine(CDynLimBuf &hashFileString,
     const CHashOptionsLocal &options,
@@ -440,8 +453,10 @@ static void WriteLine(CDynLimBuf &hashFileString,
 {
   AString methodName;
   if (!hb.Hashers.IsEmpty())
+  {
     methodName = hb.Hashers[0].Name;
-  
+    Convert_MethodName_to_TagName(methodName);
+  }
   AString hashesString;
   AddHashResultLine(hashesString, hb.Hashers);
   WriteLine(hashFileString, options, path, isDir, methodName, hashesString);
@@ -752,7 +767,7 @@ bool CHashPair::ParseCksum(const char *s)
   Name = end;
   
   Hash.Alloc(4);
-  SetBe32(Hash, crc)
+  SetBe32a(Hash, crc)
 
   Size_from_Arc = size;
   Size_from_Arc_Defined = true;
@@ -773,48 +788,87 @@ static const char * const k_CsumMethodNames[] =
 {
     "sha256"
   , "sha224"
-//  , "sha512/224"
-//  , "sha512/256"
-  , "sha512"
+  , "sha512-224"
+  , "sha512-256"
   , "sha384"
+  , "sha512"
+  , "sha3-224"
+  , "sha3-256"
+  , "sha3-384"
+  , "sha3-512"
+//  , "shake128"
+//  , "shake256"
   , "sha1"
+  , "sha2"
+  , "sha3"
+  , "sha"
   , "md5"
+  , "blake2s"
   , "blake2b"
-  , "crc64"
+  , "blake2sp"
+  , "xxh64"
   , "crc32"
+  , "crc64"
   , "cksum"
 };
 
-static UString GetMethod_from_FileName(const UString &name)
+
+// returns true, if (method) is known hash method or hash method group name.
+static bool GetMethod_from_FileName(const UString &name, AString &method)
 {
+  method.Empty();
   AString s;
   ConvertUnicodeToUTF8(name, s);
   const int dotPos = s.ReverseFind_Dot();
-  const char *src = s.Ptr();
-  bool isExtension = false;
   if (dotPos >= 0)
   {
-    isExtension = true;
-    src = s.Ptr(dotPos + 1);
+    method = s.Ptr(dotPos + 1);
+    if (method.IsEqualTo_Ascii_NoCase("txt") ||
+        method.IsEqualTo_Ascii_NoCase("asc"))
+    {
+      method.Empty();
+      const int dotPos2 = s.Find('.');
+      if (dotPos2 >= 0)
+        s.DeleteFrom(dotPos2);
+    }
   }
-  const char *m = "";
+  if (method.IsEmpty())
+  {
+    // we support file names with "sum" and "sums" postfixes: "sha256sum", "sha256sums"
+    unsigned size;
+    if (s.Len() > 4 && StringsAreEqualNoCase_Ascii(s.RightPtr(4), "sums"))
+      size = 4;
+    else if (s.Len() > 3 && StringsAreEqualNoCase_Ascii(s.RightPtr(3), "sum"))
+      size = 3;
+    else
+      return false;
+    method = s;
+    method.DeleteFrom(s.Len() - size);
+  }
+
   unsigned i;
   for (i = 0; i < Z7_ARRAY_SIZE(k_CsumMethodNames); i++)
   {
-    m = k_CsumMethodNames[i];
-    if (isExtension)
+    const char *m = k_CsumMethodNames[i];
+    if (method.IsEqualTo_Ascii_NoCase(m))
     {
-      if (StringsAreEqual_Ascii(src, m))
-        break;
+      // method = m; // we can get lowcase
+      return true;
     }
-    else if (IsString1PrefixedByString2_NoCase_Ascii(src, m))
-      if (StringsAreEqual_Ascii(src + strlen(m), "sums"))
-        break;
   }
-  UString res;
-  if (i != Z7_ARRAY_SIZE(k_CsumMethodNames))
-    res = m;
-  return res;
+
+/*
+  for (i = 0; i < Z7_ARRAY_SIZE(k_CsumMethodNames); i++)
+  {
+    const char *m = k_CsumMethodNames[i];
+    if (method.IsPrefixedBy_Ascii_NoCase(m))
+    {
+      method = m; // we get lowcase
+      return true;
+    }
+  }
+*/
+  return false;
 }
 
 
@@ -1039,7 +1093,7 @@ Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data
   if (propID == kpidChecksum)
   {
     const CHashPair &hp = HashPairs[index];
-    if (hp.Hash.Size() > 0)
+    if (hp.Hash.Size() != 0)
     {
       *data = hp.Hash;
       *dataSize = (UInt32)hp.Hash.Size();
@@ -1092,11 +1146,6 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
         s.Add_UInt32(_hashSize * 8);
         s += "-bit";
       }
-      if (!_nameExtenstion.IsEmpty())
-      {
-        s.Add_Space_if_NotEmpty();
-        s += _nameExtenstion;
-      }
       if (_is_PgpMethod)
       {
         Add_OptSpace_String(s, "PGP");
@@ -1112,6 +1161,18 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
         Add_OptSpace_String(s, "TAG");
       if (_are_there_Dirs)
         Add_OptSpace_String(s, "DIRS");
+      if (!_method_from_FileName.IsEmpty())
+      {
+        Add_OptSpace_String(s, "filename_method:");
+        s += _method_from_FileName;
+        if (!_is_KnownMethod_in_FileName)
+          s += ":UNKNOWN";
+      }
+      if (!_methods.IsEmpty())
+      {
+        Add_OptSpace_String(s, "cmd_method:");
+        s += _methods[0];
+      }
       prop = s;
       break;
     }
@@ -1220,6 +1281,15 @@ static HRESULT ReadStream_to_Buf(IInStream *stream, CByteBuffer &buf, IArchiveOp
 }
 
 
+static bool isThere_Zero_Byte(const Byte *data, size_t size)
+{
+  for (size_t i = 0; i < size; i++)
+    if (data[i] == 0)
+      return true;
+  return false;
+}
+
+
 Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *openCallback))
 {
   COM_TRY_BEGIN
@@ -1231,17 +1301,9 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallb
 
     CObjectVector<CHashPair> &pairs = HashPairs;
 
-    bool zeroMode = false;
-    bool cr_lf_Mode = false;
-    {
-      for (size_t i = 0; i < buf.Size(); i++)
-        if (buf.ConstData()[i] == 0)
-        {
-          zeroMode = true;
-          break;
-        }
-    }
+    const bool zeroMode = isThere_Zero_Byte(buf, buf.Size());
     _is_ZeroMode = zeroMode;
+    bool cr_lf_Mode = false;
     if (!zeroMode)
       cr_lf_Mode = Is_CR_LF_Data(buf, buf.Size());
 
@@ -1255,13 +1317,21 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallb
         NCOM::CPropVariant prop;
         RINOK(openVolumeCallback->GetProperty(kpidName, &prop))
         if (prop.vt == VT_BSTR)
-          _nameExtenstion = GetMethod_from_FileName(prop.bstrVal);
+          _is_KnownMethod_in_FileName = GetMethod_from_FileName(prop.bstrVal, _method_from_FileName);
       }
     }
 
-    bool cksumMode = false;
-    if (_nameExtenstion.IsEqualTo_Ascii_NoCase("cksum"))
-      cksumMode = true;
+    if (!_methods.IsEmpty())
+    {
+      ConvertUnicodeToUTF8(_methods[0], _method_for_Extraction);
+    }
+    if (_method_for_Extraction.IsEmpty())
+    {
+      // if (_is_KnownMethod_in_FileName)
+      _method_for_Extraction = _method_from_FileName;
+    }
+
+    const bool cksumMode = _method_for_Extraction.IsEqualTo_Ascii_NoCase("cksum");
     _is_CksumMode = cksumMode;
 
     size_t pos = 0;
@@ -1358,6 +1428,7 @@ void CHandler::ClearVars()
   _is_ZeroMode = false;
   _are_there_Tags = false;
   _are_there_Dirs = false;
+  _is_KnownMethod_in_FileName = false;
   _hashSize_Defined = false;
   _hashSize = 0;
 }
@@ -1366,7 +1437,8 @@ void CHandler::ClearVars()
 Z7_COM7F_IMF(CHandler::Close())
 {
   ClearVars();
-  _nameExtenstion.Empty();
+  _method_from_FileName.Empty();
+  _method_for_Extraction.Empty();
   _pgpMethod.Empty();
   HashPairs.Clear();
   return S_OK;
@@ -1393,19 +1465,73 @@ static bool CheckDigests(const Byte *a, const Byte *b, size_t size)
 }
 
 
-static void AddDefaultMethod(UStringVector &methods, unsigned size)
+static void AddDefaultMethod(UStringVector &methods,
+    const char *name, unsigned size)
 {
+  int shaVersion = -1;
+  if (name)
+  {
+    if (StringsAreEqualNoCase_Ascii(name, "sha"))
+    {
+      shaVersion = 0;
+      if (size == 0)
+        size = 32;
+    }
+    else if (StringsAreEqualNoCase_Ascii(name, "sha1"))
+    {
+      shaVersion = 1;
+      if (size == 0)
+        size = 20;
+    }
+    else if (StringsAreEqualNoCase_Ascii(name, "sha2"))
+    {
+      shaVersion = 2;
+      if (size == 0)
+        size = 32;
+    }
+    else if (StringsAreEqualNoCase_Ascii(name, "sha3"))
+    {
+      if (size == 0 ||
+               size == 32) name = "sha3-256";
+      else if (size == 28) name = "sha3-224";
+      else if (size == 48) name = "sha3-384";
+      else if (size == 64) name = "sha3-512";
+    }
+    else if (StringsAreEqualNoCase_Ascii(name, "sha512"))
+    {
+      // we allow any sha512 derived hash inside .sha512 file:
+           if (size == 48) name = "sha384";
+      else if (size == 32) name = "sha512-256";
+      else if (size == 28) name = "sha512-224";
+    }
+    if (shaVersion >= 0)
+      name = NULL;
+  }
+  
   const char *m = NULL;
-       if (size == 32) m = "sha256";
-  else if (size == 20) m = "sha1";
-  else if (size == 16) m = "md5";
-  else if (size ==  8) m = "crc64";
-  else if (size ==  4) m = "crc32";
+  if (name)
+    m = name;
   else
+  {
+         if (size == 64) m = "sha512";
+    else if (size == 48) m = "sha384";
+    else if (size == 32) m = "sha256";
+    else if (size == 28) m = "sha224";
+    else if (size == 20) m = "sha1";
+    else if (shaVersion < 0)
+    {
+           if (size == 16) m = "md5";
+      else if (size ==  8) m = "crc64";
+      else if (size ==  4) m = "crc32";
+    }
+  }
+
+  if (!m)
     return;
-  #ifdef Z7_EXTERNAL_CODECS
+
+#ifdef Z7_EXTERNAL_CODECS
   const CExternalCodecs *_externalCodecs = g_ExternalCodecs_Ptr;
-  #endif
+#endif
   CMethodId id;
   if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS
       AString(m), id))
@@ -1436,15 +1562,15 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
   CHashBundle hb_Glob;
   // UStringVector methods = options.Methods;
   UStringVector methods;
-  
-  if (methods.IsEmpty() && !_nameExtenstion.IsEmpty())
+
+/*
+  if (methods.IsEmpty() && !utf_nameExtenstion.IsEmpty() && !_hashSize_Defined)
   {
-    AString utf;
-    ConvertUnicodeToUTF8(_nameExtenstion, utf);
     CMethodId id;
-    if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS utf, id))
+    if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS utf_nameExtenstion, id))
       methods.Add(_nameExtenstion);
   }
+*/
   
   if (methods.IsEmpty() && !_pgpMethod.IsEmpty())
   {
@@ -1453,12 +1579,21 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
       methods.Add(UString(_pgpMethod));
   }
 
+/*
   if (methods.IsEmpty() && _pgpMethod.IsEmpty() && _hashSize_Defined)
-    AddDefaultMethod(methods, _hashSize);
+  {
+    AddDefaultMethod(methods,
+        utf_nameExtenstion.IsEmpty() ? NULL : utf_nameExtenstion.Ptr(),
+        _hashSize);
+  }
+*/
 
-  RINOK(hb_Glob.SetMethods(
+  if (!methods.IsEmpty())
+  {
+    RINOK(hb_Glob.SetMethods(
       EXTERNAL_CODECS_LOC_VARS
       methods))
+  }
 
   Z7_DECL_CMyComPtr_QI_FROM(
       IArchiveUpdateCallbackFile,
@@ -1553,9 +1688,11 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     {
       hb_Use = &hb_Loc;
       CMethodId id;
-      if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS hp.Method, id))
+      AString methodName = hp.Method;
+      Convert_TagName_to_MethodName(methodName);
+      if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS methodName, id))
       {
-        methods_loc.Add(UString(hp.Method));
+        methods_loc.Add(UString(methodName));
         RINOK(hb_Loc.SetMethods(
             EXTERNAL_CODECS_LOC_VARS
             methods_loc))
@@ -1565,7 +1702,10 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     }
     else if (methods.IsEmpty())
     {
-      AddDefaultMethod(methods_loc, (unsigned)hp.Hash.Size());
+      AddDefaultMethod(methods_loc,
+          _method_for_Extraction.IsEmpty() ? NULL :
+          _method_for_Extraction.Ptr(),
+          (unsigned)hp.Hash.Size());
       if (!methods_loc.IsEmpty())
       {
         hb_Use = &hb_Loc;
@@ -1613,7 +1753,7 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     Int32 opRes = NArchive::NExtract::NOperationResult::kUnsupportedMethod;
     if (isSupportedMode
         && res_SetMethods != E_NOTIMPL
-        && hb_Use->Hashers.Size() > 0
+        && !hb_Use->Hashers.IsEmpty()
         )
     {
       const CHasherState &hs = hb_Use->Hashers[0];
@@ -1766,10 +1906,6 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
       methods.Add(_methods[k]);
     }
   }
-  else if (_crcSize_WasSet)
-  {
-    AddDefaultMethod(methods, _crcSize);
-  }
   else
   {
     Z7_DECL_CMyComPtr_QI_FROM(
@@ -1781,12 +1917,23 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
       RINOK(getRootProps->GetRootProp(kpidArcFileName, &prop))
       if (prop.vt == VT_BSTR)
       {
-        const UString method = GetMethod_from_FileName(prop.bstrVal);
+        AString method;
+        /* const bool isKnownMethod = */ GetMethod_from_FileName(prop.bstrVal, method);
         if (!method.IsEmpty())
-          methods.Add(method);
+        {
+          AddDefaultMethod(methods, method, _crcSize_WasSet ? _crcSize : 0);
+          if (methods.IsEmpty())
+            return E_NOTIMPL;
+        }
       }
     }
   }
+  if (methods.IsEmpty() && _crcSize_WasSet)
+  {
+    AddDefaultMethod(methods,
+        NULL, // name
+        _crcSize);
+  }
 
   RINOK(hb.SetMethods(EXTERNAL_CODECS_LOC_VARS methods))
 
@@ -2030,6 +2177,15 @@ HRESULT CHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
 }
 
 
+void CHandler::InitProps()
+{
+  _supportWindowsBackslash = true;
+  _crcSize_WasSet = false;
+  _crcSize = 4;
+  _methods.Clear();
+  _options.Init_HashOptionsLocal();
+}
+
 Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
 {
   COM_TRY_BEGIN
@@ -2076,11 +2232,32 @@ void Codecs_AddHashArcHandler(CCodecs *codecs)
   
     // ubuntu uses "SHA256SUMS" file
     item.AddExts(UString (
-        "sha256 sha512 sha224 sha384 sha1 sha md5"
-        // "b2sum"
-        " crc32 crc64"
-        " asc"
+        "sha256"
+        " sha512"
+        " sha384"
+        " sha224"
+        " sha512-224"
+        " sha512-256"
+        " sha3-224"
+        " sha3-256"
+        " sha3-384"
+        " sha3-512"
+        // " shake128"
+        // " shake256"
+        " sha1"
+        " sha2"
+        " sha3"
+        " sha"
+        " md5"
+        " blake2s"
+        " blake2b"
+        " blake2sp"
+        " xxh64"
+        " crc32"
+        " crc64"
         " cksum"
+        " asc"
+        // " b2sum"
         ),
         UString());
 
diff --git a/CPP/7zip/UI/Common/HashCalc.h b/CPP/7zip/UI/Common/HashCalc.h
index 1e9dbf4..b8f867f 100644
--- a/CPP/7zip/UI/Common/HashCalc.h
+++ b/CPP/7zip/UI/Common/HashCalc.h
@@ -279,32 +279,25 @@ Z7_CLASS_IMP_CHandler_IInArchive_3(
   bool _isArc;
   bool _supportWindowsBackslash;
   bool _crcSize_WasSet;
-  UInt64 _phySize;
-  CObjectVector<CHashPair> HashPairs;
-  UString _nameExtenstion;
-  // UString _method_fromName;
-  AString _pgpMethod;
   bool _is_CksumMode;
   bool _is_PgpMethod;
   bool _is_ZeroMode;
   bool _are_there_Tags;
   bool _are_there_Dirs;
+  bool _is_KnownMethod_in_FileName;
   bool _hashSize_Defined;
   unsigned _hashSize;
   UInt32 _crcSize;
+  UInt64 _phySize;
+  CObjectVector<CHashPair> HashPairs;
   UStringVector _methods;
+  AString _method_from_FileName;
+  AString _pgpMethod;
+  AString _method_for_Extraction;
   CHashOptionsLocal _options;
 
   void ClearVars();
-
-  void InitProps()
-  {
-    _supportWindowsBackslash = true;
-    _crcSize_WasSet = false;
-    _crcSize = 4;
-    _methods.Clear();
-    _options.Init_HashOptionsLocal();
-  }
+  void InitProps();
 
   bool CanUpdate() const
   {
diff --git a/CPP/7zip/UI/Common/LoadCodecs.cpp b/CPP/7zip/UI/Common/LoadCodecs.cpp
index 6bf53ea..943435a 100644
--- a/CPP/7zip/UI/Common/LoadCodecs.cpp
+++ b/CPP/7zip/UI/Common/LoadCodecs.cpp
@@ -170,7 +170,7 @@ void CArcInfoEx::AddExts(const UString &ext, const UString &addExt)
     if (i < addExts.Size())
     {
       extInfo.AddExt = addExts[i];
-      if (extInfo.AddExt == L"*")
+      if (extInfo.AddExt.IsEqualTo("*"))
         extInfo.AddExt.Empty();
     }
     Exts.Add(extInfo);
@@ -931,8 +931,8 @@ bool CCodecs::FindFormatForArchiveType(const UString &arcType, CIntVector &forma
     const UString name = arcType.Mid(pos, (unsigned)pos2 - pos);
     if (name.IsEmpty())
       return false;
-    int index = FindFormatForArchiveType(name);
-    if (index < 0 && name != L"*")
+    const int index = FindFormatForArchiveType(name);
+    if (index < 0 && !name.IsEqualTo("*"))
     {
       formatIndices.Clear();
       return false;
diff --git a/CPP/7zip/UI/Common/TempFiles.cpp b/CPP/7zip/UI/Common/TempFiles.cpp
index 2f86838..ad16e36 100644
--- a/CPP/7zip/UI/Common/TempFiles.cpp
+++ b/CPP/7zip/UI/Common/TempFiles.cpp
@@ -13,7 +13,8 @@ void CTempFiles::Clear()
 {
   while (!Paths.IsEmpty())
   {
-    NDir::DeleteFileAlways(Paths.Back());
+    if (NeedDeleteFiles)
+      NDir::DeleteFileAlways(Paths.Back());
     Paths.DeleteBack();
   }
 }
diff --git a/CPP/7zip/UI/Common/TempFiles.h b/CPP/7zip/UI/Common/TempFiles.h
index dd4ac20..83c741f 100644
--- a/CPP/7zip/UI/Common/TempFiles.h
+++ b/CPP/7zip/UI/Common/TempFiles.h
@@ -10,6 +10,9 @@ class CTempFiles
   void Clear();
 public:
   FStringVector Paths;
+  bool NeedDeleteFiles;
+
+  CTempFiles(): NeedDeleteFiles(true) {}
   ~CTempFiles() { Clear(); }
 };
 
diff --git a/CPP/7zip/UI/Common/Update.cpp b/CPP/7zip/UI/Common/Update.cpp
index ed48605..1c2754e 100644
--- a/CPP/7zip/UI/Common/Update.cpp
+++ b/CPP/7zip/UI/Common/Update.cpp
@@ -474,7 +474,7 @@ static HRESULT Compress(
 
   CArcToDoStat stat2;
 
-  if (options.RenamePairs.Size() != 0)
+  if (options.RenameMode || options.RenamePairs.Size() != 0)
   {
     FOR_VECTOR (i, arcItems)
     {
@@ -1096,6 +1096,30 @@ typedef Z7_WIN_MAPISENDMAILW FAR *Z7_WIN_LPMAPISENDMAILW;
 #endif // _WIN32
 
 
+struct C_CopyFileProgress_to_IUpdateCallbackUI2 Z7_final:
+  public ICopyFileProgress
+{
+  IUpdateCallbackUI2 *Callback;
+  HRESULT CallbackResult;
+  // bool Disable_Break;
+
+  virtual DWORD CopyFileProgress(UInt64 total, UInt64 current) Z7_override
+  {
+    const HRESULT res = Callback->MoveArc_Progress(total, current);
+    CallbackResult = res;
+    // if (Disable_Break && res == E_ABORT) res = S_OK;
+    return res == S_OK ? PROGRESS_CONTINUE : PROGRESS_CANCEL;
+  }
+
+  C_CopyFileProgress_to_IUpdateCallbackUI2(
+      IUpdateCallbackUI2 *callback) :
+    Callback(callback),
+    CallbackResult(S_OK)
+    // , Disable_Break(false)
+    {}
+};
+
+
 HRESULT UpdateArchive(
     CCodecs *codecs,
     const CObjectVector<COpenType> &types,
@@ -1311,7 +1335,7 @@ HRESULT UpdateArchive(
       return E_NOTIMPL;
   }
 
-  bool thereIsInArchive = arcLink.IsOpen;
+  const bool thereIsInArchive = arcLink.IsOpen;
   if (!thereIsInArchive && renameMode)
     return E_FAIL;
   
@@ -1588,7 +1612,14 @@ HRESULT UpdateArchive(
   multiStreams.DisableDeletion();
   RINOK(multiStreams.Destruct())
 
-  tempFiles.Paths.Clear();
+  // here we disable deleting of temp archives.
+  // note: archive moving can fail, or it can be interrupted,
+  // if we move new temp update from another volume.
+  // And we still want to keep temp archive in that case,
+  // because we will have deleted original archive.
+  tempFiles.NeedDeleteFiles = false;
+  // tempFiles.Paths.Clear();
+
   if (createTempFile)
   {
     try
@@ -1603,16 +1634,29 @@ HRESULT UpdateArchive(
         if (!DeleteFileAlways(us2fs(arcPath)))
           return errorInfo.SetFromLastError("cannot delete the file", us2fs(arcPath));
       }
-      
-      if (!MyMoveFile(tempPath, us2fs(arcPath)))
+
+      UInt64 totalArcSize = 0;
+      {
+        NFind::CFileInfo fi;
+        if (fi.Find(tempPath))
+          totalArcSize = fi.Size;
+      }
+      RINOK(callback->MoveArc_Start(fs2us(tempPath), arcPath,
+          totalArcSize, BoolToInt(thereIsInArchive)))
+
+      C_CopyFileProgress_to_IUpdateCallbackUI2 prox(callback);
+      // if we update archive, we have removed original archive.
+      // So if we break archive moving, we will have only temporary archive.
+      // We can disable breaking here:
+      // prox.Disable_Break = thereIsInArchive;
+
+      if (!MyMoveFile_with_Progress(tempPath, us2fs(arcPath), &prox))
       {
         errorInfo.SystemError = ::GetLastError();
         errorInfo.Message = "cannot move the file";
         if (errorInfo.SystemError == ERROR_INVALID_PARAMETER)
         {
-          NFind::CFileInfo fi;
-          if (fi.Find(tempPath) &&
-              fi.Size > (UInt32)(Int32)-1)
+          if (totalArcSize > (UInt32)(Int32)-1)
           {
             // bool isFsDetected = false;
             // if (NSystem::Is_File_LimitedBy_4GB(us2fs(arcPath), isFsDetected) || !isFsDetected)
@@ -1622,10 +1666,20 @@ HRESULT UpdateArchive(
             }
           }
         }
+        // if there was no input archive, and we have operation breaking.
+        // then we can remove temporary archive, because we still have original uncompressed files.
+        if (!thereIsInArchive
+            && prox.CallbackResult == E_ABORT)
+          tempFiles.NeedDeleteFiles = true;
         errorInfo.FileNames.Add(tempPath);
         errorInfo.FileNames.Add(us2fs(arcPath));
+        RINOK(prox.CallbackResult)
         return errorInfo.Get_HRESULT_Error();
       }
+
+      // MoveArc_Finish() can return delayed user break (E_ABORT) status,
+      // if callback callee ignored interruption to finish archive creation operation.
+      RINOK(callback->MoveArc_Finish())
       
       /*
       if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_READONLY))
@@ -1866,7 +1920,7 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
       if (NFind::DoesDirExist(phyPath))
       {
         RINOK(callback->DeletingAfterArchiving(phyPath, true))
-        RemoveDir(phyPath);
+        RemoveDirAlways_if_Empty(phyPath);
       }
     }
 
diff --git a/CPP/7zip/UI/Common/Update.h b/CPP/7zip/UI/Common/Update.h
index a9459ff..ae141e5 100644
--- a/CPP/7zip/UI/Common/Update.h
+++ b/CPP/7zip/UI/Common/Update.h
@@ -12,8 +12,6 @@
 #include "UpdateAction.h"
 #include "UpdateCallback.h"
 
-#include "DirItem.h"
-
 enum EArcNameMode
 {
   k_ArcNameMode_Smart,
@@ -96,6 +94,7 @@ struct CUpdateOptions
 
   bool DeleteAfterCompressing;
   bool SetArcMTime;
+  bool RenameMode;
 
   CBoolPair NtSecurity;
   CBoolPair AltStreams;
@@ -141,6 +140,7 @@ struct CUpdateOptions
     
     DeleteAfterCompressing(false),
     SetArcMTime(false),
+    RenameMode(false),
 
     ArcNameMode(k_ArcNameMode_Smart),
     PathMode(NWildcard::k_RelatPath)
@@ -195,6 +195,9 @@ Z7_PURE_INTERFACES_BEGIN
   virtual HRESULT FinishArchive(const CFinishArchiveStat &st) x \
   virtual HRESULT DeletingAfterArchiving(const FString &path, bool isDir) x \
   virtual HRESULT FinishDeletingAfterArchiving() x \
+  virtual HRESULT MoveArc_Start(const wchar_t *srcTempPath, const wchar_t *destFinalPath, UInt64 size, Int32 updateMode) x \
+  virtual HRESULT MoveArc_Progress(UInt64 total, UInt64 current) x \
+  virtual HRESULT MoveArc_Finish() x \
 
 DECLARE_INTERFACE(IUpdateCallbackUI2):
     public IUpdateCallbackUI,
diff --git a/CPP/7zip/UI/Common/UpdateCallback.cpp b/CPP/7zip/UI/Common/UpdateCallback.cpp
index d3ee639..e2f1866 100644
--- a/CPP/7zip/UI/Common/UpdateCallback.cpp
+++ b/CPP/7zip/UI/Common/UpdateCallback.cpp
@@ -32,6 +32,7 @@
 #include "../../../Windows/PropVariant.h"
 
 #include "../../Common/StreamObjects.h"
+#include "../../Archive/Common/ItemNameUtils.h"
 
 #include "UpdateCallback.h"
 
@@ -306,7 +307,7 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetRawProp(UInt32 index, PROPID propID, con
 
 #if defined(_WIN32) && !defined(UNDER_CE)
 
-static UString GetRelativePath(const UString &to, const UString &from)
+static UString GetRelativePath(const UString &to, const UString &from, bool isWSL)
 {
   UStringVector partsTo, partsFrom;
   SplitPathToParts(to, partsTo);
@@ -324,11 +325,12 @@ static UString GetRelativePath(const UString &to, const UString &from)
 
   if (i == 0)
   {
-    #ifdef _WIN32
-    if (NName::IsDrivePath(to) ||
-        NName::IsDrivePath(from))
+#ifdef _WIN32
+    if (isWSL ||
+       (NName::IsDrivePath(to) ||
+        NName::IsDrivePath(from)))
       return to;
-    #endif
+#endif
   }
 
   UString s;
@@ -373,54 +375,87 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PR
         return S_OK;
       }
       
-      #if !defined(UNDER_CE)
-
+#if !defined(UNDER_CE)
       if (up.DirIndex >= 0)
       {
         const CDirItem &di = DirItems->Items[(unsigned)up.DirIndex];
-        
-        #ifdef _WIN32
-        // if (di.IsDir())
+        if (di.ReparseData.Size())
         {
+#ifdef _WIN32
           CReparseAttr attr;
           if (attr.Parse(di.ReparseData, di.ReparseData.Size()))
           {
-            const UString simpleName = attr.GetPath();
-            if (!attr.IsSymLink_WSL() && attr.IsRelative_Win())
-              prop = simpleName;
-            else
+            UString path = attr.GetPath();
+            if (!path.IsEmpty())
             {
-              const FString phyPath = DirItems->GetPhyPath((unsigned)up.DirIndex);
-              FString fullPath;
-              if (NDir::MyGetFullPathName(phyPath, fullPath))
+              bool isWSL = attr.IsSymLink_WSL();
+              if (isWSL)
+                NArchive::NItemName::ReplaceToWinSlashes(path, true); // useBackslashReplacement
+              // it's expected that (path) now uses windows slashes.
+              // CReparseAttr::IsRelative_Win() returns true if FLAG_RELATIVE is set
+              // CReparseAttr::IsRelative_Win() returns true for "\dir1\path"
+              // but we want to store real relative paths without "\" root prefix.
+              // so we parse path instead of IsRelative_Win() calling.
+              if (// attr.IsRelative_Win() ||
+                  (isWSL ?
+                   IS_PATH_SEPAR(path[0]) :
+                   NName::IsAbsolutePath(path)))
               {
-                prop = GetRelativePath(simpleName, fs2us(fullPath));
+                // (path) is abolute path or relative to root: "\path"
+                // we try to convert (path) to relative path for writing to archive.
+                const FString phyPath = DirItems->GetPhyPath((unsigned)up.DirIndex);
+                FString fullPath;
+                if (NDir::MyGetFullPathName(phyPath, fullPath))
+                {
+                  if (IS_PATH_SEPAR(path[0]) &&
+                      !IS_PATH_SEPAR(path[1]))
+                  {
+                    // path is relative to root of (fullPath): "\path"
+                    const unsigned prefixSize = NName::GetRootPrefixSize(fullPath);
+                    if (prefixSize)
+                    {
+                      path.DeleteFrontal(1);
+                      path.Insert(0, fs2us(fullPath.Left(prefixSize)));
+                      // we have changed "\" prefix to drive prefix "c:\" in (path).
+                      // (path) is Windows path now.
+                      isWSL = false;
+                    }
+                  }
+                }
+                path = GetRelativePath(path, fs2us(fullPath), isWSL);
               }
+#if WCHAR_PATH_SEPARATOR != L'/'
+              // 7-Zip's TAR handler in Windows replaces windows slashes to linux slashes.
+              // so we can return any slashes to TAR handler.
+              // or we can convert to linux slashes here,
+              // because input IInArchive handler uses linux slashes for kpidSymLink.
+              // path.Replace(WCHAR_PATH_SEPARATOR, L'/');
+#endif
+              if (!path.IsEmpty())
+                prop = path;
             }
-            prop.Detach(value);
-            return S_OK;
           }
-        }
-        
-        #else // _WIN32
-
-        if (di.ReparseData.Size() != 0)
-        {
+#else // ! _WIN32
           AString utf;
           utf.SetFrom_CalcLen((const char *)(const Byte *)di.ReparseData, (unsigned)di.ReparseData.Size());
-
+    #if 0 // 0 - for debug
+          // it's expected that link data uses system codepage.
+          // fs2us() ignores conversion errors. But we want correct path
+          UString us (fs2us(utf));
+    #else
           UString us;
           if (ConvertUTF8ToUnicode(utf, us))
+    #endif
           {
-            prop = us;
-            prop.Detach(value);
-            return S_OK;
+            if (!us.IsEmpty())
+              prop = us;
           }
+#endif // ! _WIN32
         }
-
-        #endif // _WIN32
+        prop.Detach(value);
+        return S_OK;
       }
-      #endif // !defined(UNDER_CE)
+#endif // !defined(UNDER_CE)
     }
     else if (propID == kpidHardLink)
     {
@@ -428,7 +463,12 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PR
       {
         const CKeyKeyValPair &pair = _map[_hardIndex_To];
         const CUpdatePair2 &up2 = (*UpdatePairs)[pair.Value];
-        prop = DirItems->GetLogPath((unsigned)up2.DirIndex);
+        const UString path = DirItems->GetLogPath((unsigned)up2.DirIndex);
+#if WCHAR_PATH_SEPARATOR != L'/'
+        // 7-Zip's TAR handler in Windows replaces windows slashes to linux slashes.
+        // path.Replace(WCHAR_PATH_SEPARATOR, L'/');
+#endif
+        prop = path;
         prop.Detach(value);
         return S_OK;
       }
@@ -438,7 +478,7 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PR
         return S_OK;
       }
     }
-  }
+  } // if (up.NewData)
   
   if (up.IsAnti
       && propID != kpidIsDir
diff --git a/CPP/7zip/UI/Common/WorkDir.cpp b/CPP/7zip/UI/Common/WorkDir.cpp
index cfec635..a492967 100644
--- a/CPP/7zip/UI/Common/WorkDir.cpp
+++ b/CPP/7zip/UI/Common/WorkDir.cpp
@@ -63,24 +63,22 @@ HRESULT CWorkDirTempFile::CreateTempFile(const FString &originalPath)
   NWorkDir::CInfo workDirInfo;
   workDirInfo.Load();
   FString namePart;
-  const FString workDir = GetWorkDir(workDirInfo, originalPath, namePart);
-  CreateComplexDir(workDir);
+  FString path = GetWorkDir(workDirInfo, originalPath, namePart);
+  CreateComplexDir(path);
+  path += namePart;
   _outStreamSpec = new COutFileStream;
   OutStream = _outStreamSpec;
-  if (!_tempFile.Create(workDir + namePart, &_outStreamSpec->File))
-  {
+  if (!_tempFile.Create(path, &_outStreamSpec->File))
     return GetLastError_noZero_HRESULT();
-  }
   _originalPath = originalPath;
   return S_OK;
 }
 
-HRESULT CWorkDirTempFile::MoveToOriginal(bool deleteOriginal)
+HRESULT CWorkDirTempFile::MoveToOriginal(bool deleteOriginal,
+    NWindows::NFile::NDir::ICopyFileProgress *progress)
 {
   OutStream.Release();
-  if (!_tempFile.MoveTo(_originalPath, deleteOriginal))
-  {
+  if (!_tempFile.MoveTo(_originalPath, deleteOriginal, progress))
     return GetLastError_noZero_HRESULT();
-  }
   return S_OK;
 }
diff --git a/CPP/7zip/UI/Common/WorkDir.h b/CPP/7zip/UI/Common/WorkDir.h
index d32ab9d..fed8c4a 100644
--- a/CPP/7zip/UI/Common/WorkDir.h
+++ b/CPP/7zip/UI/Common/WorkDir.h
@@ -11,7 +11,7 @@
 
 FString GetWorkDir(const NWorkDir::CInfo &workDirInfo, const FString &path, FString &fileName);
 
-class CWorkDirTempFile
+class CWorkDirTempFile  MY_UNCOPYABLE
 {
   FString _originalPath;
   NWindows::NFile::NDir::CTempFile _tempFile;
@@ -19,8 +19,12 @@ class CWorkDirTempFile
 public:
   CMyComPtr<IOutStream> OutStream;
 
+  const FString &Get_OriginalFilePath() const { return _originalPath; }
+  const FString &Get_TempFilePath() const { return _tempFile.GetPath(); }
+
   HRESULT CreateTempFile(const FString &originalPath);
-  HRESULT MoveToOriginal(bool deleteOriginal);
+  HRESULT MoveToOriginal(bool deleteOriginal,
+      NWindows::NFile::NDir::ICopyFileProgress *progress = NULL);
 };
 
 #endif
diff --git a/CPP/7zip/UI/Common/ZipRegistry.cpp b/CPP/7zip/UI/Common/ZipRegistry.cpp
index 73c56cf..936b888 100644
--- a/CPP/7zip/UI/Common/ZipRegistry.cpp
+++ b/CPP/7zip/UI/Common/ZipRegistry.cpp
@@ -45,8 +45,8 @@ static void Key_Set_UInt32(CKey &key, LPCTSTR name, UInt32 value)
 
 static void Key_Get_UInt32(CKey &key, LPCTSTR name, UInt32 &value)
 {
-  if (key.QueryValue(name, value) != ERROR_SUCCESS)
-    value = (UInt32)(Int32)-1;
+  value = (UInt32)(Int32)-1;
+  key.GetValue_UInt32_IfOk(name, value);
 }
 
 
@@ -59,7 +59,7 @@ static void Key_Set_BoolPair(CKey &key, LPCTSTR name, const CBoolPair &b)
 static void Key_Set_bool_if_Changed(CKey &key, LPCTSTR name, bool val)
 {
   bool oldVal = false;
-  if (key.GetValue_IfOk(name, oldVal) == ERROR_SUCCESS)
+  if (key.GetValue_bool_IfOk(name, oldVal) == ERROR_SUCCESS)
     if (val == oldVal)
       return;
   key.SetValue(name, val);
@@ -76,13 +76,13 @@ static void Key_Set_BoolPair_Delete_IfNotDef(CKey &key, LPCTSTR name, const CBoo
 static void Key_Get_BoolPair(CKey &key, LPCTSTR name, CBoolPair &b)
 {
   b.Val = false;
-  b.Def = (key.GetValue_IfOk(name, b.Val) == ERROR_SUCCESS);
+  b.Def = (key.GetValue_bool_IfOk(name, b.Val) == ERROR_SUCCESS);
 }
 
 static void Key_Get_BoolPair_true(CKey &key, LPCTSTR name, CBoolPair &b)
 {
   b.Val = true;
-  b.Def = (key.GetValue_IfOk(name, b.Val) == ERROR_SUCCESS);
+  b.Def = (key.GetValue_bool_IfOk(name, b.Val) == ERROR_SUCCESS);
 }
 
 namespace NExtract
@@ -155,12 +155,12 @@ void CInfo::Load()
   
   key.GetValue_Strings(kPathHistory, Paths);
   UInt32 v;
-  if (key.QueryValue(kExtractMode, v) == ERROR_SUCCESS && v <= NPathMode::kAbsPaths)
+  if (key.GetValue_UInt32_IfOk(kExtractMode, v) == ERROR_SUCCESS && v <= NPathMode::kAbsPaths)
   {
     PathMode = (NPathMode::EEnum)v;
     PathMode_Force = true;
   }
-  if (key.QueryValue(kOverwriteMode, v) == ERROR_SUCCESS && v <= NOverwriteMode::kRenameExisting)
+  if (key.GetValue_UInt32_IfOk(kOverwriteMode, v) == ERROR_SUCCESS && v <= NOverwriteMode::kRenameExisting)
   {
     OverwriteMode = (NOverwriteMode::EEnum)v;
     OverwriteMode_Force = true;
@@ -181,7 +181,7 @@ bool Read_ShowPassword()
   bool showPassword = false;
   if (OpenMainKey(key, kKeyName) != ERROR_SUCCESS)
     return showPassword;
-  key.GetValue_IfOk(kShowPassword, showPassword);
+  key.GetValue_bool_IfOk(kShowPassword, showPassword);
   return showPassword;
 }
 
@@ -189,13 +189,10 @@ UInt32 Read_LimitGB()
 {
   CS_LOCK
   CKey key;
+  UInt32 v = (UInt32)(Int32)-1;
   if (OpenMainKey(key, kKeyName) == ERROR_SUCCESS)
-  {
-    UInt32 v;
-    if (key.QueryValue(kMemLimit, v) == ERROR_SUCCESS)
-      return v;
-  }
-  return (UInt32)(Int32)-1;
+    key.GetValue_UInt32_IfOk(kMemLimit, v);
+  return v;
 }
 
 }
@@ -371,9 +368,9 @@ void CInfo::Load()
   UString a;
   if (key.QueryValue(kArchiver, a) == ERROR_SUCCESS)
     ArcType = a;
-  key.GetValue_IfOk(kLevel, Level);
-  key.GetValue_IfOk(kShowPassword, ShowPassword);
-  key.GetValue_IfOk(kEncryptHeaders, EncryptHeaders);
+  key.GetValue_UInt32_IfOk(kLevel, Level);
+  key.GetValue_bool_IfOk(kShowPassword, ShowPassword);
+  key.GetValue_bool_IfOk(kEncryptHeaders, EncryptHeaders);
 }
 
 
@@ -517,7 +514,7 @@ void CInfo::Load()
     return;
 
   UInt32 dirType;
-  if (key.QueryValue(kWorkDirType, dirType) != ERROR_SUCCESS)
+  if (key.GetValue_UInt32_IfOk(kWorkDirType, dirType) != ERROR_SUCCESS)
     return;
   switch (dirType)
   {
@@ -535,7 +532,7 @@ void CInfo::Load()
     if (Mode == NMode::kSpecified)
       Mode = NMode::kSystem;
   }
-  key.GetValue_IfOk(kTempRemovableOnly, ForRemovableOnly);
+  key.GetValue_bool_IfOk(kTempRemovableOnly, ForRemovableOnly);
 }
 
 }
@@ -598,5 +595,5 @@ void CContextMenuInfo::Load()
 
   Key_Get_UInt32(key, kWriteZoneId, WriteZone);
 
-  Flags_Def = (key.GetValue_IfOk(kContextMenu, Flags) == ERROR_SUCCESS);
+  Flags_Def = (key.GetValue_UInt32_IfOk(kContextMenu, Flags) == ERROR_SUCCESS);
 }
diff --git a/CPP/7zip/UI/Console/ConsoleClose.cpp b/CPP/7zip/UI/Console/ConsoleClose.cpp
index 9e4c040..a184ffb 100644
--- a/CPP/7zip/UI/Console/ConsoleClose.cpp
+++ b/CPP/7zip/UI/Console/ConsoleClose.cpp
@@ -16,7 +16,7 @@
 namespace NConsoleClose {
 
 unsigned g_BreakCounter = 0;
-static const unsigned kBreakAbortThreshold = 2;
+static const unsigned kBreakAbortThreshold = 3;
 
 #ifdef _WIN32
 
@@ -28,8 +28,7 @@ static BOOL WINAPI HandlerRoutine(DWORD ctrlType)
     return TRUE;
   }
 
-  g_BreakCounter++;
-  if (g_BreakCounter < kBreakAbortThreshold)
+  if (++g_BreakCounter < kBreakAbortThreshold)
     return TRUE;
   return FALSE;
   /*
@@ -47,7 +46,7 @@ static BOOL WINAPI HandlerRoutine(DWORD ctrlType)
 CCtrlHandlerSetter::CCtrlHandlerSetter()
 {
   if (!SetConsoleCtrlHandler(HandlerRoutine, TRUE))
-    throw "SetConsoleCtrlHandler fails";
+    throw 1019; // "SetConsoleCtrlHandler fails";
 }
 
 CCtrlHandlerSetter::~CCtrlHandlerSetter()
@@ -63,8 +62,7 @@ CCtrlHandlerSetter::~CCtrlHandlerSetter()
 
 static void HandlerRoutine(int)
 {
-  g_BreakCounter++;
-  if (g_BreakCounter < kBreakAbortThreshold)
+  if (++g_BreakCounter < kBreakAbortThreshold)
     return;
   exit(EXIT_FAILURE);
 }
diff --git a/CPP/7zip/UI/Console/ConsoleClose.h b/CPP/7zip/UI/Console/ConsoleClose.h
index 25c5d0c..b0d99b4 100644
--- a/CPP/7zip/UI/Console/ConsoleClose.h
+++ b/CPP/7zip/UI/Console/ConsoleClose.h
@@ -5,7 +5,7 @@
 
 namespace NConsoleClose {
 
-class CCtrlBreakException {};
+// class CCtrlBreakException {};
 
 #ifdef UNDER_CE
 
diff --git a/CPP/7zip/UI/Console/ExtractCallbackConsole.cpp b/CPP/7zip/UI/Console/ExtractCallbackConsole.cpp
index f59d4c1..b127631 100644
--- a/CPP/7zip/UI/Console/ExtractCallbackConsole.cpp
+++ b/CPP/7zip/UI/Console/ExtractCallbackConsole.cpp
@@ -928,7 +928,7 @@ HRESULT CExtractCallbackConsole::ExtractResult(HRESULT result)
     if (result == E_ABORT
         || result == HRESULT_FROM_WIN32(ERROR_DISK_FULL))
       return result;
-    NumArcsWithError++; 
+    NumArcsWithError++;
     
     if (_se)
     {
diff --git a/CPP/7zip/UI/Console/Main.cpp b/CPP/7zip/UI/Console/Main.cpp
index dabd696..90e00a4 100644
--- a/CPP/7zip/UI/Console/Main.cpp
+++ b/CPP/7zip/UI/Console/Main.cpp
@@ -908,9 +908,12 @@ int Main2(
 
   if (options.EnableHeaders)
   {
-    ShowCopyrightAndHelp(g_StdStream, false);
-    if (!parser.Parse1Log.IsEmpty())
-      *g_StdStream << parser.Parse1Log;
+    if (g_StdStream)
+    {
+      ShowCopyrightAndHelp(g_StdStream, false);
+      if (!parser.Parse1Log.IsEmpty())
+        *g_StdStream << parser.Parse1Log;
+    }
   }
 
   parser.Parse2(options);
diff --git a/CPP/7zip/UI/Console/MainAr.cpp b/CPP/7zip/UI/Console/MainAr.cpp
index 602ab64..490950b 100644
--- a/CPP/7zip/UI/Console/MainAr.cpp
+++ b/CPP/7zip/UI/Console/MainAr.cpp
@@ -140,11 +140,13 @@ int Z7_CDECL main
     PrintError(kMemoryExceptionMessage);
     return (NExitCode::kMemoryError);
   }
+/*
   catch(const NConsoleClose::CCtrlBreakException &)
   {
     PrintError(kUserBreakMessage);
     return (NExitCode::kUserBreak);
   }
+*/
   catch(const CMessagePathException &e)
   {
     PrintError(kException_CmdLine_Error_Message);
diff --git a/CPP/7zip/UI/Console/PercentPrinter.h b/CPP/7zip/UI/Console/PercentPrinter.h
index 46988a5..379aa1b 100644
--- a/CPP/7zip/UI/Console/PercentPrinter.h
+++ b/CPP/7zip/UI/Console/PercentPrinter.h
@@ -26,6 +26,13 @@ struct CPercentPrinterState
 
 class CPercentPrinter: public CPercentPrinterState
 {
+public:
+  CStdOutStream *_so;
+  bool DisablePrint;
+  bool NeedFlush;
+  unsigned MaxLen;
+  
+private:
   UInt32 _tickStep;
   DWORD _prevTick;
 
@@ -41,18 +48,13 @@ class CPercentPrinter: public CPercentPrinterState
   void GetPercents();
 
 public:
-  CStdOutStream *_so;
-
-  bool DisablePrint;
-  bool NeedFlush;
-  unsigned MaxLen;
   
   CPercentPrinter(UInt32 tickStep = 200):
-      _tickStep(tickStep),
-      _prevTick(0),
       DisablePrint(false),
       NeedFlush(true),
-      MaxLen(80 - 1)
+      MaxLen(80 - 1),
+      _tickStep(tickStep),
+      _prevTick(0)
   {}
 
   ~CPercentPrinter();
diff --git a/CPP/7zip/UI/Console/UpdateCallbackConsole.cpp b/CPP/7zip/UI/Console/UpdateCallbackConsole.cpp
index 3e79645..5185d5c 100644
--- a/CPP/7zip/UI/Console/UpdateCallbackConsole.cpp
+++ b/CPP/7zip/UI/Console/UpdateCallbackConsole.cpp
@@ -361,6 +361,119 @@ HRESULT CUpdateCallbackConsole::WriteSfx(const wchar_t *name, UInt64 size)
 }
 
 
+
+HRESULT CUpdateCallbackConsole::MoveArc_UpdateStatus()
+{
+  if (NeedPercents())
+  {
+    AString &s = _percent.Command;
+    s = " : ";
+    s.Add_UInt64(_arcMoving_percents);
+    s.Add_Char('%');
+    const bool totalDefined = (_arcMoving_total != 0 && _arcMoving_total != (UInt64)(Int64)-1);
+    if (_arcMoving_current != 0 || totalDefined)
+    {
+      s += " : ";
+      s.Add_UInt64(_arcMoving_current >> 20);
+      s += " MiB";
+    }
+    if (totalDefined)
+    {
+      s += " / ";
+      s.Add_UInt64((_arcMoving_total + ((1 << 20) - 1)) >> 20);
+      s += " MiB";
+    }
+    s += " : temporary archive moving ...";
+    _percent.Print();
+  }
+
+  // we ignore single Ctrl-C, if (_arcMoving_updateMode) mode
+  // because we want to get good final archive instead of temp archive.
+  if (NConsoleClose::g_BreakCounter == 1 && _arcMoving_updateMode)
+    return S_OK;
+  return CheckBreak();
+}
+
+
+HRESULT CUpdateCallbackConsole::MoveArc_Start(
+    const wchar_t *srcTempPath, const wchar_t *destFinalPath,
+    UInt64 size, Int32 updateMode)
+{
+#if 0 // 1 : for debug
+  if (LogLevel > 0 && _so)
+  {
+    ClosePercents_for_so();
+    *_so << "Temporary archive moving:" << endl;
+    _tempU = srcTempPath;
+    _so->Normalize_UString_Path(_tempU);
+    _so->PrintUString(_tempU, _tempA);
+    *_so << endl;
+    _tempU = destFinalPath;
+    _so->Normalize_UString_Path(_tempU);
+    _so->PrintUString(_tempU, _tempA);
+    *_so << endl;
+  }
+#else
+  UNUSED_VAR(srcTempPath)
+  UNUSED_VAR(destFinalPath)
+#endif
+
+  _arcMoving_updateMode = updateMode;
+  _arcMoving_total = size;
+  _arcMoving_current = 0;
+  _arcMoving_percents = 0;
+  return MoveArc_UpdateStatus();
+}
+
+
+HRESULT CUpdateCallbackConsole::MoveArc_Progress(UInt64 totalSize, UInt64 currentSize)
+{
+#if 0 // 1 : for debug
+  if (_so)
+  {
+    ClosePercents_for_so();
+    *_so << totalSize << " : " << currentSize << endl;
+  }
+#endif
+
+  UInt64 percents = 0;
+  if (totalSize != 0)
+  {
+    if (totalSize < ((UInt64)1 << 57))
+      percents = currentSize * 100 / totalSize;
+    else
+      percents = currentSize / (totalSize / 100);
+  }
+
+#ifdef _WIN32
+  // Sleep(300); // for debug
+#endif
+  // totalSize = (UInt64)(Int64)-1; // for debug
+
+  if (percents == _arcMoving_percents)
+    return CheckBreak();
+  _arcMoving_current = currentSize;
+  _arcMoving_total = totalSize;
+  _arcMoving_percents = percents;
+  return MoveArc_UpdateStatus();
+}
+
+
+HRESULT CUpdateCallbackConsole::MoveArc_Finish()
+{
+  // _arcMoving_percents = 0;
+  if (NeedPercents())
+  {
+    _percent.Command.Empty();
+    _percent.Print();
+  }
+  // it can return delayed user break (E_ABORT) status,
+  // if it ignored single CTRL+C in MoveArc_Progress().
+  return CheckBreak();
+}
+
+
+
 HRESULT CUpdateCallbackConsole::DeletingAfterArchiving(const FString &path, bool /* isDir */)
 {
   if (LogLevel > 0 && _so)
diff --git a/CPP/7zip/UI/Console/UpdateCallbackConsole.h b/CPP/7zip/UI/Console/UpdateCallbackConsole.h
index 276edba..a386371 100644
--- a/CPP/7zip/UI/Console/UpdateCallbackConsole.h
+++ b/CPP/7zip/UI/Console/UpdateCallbackConsole.h
@@ -29,30 +29,31 @@ struct CErrorPathCodes
 
 class CCallbackConsoleBase
 {
-protected:
-  CPercentPrinter _percent;
+  void CommonError(const FString &path, DWORD systemError, bool isWarning);
 
+protected:
   CStdOutStream *_so;
   CStdOutStream *_se;
 
-  void CommonError(const FString &path, DWORD systemError, bool isWarning);
-  // void CommonError(const char *message);
-
   HRESULT ScanError_Base(const FString &path, DWORD systemError);
   HRESULT OpenFileError_Base(const FString &name, DWORD systemError);
   HRESULT ReadingFileError_Base(const FString &name, DWORD systemError);
 
 public:
-  bool NeedPercents() const { return _percent._so != NULL; }
-
   bool StdOutMode;
-
   bool NeedFlush;
   unsigned PercentsNameLevel;
   unsigned LogLevel;
 
+protected:
   AString _tempA;
   UString _tempU;
+  CPercentPrinter _percent;
+
+public:
+  CErrorPathCodes FailedFiles;
+  CErrorPathCodes ScanErrors;
+  UInt64 NumNonOpenFiles;
 
   CCallbackConsoleBase():
       StdOutMode(false),
@@ -62,6 +63,7 @@ public:
       NumNonOpenFiles(0)
       {}
   
+  bool NeedPercents() const { return _percent._so != NULL; }
   void SetWindowWidth(unsigned width) { _percent.MaxLen = width - 1; }
 
   void Init(
@@ -90,10 +92,6 @@ public:
       _percent.ClosePrint(false);
   }
 
-  CErrorPathCodes FailedFiles;
-  CErrorPathCodes ScanErrors;
-  UInt64 NumNonOpenFiles;
-
   HRESULT PrintProgress(const wchar_t *name, bool isDir, const char *command, bool showInLog);
 
   // void PrintInfoLine(const UString &s);
@@ -109,6 +107,14 @@ class CUpdateCallbackConsole Z7_final:
   Z7_IFACE_IMP(IUpdateCallbackUI)
   Z7_IFACE_IMP(IDirItemsCallback)
   Z7_IFACE_IMP(IUpdateCallbackUI2)
+
+  HRESULT MoveArc_UpdateStatus();
+
+  UInt64 _arcMoving_total;
+  UInt64 _arcMoving_current;
+  UInt64 _arcMoving_percents;
+  Int32  _arcMoving_updateMode;
+
 public:
   bool DeleteMessageWasShown;
 
@@ -119,7 +125,11 @@ public:
   #endif
 
   CUpdateCallbackConsole():
-      DeleteMessageWasShown(false)
+        _arcMoving_total(0)
+      , _arcMoving_current(0)
+      , _arcMoving_percents(0)
+      , _arcMoving_updateMode(0)
+      , DeleteMessageWasShown(false)
       #ifndef Z7_NO_CRYPTO
       , PasswordIsDefined(false)
       , AskPassword(false)
diff --git a/CPP/7zip/UI/Console/makefile b/CPP/7zip/UI/Console/makefile
index a20b0cc..d449b38 100644
--- a/CPP/7zip/UI/Console/makefile
+++ b/CPP/7zip/UI/Console/makefile
@@ -59,10 +59,10 @@ COMPRESS_OBJS = \
 C_OBJS = $(C_OBJS) \
   $O\Alloc.obj \
   $O\CpuArch.obj \
-  $O\Sort.obj \
   $O\Threads.obj \
 
 !include "../../Crc.mak"
+!include "../../Sort.mak"
 !include "Console.mak"
 
 !include "../../7zip.mak"
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.cpp b/CPP/7zip/UI/Explorer/ContextMenu.cpp
index fab3493..0630d78 100644
--- a/CPP/7zip/UI/Explorer/ContextMenu.cpp
+++ b/CPP/7zip/UI/Explorer/ContextMenu.cpp
@@ -295,9 +295,13 @@ static const CHashCommand g_HashCommands[] =
 {
   { CZipContextMenu::kHash_CRC32,  "CRC-32",  "CRC32" },
   { CZipContextMenu::kHash_CRC64,  "CRC-64",  "CRC64" },
-  { CZipContextMenu::kHash_XXH64,  "XXH64",    "XXH64" },
+  { CZipContextMenu::kHash_XXH64,  "XXH64",   "XXH64" },
+  { CZipContextMenu::kHash_MD5,    "MD5",     "MD5" },
   { CZipContextMenu::kHash_SHA1,   "SHA-1",   "SHA1" },
   { CZipContextMenu::kHash_SHA256, "SHA-256", "SHA256" },
+  { CZipContextMenu::kHash_SHA384, "SHA-384", "SHA384" },
+  { CZipContextMenu::kHash_SHA512, "SHA-512", "SHA512" },
+  { CZipContextMenu::kHash_SHA3_256, "SHA3-256", "SHA3-256" },
   { CZipContextMenu::kHash_BLAKE2SP, "BLAKE2sp", "BLAKE2sp" },
   { CZipContextMenu::kHash_All,    "*",       "*" },
   { CZipContextMenu::kHash_Generate_SHA256, "SHA-256 -> file.sha256", "SHA256" },
@@ -1338,8 +1342,12 @@ HRESULT CZipContextMenu::InvokeCommandCommon(const CCommandMapItem &cmi)
       case kHash_CRC32:
       case kHash_CRC64:
       case kHash_XXH64:
+      case kHash_MD5:
       case kHash_SHA1:
       case kHash_SHA256:
+      case kHash_SHA384:
+      case kHash_SHA512:
+      case kHash_SHA3_256:
       case kHash_BLAKE2SP:
       case kHash_All:
       case kHash_Generate_SHA256:
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.h b/CPP/7zip/UI/Explorer/ContextMenu.h
index a68ba9d..2759967 100644
--- a/CPP/7zip/UI/Explorer/ContextMenu.h
+++ b/CPP/7zip/UI/Explorer/ContextMenu.h
@@ -88,8 +88,12 @@ public:
     kHash_CRC32,
     kHash_CRC64,
     kHash_XXH64,
+    kHash_MD5,
     kHash_SHA1,
     kHash_SHA256,
+    kHash_SHA384,
+    kHash_SHA512,
+    kHash_SHA3_256,
     kHash_BLAKE2SP,
     kHash_All,
     kHash_Generate_SHA256,
diff --git a/CPP/7zip/UI/Explorer/makefile b/CPP/7zip/UI/Explorer/makefile
index 3901d6b..311d70e 100644
--- a/CPP/7zip/UI/Explorer/makefile
+++ b/CPP/7zip/UI/Explorer/makefile
@@ -72,7 +72,7 @@ FM_OBJS = \
 
 C_OBJS = \
   $O\CpuArch.obj \
-  $O\Sort.obj \
   $O\Threads.obj \
 
+!include "../../Sort.mak"
 !include "../../7zip.mak"
diff --git a/CPP/7zip/UI/Far/Far.cpp b/CPP/7zip/UI/Far/Far.cpp
index 211dde8..962af97 100644
--- a/CPP/7zip/UI/Far/Far.cpp
+++ b/CPP/7zip/UI/Far/Far.cpp
@@ -116,15 +116,16 @@ Z7_CLASS_IMP_COM_3(
   // DWORD m_StartTickValue;
   bool m_MessageBoxIsShown;
 
-  CProgressBox _progressBox;
-
   bool _numFilesTotalDefined;
   bool _numBytesTotalDefined;
-
 public:
   bool PasswordIsDefined;
   UString Password;
 
+private:
+  CProgressBox _progressBox;
+public:
+
   COpenArchiveCallback()
     {}
   
diff --git a/CPP/7zip/UI/Far/FarUtils.cpp b/CPP/7zip/UI/Far/FarUtils.cpp
index ed61ccc..3c33d8e 100644
--- a/CPP/7zip/UI/Far/FarUtils.cpp
+++ b/CPP/7zip/UI/Far/FarUtils.cpp
@@ -281,7 +281,7 @@ UInt32 CStartupInfo::QueryRegKeyValue(HKEY parentKey, const char *keyName,
     return valueDefault;
   
   UInt32 value;
-  if (regKey.QueryValue(valueName, value) != ERROR_SUCCESS)
+  if (regKey.GetValue_UInt32_IfOk(valueName, value) != ERROR_SUCCESS)
     return valueDefault;
   
   return value;
@@ -295,7 +295,7 @@ bool CStartupInfo::QueryRegKeyValue(HKEY parentKey, const char *keyName,
     return valueDefault;
   
   bool value;
-  if (regKey.QueryValue(valueName, value) != ERROR_SUCCESS)
+  if (regKey.GetValue_bool_IfOk(valueName, value) != ERROR_SUCCESS)
     return valueDefault;
   
   return value;
diff --git a/CPP/7zip/UI/Far/Plugin.cpp b/CPP/7zip/UI/Far/Plugin.cpp
index 2d31b8a..b7f91d6 100644
--- a/CPP/7zip/UI/Far/Plugin.cpp
+++ b/CPP/7zip/UI/Far/Plugin.cpp
@@ -61,7 +61,6 @@ static void MyGetFileTime(IFolderFolder *folder, UInt32 itemIndex,
 }
 
 #define kDotsReplaceString "[[..]]"
-#define kDotsReplaceStringU L"[[..]]"
   
 static void CopyStrLimited(char *dest, const AString &src, unsigned len)
 {
@@ -84,7 +83,7 @@ void CPlugin::ReadPluginPanelItem(PluginPanelItem &panelItem, UInt32 itemIndex)
     throw 272340;
 
   AString oemString (UnicodeStringToMultiByte(prop.bstrVal, CP_OEMCP));
-  if (oemString == "..")
+  if (oemString.IsEqualTo(".."))
     oemString = kDotsReplaceString;
 
   COPY_STR_LIMITED(panelItem.FindData.cFileName, oemString);
@@ -193,7 +192,7 @@ void CPlugin::EnterToDirectory(const UString &dirName)
 {
   CMyComPtr<IFolderFolder> newFolder;
   UString s = dirName;
-  if (dirName == kDotsReplaceStringU)
+  if (dirName.IsEqualTo(kDotsReplaceString))
     s = "..";
   _folder->BindToFolder(s, &newFolder);
   if (!newFolder)
@@ -209,12 +208,12 @@ void CPlugin::EnterToDirectory(const UString &dirName)
 int CPlugin::SetDirectory(const char *aszDir, int /* opMode */)
 {
   UString path = MultiByteToUnicodeString(aszDir, CP_OEMCP);
-  if (path == WSTRING_PATH_SEPARATOR)
+  if (path.IsEqualTo(STRING_PATH_SEPARATOR))
   {
     _folder.Release();
     m_ArchiveHandler->BindToRootFolder(&_folder);
   }
-  else if (path == L"..")
+  else if (path.IsEqualTo(".."))
   {
     CMyComPtr<IFolderFolder> newFolder;
     _folder->BindToParentFolder(&newFolder);
diff --git a/CPP/7zip/UI/Far/ProgressBox.h b/CPP/7zip/UI/Far/ProgressBox.h
index 6e8b487..f6b36c4 100644
--- a/CPP/7zip/UI/Far/ProgressBox.h
+++ b/CPP/7zip/UI/Far/ProgressBox.h
@@ -45,7 +45,12 @@ class CProgressBox: public CPercentPrinterState
   DWORD _prevElapsedSec;
 
   bool _wasPrinted;
+public:
+  bool UseBytesForPercents;
+  DWORD StartTick;
+  unsigned MaxLen;
 
+private:
   UString _tempU;
   UString _name1U;
   UString _name2U;
@@ -64,15 +69,12 @@ class CProgressBox: public CPercentPrinterState
   void ReduceString(const UString &src, AString &dest);
 
 public:
-  DWORD StartTick;
-  bool UseBytesForPercents;
-  unsigned MaxLen;
 
   CProgressBox(UInt32 tickStep = 200):
       _tickStep(tickStep),
       _prevTick(0),
-      StartTick(0),
       UseBytesForPercents(true),
+      StartTick(0),
       MaxLen(60)
     {}
 
diff --git a/CPP/7zip/UI/Far/UpdateCallbackFar.cpp b/CPP/7zip/UI/Far/UpdateCallbackFar.cpp
index 94f0a47..16702d3 100644
--- a/CPP/7zip/UI/Far/UpdateCallbackFar.cpp
+++ b/CPP/7zip/UI/Far/UpdateCallbackFar.cpp
@@ -210,6 +210,96 @@ Z7_COM7F_IMF(CUpdateCallback100Imp::ReportUpdateOperation(UInt32 op, const wchar
 }
 
 
+HRESULT CUpdateCallback100Imp::MoveArc_UpdateStatus()
+{
+  MT_LOCK
+
+  if (_percent)
+  {
+    AString s;
+    s.Add_UInt64(_arcMoving_percents);
+    // status.Add_Space();
+    s.Add_Char('%');
+    const bool totalDefined = (_arcMoving_total != 0 && _arcMoving_total != (UInt64)(Int64)-1);
+    if (_arcMoving_current != 0 || totalDefined)
+    {
+      s += " : ";
+      s.Add_UInt64(_arcMoving_current >> 20);
+      s += " MiB";
+    }
+    if (totalDefined)
+    {
+      s += " / ";
+      s.Add_UInt64((_arcMoving_total + ((1 << 20) - 1)) >> 20);
+      s += " MiB";
+    }
+    s += " : temporary archive moving ...";
+    _percent->Command =  s;
+    _percent->Print();
+  }
+
+  return CheckBreak2();
+}
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::MoveArc_Start(const wchar_t *srcTempPath, const wchar_t * /* destFinalPath */ , UInt64 size, Int32 /* updateMode */))
+{
+  MT_LOCK
+
+  _arcMoving_total = size;
+  _arcMoving_current = 0;
+  _arcMoving_percents = 0;
+  // _arcMoving_updateMode = updateMode;
+  // _name2 = fs2us(destFinalPath);
+  if (_percent)
+    _percent->FileName = srcTempPath;
+  return MoveArc_UpdateStatus();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::MoveArc_Progress(UInt64 totalSize, UInt64 currentSize))
+{
+  UInt64 percents = 0;
+  if (totalSize != 0)
+  {
+    if (totalSize < ((UInt64)1 << 57))
+      percents = currentSize * 100 / totalSize;
+    else
+      percents = currentSize / (totalSize / 100);
+  }
+
+#ifdef _WIN32
+  // Sleep(300); // for debug
+#endif
+  if (percents == _arcMoving_percents)
+    return CheckBreak2();
+  _arcMoving_total = totalSize;
+  _arcMoving_current = currentSize;
+  _arcMoving_percents = percents;
+  // if (_arcMoving_percents > 100) return E_FAIL;
+  return MoveArc_UpdateStatus();
+}
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::MoveArc_Finish())
+{
+  // _arcMoving_percents = 0;
+  if (_percent)
+  {
+    _percent->Command.Empty();
+    _percent->FileName.Empty();
+    _percent->Print();
+  }
+  return CheckBreak2();
+}
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::Before_ArcReopen())
+{
+  // fixme: we can use Clear_Stop_Status() here
+  return CheckBreak2();
+}
+
+
 extern HRESULT GetPassword(UString &password);
 
 Z7_COM7F_IMF(CUpdateCallback100Imp::CryptoGetTextPassword(BSTR *password))
diff --git a/CPP/7zip/UI/Far/UpdateCallbackFar.h b/CPP/7zip/UI/Far/UpdateCallbackFar.h
index 4ec5eed..8d2c8b8 100644
--- a/CPP/7zip/UI/Far/UpdateCallbackFar.h
+++ b/CPP/7zip/UI/Far/UpdateCallbackFar.h
@@ -11,10 +11,11 @@
 
 #include "ProgressBox.h"
 
-Z7_CLASS_IMP_COM_6(
+Z7_CLASS_IMP_COM_7(
   CUpdateCallback100Imp
   , IFolderArchiveUpdateCallback
   , IFolderArchiveUpdateCallback2
+  , IFolderArchiveUpdateCallback_MoveArc
   , IFolderScanProgress
   , ICryptoGetTextPassword2
   , ICryptoGetTextPassword
@@ -25,6 +26,15 @@ Z7_CLASS_IMP_COM_6(
   // CMyComPtr<IInFolderArchive> _archiveHandler;
   CProgressBox *_percent;
   // UInt64 _total;
+
+  HRESULT MoveArc_UpdateStatus();
+
+private:
+  UInt64 _arcMoving_total;
+  UInt64 _arcMoving_current;
+  UInt64 _arcMoving_percents;
+  // Int32  _arcMoving_updateMode;
+
 public:
   bool PasswordIsDefined;
   UString Password;
@@ -38,6 +48,10 @@ public:
     _percent = progressBox;
     PasswordIsDefined = false;
     Password.Empty();
+    _arcMoving_total = 0;
+    _arcMoving_current = 0;
+    _arcMoving_percents = 0;
+    //  _arcMoving_updateMode = 0;
   }
 };
 
diff --git a/CPP/7zip/UI/Far/makefile b/CPP/7zip/UI/Far/makefile
index a66f9d7..7bc166b 100644
--- a/CPP/7zip/UI/Far/makefile
+++ b/CPP/7zip/UI/Far/makefile
@@ -99,9 +99,9 @@ COMPRESS_OBJS = \
 C_OBJS = \
   $O\Alloc.obj \
   $O\CpuArch.obj \
-  $O\Sort.obj \
   $O\Threads.obj \
 
 !include "../../Crc.mak"
+!include "../../Sort.mak"
 
 !include "../../7zip.mak"
diff --git a/CPP/7zip/UI/FileManager/App.cpp b/CPP/7zip/UI/FileManager/App.cpp
index 06c2e8b..5b7d616 100644
--- a/CPP/7zip/UI/FileManager/App.cpp
+++ b/CPP/7zip/UI/FileManager/App.cpp
@@ -402,11 +402,17 @@ void CApp::Save()
   // Save_ShowDeleted(ShowDeletedFiles);
 }
 
-void CApp::Release()
+void CApp::ReleaseApp()
 {
+  // 24.09: ReleasePanel() will stop panel timer processing.
+  // but we want to stop timer processing for all panels
+  // before ReleasePanel() calling.
+  unsigned i;
+  for (i = 0; i < kNumPanelsMax; i++)
+    Panels[i].Disable_Processing_Timer_Notify_StatusBar();
   // It's for unloading COM dll's: don't change it.
-  for (unsigned i = 0; i < kNumPanelsMax; i++)
-    Panels[i].Release();
+  for (i = 0; i < kNumPanelsMax; i++)
+    Panels[i].ReleasePanel();
 }
 
 // reduces path to part that exists on disk (or root prefix of path)
@@ -644,7 +650,7 @@ void CApp::OnCopy(bool move, bool copyToSame, unsigned srcPanelIndex)
     destPath += correctName;
 
     #if defined(_WIN32) && !defined(UNDER_CE)
-    if (destPath.Len() > 0 && destPath[0] == '\\')
+    if (destPath.Len() != 0 && destPath[0] == '\\')
       if (destPath.Len() == 1 || destPath[1] != '\\')
       {
         srcPanel.MessageBox_Error_UnsupportOperation();
diff --git a/CPP/7zip/UI/FileManager/App.h b/CPP/7zip/UI/FileManager/App.h
index 1e20532..cf74d6a 100644
--- a/CPP/7zip/UI/FileManager/App.h
+++ b/CPP/7zip/UI/FileManager/App.h
@@ -109,7 +109,7 @@ public:
   HRESULT Create(HWND hwnd, const UString &mainPath, const UString &arcFormat, int xSizes[2], bool needOpenArc, COpenResult &openRes);
   void Read();
   void Save();
-  void Release();
+  void ReleaseApp();
 
   // void SetFocus(int panelIndex) { Panels[panelIndex].SetFocusToList(); }
   void SetFocusToLastItem() { Panels[LastFocusedPanel].SetFocusToLastRememberedItem(); }
diff --git a/CPP/7zip/UI/FileManager/ExtractCallback.cpp b/CPP/7zip/UI/FileManager/ExtractCallback.cpp
index 6ec6065..da25969 100644
--- a/CPP/7zip/UI/FileManager/ExtractCallback.cpp
+++ b/CPP/7zip/UI/FileManager/ExtractCallback.cpp
@@ -2,7 +2,6 @@
 
 #include "StdAfx.h"
 
-
 #include "../../../Common/ComTry.h"
 #include "../../../Common/IntToString.h"
 #include "../../../Common/Lang.h"
@@ -27,11 +26,11 @@
 #include "ExtractCallback.h"
 #include "FormatUtils.h"
 #include "LangUtils.h"
+#include "MemDialog.h"
 #include "OverwriteDialog.h"
 #ifndef Z7_NO_CRYPTO
 #include "PasswordDialog.h"
 #endif
-#include "MemDialog.h"
 #include "PropertyName.h"
 
 using namespace NWindows;
@@ -44,9 +43,9 @@ CExtractCallbackImp::~CExtractCallbackImp() {}
 
 void CExtractCallbackImp::Init()
 {
-  _lang_Extracting = LangString(IDS_PROGRESS_EXTRACTING);
-  _lang_Testing = LangString(IDS_PROGRESS_TESTING);
-  _lang_Skipping = LangString(IDS_PROGRESS_SKIPPING);
+  LangString(IDS_PROGRESS_EXTRACTING, _lang_Extracting);
+  LangString(IDS_PROGRESS_TESTING, _lang_Testing);
+  LangString(IDS_PROGRESS_SKIPPING, _lang_Skipping);
   _lang_Reading = "Reading";
 
   NumArchiveErrors = 0;
@@ -107,19 +106,19 @@ HRESULT CExtractCallbackImp::Open_SetTotal(const UInt64 *files, const UInt64 *by
   {
     if (files)
     {
-      _totalFilesDefined = true;
+      _totalFiles_Defined = true;
       // res = ProgressDialog->Sync.Set_NumFilesTotal(*files);
     }
     else
-      _totalFilesDefined = false;
+      _totalFiles_Defined = false;
 
     if (bytes)
     {
-      _totalBytesDefined = true;
+      _totalBytes_Defined = true;
       ProgressDialog->Sync.Set_NumBytesTotal(*bytes);
     }
     else
-      _totalBytesDefined = false;
+      _totalBytes_Defined = false;
   }
 
   return res;
@@ -217,7 +216,7 @@ Z7_COM7F_IMF(CExtractCallbackImp::AskOverwrite(
   dialog.NewFileInfo.Is_FileSystemFile = Src_Is_IO_FS_Folder;
   
   ProgressDialog->WaitCreating();
-  INT_PTR writeAnswer = dialog.Create(*ProgressDialog);
+  const INT_PTR writeAnswer = dialog.Create(*ProgressDialog);
   
   switch (writeAnswer)
   {
@@ -478,10 +477,10 @@ UString GetOpenArcErrorMessage(UInt32 errorFlags)
 
   for (unsigned i = 0; i < Z7_ARRAY_SIZE(k_ErrorFlagsIds); i++)
   {
-    UInt32 f = ((UInt32)1 << i);
+    const UInt32 f = (UInt32)1 << i;
     if ((errorFlags & f) == 0)
       continue;
-    UInt32 id = k_ErrorFlagsIds[i];
+    const UInt32 id = k_ErrorFlagsIds[i];
     UString m = LangString(id);
     if (m.IsEmpty())
       continue;
@@ -512,8 +511,8 @@ UString GetOpenArcErrorMessage(UInt32 errorFlags)
 
 static void ErrorInfo_Print(UString &s, const CArcErrorInfo &er)
 {
-  UInt32 errorFlags = er.GetErrorFlags();
-  UInt32 warningFlags = er.GetWarningFlags();
+  const UInt32 errorFlags = er.GetErrorFlags();
+  const UInt32 warningFlags = er.GetWarningFlags();
 
   if (errorFlags != 0)
     AddNewLineString(s, GetOpenArcErrorMessage(errorFlags));
@@ -524,7 +523,7 @@ static void ErrorInfo_Print(UString &s, const CArcErrorInfo &er)
   if (warningFlags != 0)
   {
     s += GetNameOfProperty(kpidWarningFlags, L"Warnings");
-    s += ":";
+    s.Add_Colon();
     s.Add_LF();
     AddNewLineString(s, GetOpenArcErrorMessage(warningFlags));
   }
@@ -852,34 +851,35 @@ Z7_COM7F_IMF(CExtractCallbackImp::GetStream7(const wchar_t *name,
   _newVirtFileWasAdded = false;
   _hashStream_WasUsed = false;
   _needUpdateStat = false;
+  _isFolder = IntToBool(isDir);
+  _curSize_Defined = false;
+  _curSize = 0;
 
   if (_hashStream)
     _hashStream->ReleaseStream();
 
-  GetItemBoolProp(getProp, kpidIsAltStream, _isAltStream);
-
-  if (!ProcessAltStreams && _isAltStream)
-    return S_OK;
-
   _filePath = name;
-  _isFolder = IntToBool(isDir);
-  _curSize = 0;
-  _curSize_Defined = false;
 
   UInt64 size = 0;
-  bool sizeDefined;
+  bool size_Defined;
   {
     NCOM::CPropVariant prop;
     RINOK(getProp->GetProp(kpidSize, &prop))
-    sizeDefined = ConvertPropVariantToUInt64(prop, size);
+    size_Defined = ConvertPropVariantToUInt64(prop, size);
   }
-
-  if (sizeDefined)
+  if (size_Defined)
   {
     _curSize = size;
     _curSize_Defined = true;
   }
 
+  GetItemBoolProp(getProp, kpidIsAltStream, _isAltStream);
+  if (!ProcessAltStreams && _isAltStream)
+    return S_OK;
+
+  if (isDir) // we don't support dir items extraction in this code
+    return S_OK;
+
   if (askExtractMode != NArchive::NExtract::NAskMode::kExtract &&
       askExtractMode != NArchive::NExtract::NAskMode::kTest)
     return S_OK;
@@ -890,40 +890,64 @@ Z7_COM7F_IMF(CExtractCallbackImp::GetStream7(const wchar_t *name,
   
   if (VirtFileSystem && askExtractMode == NArchive::NExtract::NAskMode::kExtract)
   {
-    CVirtFile &file = VirtFileSystemSpec->AddNewFile();
+    if (!VirtFileSystemSpec->Files.IsEmpty())
+      VirtFileSystemSpec->MaxTotalAllocSize -= VirtFileSystemSpec->Files.Back().Data.Size();
+    CVirtFile &file = VirtFileSystemSpec->Files.AddNew();
     _newVirtFileWasAdded = true;
-    file.Name = name;
-    file.IsDir = IntToBool(isDir);
+    // file.IsDir = _isFolder;
     file.IsAltStream = _isAltStream;
-    file.Size = 0;
+    file.WrittenSize = 0;
+    file.ExpectedSize = 0;
+    if (size_Defined)
+      file.ExpectedSize = size;
 
-    RINOK(GetTime(getProp, kpidCTime, file.CTime, file.CTimeDefined))
-    RINOK(GetTime(getProp, kpidATime, file.ATime, file.ATimeDefined))
-    RINOK(GetTime(getProp, kpidMTime, file.MTime, file.MTimeDefined))
+    if (VirtFileSystemSpec->Index_of_MainExtractedFile_in_Files < 0)
+      if (!file.IsAltStream || VirtFileSystemSpec->IsAltStreamFile)
+        VirtFileSystemSpec->Index_of_MainExtractedFile_in_Files =
+            (int)(VirtFileSystemSpec->Files.Size() - 1);
 
-    NCOM::CPropVariant prop;
-    RINOK(getProp->GetProp(kpidAttrib, &prop))
-    if (prop.vt == VT_UI4)
+    /* if we open only AltStream, then (name) contains only name without "fileName:" prefix */
+    file.BaseName = name;
+
+    if (file.IsAltStream
+        && !VirtFileSystemSpec->IsAltStreamFile
+        && file.BaseName.IsPrefixedBy_NoCase(VirtFileSystemSpec->FileName))
     {
-      file.Attrib = prop.ulVal;
-      file.AttribDefined = true;
+      const unsigned colonPos = VirtFileSystemSpec->FileName.Len();
+      if (file.BaseName[colonPos] == ':')
+      {
+        file.ColonWasUsed = true;
+        file.AltStreamName = name + (size_t)colonPos + 1;
+        file.BaseName.DeleteFrom(colonPos);
+        if (Is_ZoneId_StreamName(file.AltStreamName))
+        {
+          if (VirtFileSystemSpec->Index_of_ZoneBuf_AltStream_in_Files < 0)
+            VirtFileSystemSpec->Index_of_ZoneBuf_AltStream_in_Files =
+              (int)(VirtFileSystemSpec->Files.Size() - 1);
+        }
+      }
+    }
+    RINOK(GetTime(getProp, kpidCTime, file.CTime, file.CTime_Defined))
+    RINOK(GetTime(getProp, kpidATime, file.ATime, file.ATime_Defined))
+    RINOK(GetTime(getProp, kpidMTime, file.MTime, file.MTime_Defined))
+    {
+      NCOM::CPropVariant prop;
+      RINOK(getProp->GetProp(kpidAttrib, &prop))
+      if (prop.vt == VT_UI4)
+      {
+        file.Attrib = prop.ulVal;
+        file.Attrib_Defined = true;
+      }
     }
-    // else if (isDir) file.Attrib = FILE_ATTRIBUTE_DIRECTORY;
-
-    file.ExpectedSize = 0;
-    if (sizeDefined)
-      file.ExpectedSize = size;
     outStreamLoc = VirtFileSystem;
   }
 
   if (_hashStream)
   {
-    {
-      _hashStream->SetStream(outStreamLoc);
-      outStreamLoc = _hashStream;
-      _hashStream->Init(true);
-      _hashStream_WasUsed = true;
-    }
+    _hashStream->SetStream(outStreamLoc);
+    outStreamLoc = _hashStream;
+    _hashStream->Init(true);
+    _hashStream_WasUsed = true;
   }
 
   if (outStreamLoc)
@@ -1077,10 +1101,10 @@ Z7_COM7F_IMF(CExtractCallbackImp::RequestMemoryUse(
     // if (indexType == NArchive::NEventIndexType::kNoIndex)
     if ((flags & NRequestMemoryUseFlags::k_SkipArc_IsExpected) ||
         (flags & NRequestMemoryUseFlags::k_Report_SkipArc))
-      s += LangString(IDS_MSG_ARC_UNPACKING_WAS_SKIPPED);
+      AddLangString(s, IDS_MSG_ARC_UNPACKING_WAS_SKIPPED);
 /*
     else
-      s += LangString(IDS_MSG_ARC_FILES_UNPACKING_WAS_SKIPPED);
+      AddLangString(, IDS_MSG_ARC_FILES_UNPACKING_WAS_SKIPPED);
 */
     AddError_Message_ShowArcPath(s);
   }
@@ -1093,88 +1117,154 @@ Z7_COM7F_IMF(CExtractCallbackImp::RequestMemoryUse(
 }
 
 
-
-// static const UInt32 kBlockSize = ((UInt32)1 << 31);
-
 Z7_COM7F_IMF(CVirtFileSystem::Write(const void *data, UInt32 size, UInt32 *processedSize))
 {
   if (processedSize)
     *processedSize = 0;
   if (size == 0)
     return S_OK;
-  if (!_fileMode)
+  if (!_wasSwitchedToFsMode)
   {
     CVirtFile &file = Files.Back();
-    size_t rem = file.Data.Size() - (size_t)file.Size;
+    const size_t rem = file.Data.Size() - file.WrittenSize;
     bool useMem = true;
     if (rem < size)
     {
       UInt64 b = 0;
       if (file.Data.Size() == 0)
         b = file.ExpectedSize;
-      UInt64 a = file.Size + size;
+      UInt64 a = (UInt64)file.WrittenSize + size;
       if (b < a)
         b = a;
       a = (UInt64)file.Data.Size() * 2;
       if (b < a)
         b = a;
       useMem = false;
-      const size_t b_sizet = (size_t)b;
-      if (b == b_sizet && b <= MaxTotalAllocSize)
-        useMem = file.Data.ReAlloc_KeepData(b_sizet, (size_t)file.Size);
+      if (b <= MaxTotalAllocSize)
+        useMem = file.Data.ReAlloc_KeepData((size_t)b, file.WrittenSize);
     }
+
+#if 0 // 1 for debug : FLUSHING TO FS
+    useMem = false;
+#endif
+
     if (useMem)
     {
-      memcpy(file.Data + file.Size, data, size);
-      file.Size += size;
+      memcpy(file.Data + file.WrittenSize, data, size);
+      file.WrittenSize += size;
       if (processedSize)
         *processedSize = (UInt32)size;
       return S_OK;
     }
-    _fileMode = true;
+    _wasSwitchedToFsMode = true;
+  }
+  
+  if (!_newVirtFileStream_IsReadyToWrite) // we check for _newVirtFileStream_IsReadyToWrite to optimize execution
+  {
+    RINOK(FlushToDisk(false))
   }
-  RINOK(FlushToDisk(false))
-  return _outFileStream.Interface()->Write(data, size, processedSize);
+
+  if (_needWriteToRealFile)
+    return _outFileStream.Interface()->Write(data, size, processedSize);
+  if (processedSize)
+    *processedSize = size;
+  return S_OK;
 }
 
 
 HRESULT CVirtFileSystem::FlushToDisk(bool closeLast)
 {
-  _outFileStream.Create_if_Empty();
   while (_numFlushed < Files.Size())
   {
-    const CVirtFile &file = Files[_numFlushed];
-    const FString path = DirPrefix + us2fs(Get_Correct_FsFile_Name(file.Name));
-    if (!_fileIsOpen)
+    CVirtFile &file = Files[_numFlushed];
+    const FString basePath = DirPrefix + us2fs(Get_Correct_FsFile_Name(file.BaseName));
+    FString path = basePath;
+
+    if (file.ColonWasUsed)
     {
-      if (!_outFileStream->Create_NEW(path))
+      if (ZoneBuf.Size() != 0
+          && Is_ZoneId_StreamName(file.AltStreamName))
       {
-        // do we need to release stream here?
-        // _outFileStream.Release();
-        return E_FAIL;
-        // MessageBoxMyError(UString("Can't create file ") + fs2us(tempFilePath));
+        // it's expected that
+        // CArchiveExtractCallback::GetStream() have excluded
+        // ZoneId alt stream from extraction already.
+        // But we exclude alt stream extraction here too.
+        _numFlushed++;
+        continue;
       }
-      _fileIsOpen = true;
-      RINOK(WriteStream(_outFileStream, file.Data, (size_t)file.Size))
+      path.Add_Colon();
+      path += us2fs(Get_Correct_FsFile_Name(file.AltStreamName));
     }
+
+    if (!_newVirtFileStream_IsReadyToWrite)
+    {
+      if (file.ColonWasUsed)
+      {
+        NFind::CFileInfo parentFi;
+        if (parentFi.Find(basePath)
+            && parentFi.IsReadOnly())
+        {
+          _altStream_NeedRestore_Attrib_bool = true;
+          _altStream_NeedRestore_AttribVal = parentFi.Attrib;
+          NDir::SetFileAttrib(basePath, parentFi.Attrib & ~(DWORD)FILE_ATTRIBUTE_READONLY);
+        }
+      }
+      _outFileStream.Create_if_Empty();
+      _needWriteToRealFile = _outFileStream->Create_NEW(path);
+      if (!_needWriteToRealFile)
+      {
+        if (!file.ColonWasUsed)
+          return GetLastError_noZero_HRESULT(); // it's main file and we can't ignore such error.
+        // (file.ColonWasUsed == true)
+        // So it's additional alt stream.
+        // And we ignore file creation error for additional alt stream.
+        // ShowErrorMessage(UString("Can't create file ") + fs2us(path));
+      }
+      _newVirtFileStream_IsReadyToWrite = true;
+      // _openFilePath = path;
+      HRESULT hres = S_OK;
+      if (_needWriteToRealFile)
+        hres = WriteStream(_outFileStream, file.Data, file.WrittenSize);
+      // we free allocated memory buffer after data flushing:
+      file.WrittenSize = 0;
+      file.Data.Free();
+      RINOK(hres)
+    }
+    
     if (_numFlushed == Files.Size() - 1 && !closeLast)
       break;
-    if (file.CTimeDefined ||
-        file.ATimeDefined ||
-        file.MTimeDefined)
-      _outFileStream->SetTime(
-          file.CTimeDefined ? &file.CTime : NULL,
-          file.ATimeDefined ? &file.ATime : NULL,
-          file.MTimeDefined ? &file.MTime : NULL);
-    _outFileStream->Close();
+    
+    if (_needWriteToRealFile)
+    {
+      if (file.CTime_Defined ||
+          file.ATime_Defined ||
+          file.MTime_Defined)
+        _outFileStream->SetTime(
+          file.CTime_Defined ? &file.CTime : NULL,
+          file.ATime_Defined ? &file.ATime : NULL,
+          file.MTime_Defined ? &file.MTime : NULL);
+      _outFileStream->Close();
+    }
+    
     _numFlushed++;
-    _fileIsOpen = false;
+    _newVirtFileStream_IsReadyToWrite = false;
 
-    if (ZoneBuf.Size() != 0)
-      WriteZoneFile_To_BaseFile(path, ZoneBuf);
-
-    if (file.AttribDefined)
-      NDir::SetFileAttrib_PosixHighDetect(path, file.Attrib);
+    if (_needWriteToRealFile)
+    {
+      if (!file.ColonWasUsed
+          && ZoneBuf.Size() != 0)
+        WriteZoneFile_To_BaseFile(path, ZoneBuf);
+      if (file.Attrib_Defined)
+        NDir::SetFileAttrib_PosixHighDetect(path, file.Attrib);
+      // _openFilePath.Empty();
+      _needWriteToRealFile = false;
+    }
+      
+    if (_altStream_NeedRestore_Attrib_bool)
+    {
+      _altStream_NeedRestore_Attrib_bool = false;
+      NDir::SetFileAttrib(basePath, _altStream_NeedRestore_AttribVal);
+    }
   }
   return S_OK;
 }
diff --git a/CPP/7zip/UI/FileManager/ExtractCallback.h b/CPP/7zip/UI/FileManager/ExtractCallback.h
index 5c459aa..8b4dcb3 100644
--- a/CPP/7zip/UI/FileManager/ExtractCallback.h
+++ b/CPP/7zip/UI/FileManager/ExtractCallback.h
@@ -25,10 +25,6 @@
 
 #include "ProgressDialog2.h"
 
-#ifdef Z7_LANG
-// #include "LangUtils.h"
-#endif
-
 #ifndef Z7_SFX
 
 class CGrowBuf
@@ -39,12 +35,24 @@ class CGrowBuf
   Z7_CLASS_NO_COPY(CGrowBuf)
 
 public:
+  void Free()
+  {
+    MyFree(_items);
+    _items = NULL;
+    _size = 0;
+  }
+
+  // newSize >= keepSize
   bool ReAlloc_KeepData(size_t newSize, size_t keepSize)
   {
-    void *buf = MyAlloc(newSize);
-    if (!buf)
-      return false;
-    if (keepSize != 0)
+    void *buf = NULL;
+    if (newSize)
+    {
+      buf = MyAlloc(newSize);
+      if (!buf)
+        return false;
+    }
+    if (keepSize)
       memcpy(buf, _items, keepSize);
     MyFree(_items);
     _items = (Byte *)buf;
@@ -60,23 +68,27 @@ public:
   size_t Size() const { return _size; }
 };
 
+
 struct CVirtFile
 {
   CGrowBuf Data;
   
-  UInt64 Size; // real size
-  UInt64 ExpectedSize; // the size from props request. 0 if unknown
-
-  UString Name;
-
-  bool CTimeDefined;
-  bool ATimeDefined;
-  bool MTimeDefined;
-  bool AttribDefined;
+  UInt64 ExpectedSize; // size from props request. 0 if unknown
+  size_t WrittenSize;  // size of written data in (Data) buffer
+                       //   use (WrittenSize) only if (CVirtFileSystem::_newVirtFileStream_IsReadyToWrite == false)
+  UString BaseName;    // original name of file inside archive,
+                       // It's not path. So any path separators
+                       // should be treated as part of name (or as incorrect chars)
+  UString AltStreamName;
+
+  bool CTime_Defined;
+  bool ATime_Defined;
+  bool MTime_Defined;
+  bool Attrib_Defined;
   
-  bool IsDir;
+  // bool IsDir;
   bool IsAltStream;
-  
+  bool ColonWasUsed;
   DWORD Attrib;
 
   FILETIME CTime;
@@ -84,82 +96,82 @@ struct CVirtFile
   FILETIME MTime;
 
   CVirtFile():
-    CTimeDefined(false),
-    ATimeDefined(false),
-    MTimeDefined(false),
-    AttribDefined(false),
-    IsDir(false),
-    IsAltStream(false) {}
+    CTime_Defined(false),
+    ATime_Defined(false),
+    MTime_Defined(false),
+    Attrib_Defined(false),
+    // IsDir(false),
+    IsAltStream(false),
+    ColonWasUsed(false)
+    {}
 };
 
 
+/*
+  We use CVirtFileSystem only for single file extraction:
+  It supports the following cases and names:
+     - "fileName" : single file
+     - "fileName" item (main base file) and additional "fileName:altStream" items
+     - "altStream" : single item without "fileName:" prefix.
+  If file is flushed to disk, it uses Get_Correct_FsFile_Name(name).
+*/
+ 
 Z7_CLASS_IMP_NOQIB_1(
   CVirtFileSystem,
   ISequentialOutStream
 )
-  UInt64 _totalAllocSize;
-
-  size_t _pos;
   unsigned _numFlushed;
-  bool _fileIsOpen;
-  bool _fileMode;
+public:
+  bool IsAltStreamFile; // in:
+      // = true,  if extracting file is alt stream without "fileName:" prefix.
+      // = false, if extracting file is normal file, but additional
+      //          alt streams "fileName:altStream" items are possible.
+private:
+  bool _newVirtFileStream_IsReadyToWrite;    // it can non real file (if can't open alt stream)
+  bool _needWriteToRealFile;  // we need real writing to open file.
+  bool _wasSwitchedToFsMode;
+  bool _altStream_NeedRestore_Attrib_bool;
+  DWORD _altStream_NeedRestore_AttribVal;
+
   CMyComPtr2<ISequentialOutStream, COutFileStream> _outFileStream;
 public:
   CObjectVector<CVirtFile> Files;
-  UInt64 MaxTotalAllocSize;
-  FString DirPrefix;
+  size_t MaxTotalAllocSize; // remain size, including Files.Back()
+  FString DirPrefix; // files will be flushed to this FS directory.
+  UString FileName; // name of file that will be extracted.
+                    // it can be name of alt stream without "fileName:" prefix, if (IsAltStreamFile == trye).
+                    // we use that name to detect altStream part in "FileName:altStream".
   CByteBuffer ZoneBuf;
+  int Index_of_MainExtractedFile_in_Files; // out: index in Files. == -1, if expected file was not extracted
+  int Index_of_ZoneBuf_AltStream_in_Files; // out: index in Files. == -1, if no zonbuf alt stream
+  
 
-
-  CVirtFile &AddNewFile()
+  CVirtFileSystem()
   {
-    if (!Files.IsEmpty())
-    {
-      MaxTotalAllocSize -= Files.Back().Data.Size();
-    }
-    return Files.AddNew();
+    _numFlushed = 0;
+    IsAltStreamFile = false;
+    _newVirtFileStream_IsReadyToWrite = false;
+    _needWriteToRealFile = false;
+    _wasSwitchedToFsMode = false;
+    _altStream_NeedRestore_Attrib_bool = false;
+    MaxTotalAllocSize = (size_t)0 - 1;
+    Index_of_MainExtractedFile_in_Files = -1;
+    Index_of_ZoneBuf_AltStream_in_Files = -1;
   }
+
+  bool WasStreamFlushedToFS() const { return _wasSwitchedToFsMode; }
+
   HRESULT CloseMemFile()
   {
-    if (_fileMode)
-    {
-      return FlushToDisk(true);
-    }
+    if (_wasSwitchedToFsMode)
+      return FlushToDisk(true); // closeLast
     CVirtFile &file = Files.Back();
-    if (file.Data.Size() != file.Size)
-    {
-      file.Data.ReAlloc_KeepData((size_t)file.Size, (size_t)file.Size);
-    }
+    if (file.Data.Size() != file.WrittenSize)
+      file.Data.ReAlloc_KeepData(file.WrittenSize, file.WrittenSize);
     return S_OK;
   }
 
-  bool IsStreamInMem() const
-  {
-    if (_fileMode)
-      return false;
-    if (Files.Size() < 1 || /* Files[0].IsAltStream || */ Files[0].IsDir)
-      return false;
-    return true;
-  }
-
-  size_t GetMemStreamWrittenSize() const { return _pos; }
-
-  CVirtFileSystem():
-    MaxTotalAllocSize((UInt64)0 - 1)
-    {}
-
-  void Init()
-  {
-    _totalAllocSize = 0;
-    _fileMode = false;
-    _pos = 0;
-    _numFlushed = 0;
-    _fileIsOpen = false;
-  }
-
-  HRESULT CloseFile(const FString &path);
   HRESULT FlushToDisk(bool closeLast);
-  size_t GetPos() const { return _pos; }
 };
 
 #endif
@@ -217,12 +229,12 @@ class CExtractCallbackImp Z7_final:
 
   bool _needWriteArchivePath;
   bool _isFolder;
-  bool _totalFilesDefined;
-  bool _totalBytesDefined;
+  bool _totalFiles_Defined;
+  bool _totalBytes_Defined;
 public:
   bool MultiArcMode;
   bool ProcessAltStreams;
-  bool StreamMode;
+  bool StreamMode; // set to true, if you want the callee to call GetStream7()
   bool ThereAreMessageErrors;
   bool Src_Is_IO_FS_Folder;
 
@@ -246,9 +258,17 @@ private:
   bool _skipArc;
 #endif
 
+public:
+  bool YesToAll;
+  bool TestMode;
+
+  UInt32 NumArchiveErrors;
+  NExtract::NOverwriteMode::EEnum OverwriteMode;
+
+private:
   UString _currentArchivePath;
   UString _currentFilePath;
-  UString _filePath;
+  UString _filePath;  // virtual path than will be sent via IFolderExtractToStreamCallback
 
 #ifndef Z7_SFX
   UInt64 _curSize;
@@ -266,12 +286,6 @@ public:
   UInt64 NumFiles;
 #endif
 
-  UInt32 NumArchiveErrors;
-  NExtract::NOverwriteMode::EEnum OverwriteMode;
-
-  bool YesToAll;
-  bool TestMode;
-
 #ifndef Z7_NO_CRYPTO
   UString Password;
 #endif
@@ -283,8 +297,8 @@ public:
   UString _lang_Empty;
 
   CExtractCallbackImp():
-      _totalFilesDefined(false)
-    , _totalBytesDefined(false)
+      _totalFiles_Defined(false)
+    , _totalBytes_Defined(false)
     , MultiArcMode(false)
     , ProcessAltStreams(true)
     , StreamMode(false)
@@ -297,11 +311,13 @@ public:
 #ifndef Z7_SFX
     , _remember(false)
     , _skipArc(false)
-    , _hashCalc(NULL)
 #endif
-    , OverwriteMode(NExtract::NOverwriteMode::kAsk)
     , YesToAll(false)
     , TestMode(false)
+    , OverwriteMode(NExtract::NOverwriteMode::kAsk)
+#ifndef Z7_SFX
+    , _hashCalc(NULL)
+#endif
     {}
    
   ~CExtractCallbackImp();
diff --git a/CPP/7zip/UI/FileManager/FM.cpp b/CPP/7zip/UI/FileManager/FM.cpp
index fe4f2bd..b2f4c2b 100644
--- a/CPP/7zip/UI/FileManager/FM.cpp
+++ b/CPP/7zip/UI/FileManager/FM.cpp
@@ -63,8 +63,8 @@ bool g_LargePagesMode = false;
 static bool g_Maximized = false;
 
 extern
-UInt64 g_RAM_Size;
-UInt64 g_RAM_Size;
+size_t g_RAM_Size;
+size_t g_RAM_Size;
 
 #ifdef _WIN32
 extern
@@ -651,7 +651,7 @@ static int WINAPI WinMain2(int nCmdShow)
   SplitStringToTwoStrings(commandsString, paramString, tailString);
   paramString.Trim();
   tailString.Trim();
-  if (tailString.IsPrefixedBy(L"-t"))
+  if (tailString.IsPrefixedBy("-t"))
     g_ArcFormat = tailString.Ptr(2);
 
   /*
@@ -1025,8 +1025,11 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
       break;
     }
 
-    case WM_DESTROY:
+    case WM_CLOSE:
     {
+      // why do we use WA_INACTIVE here ?
+      SendMessage(hWnd, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), (LPARAM)hWnd);
+      g_ExitEventLauncher.Exit(false);
       // ::DragAcceptFiles(hWnd, FALSE);
       RevokeDragDrop(hWnd);
       g_App._dropTarget.Release();
@@ -1034,12 +1037,18 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
       if (g_WindowWasCreated)
         g_App.Save();
     
-      g_App.Release();
+      g_App.ReleaseApp();
       
       if (g_WindowWasCreated)
         SaveWindowInfo(hWnd);
 
       g_ExitEventLauncher.Exit(true);
+      // default DefWindowProc will call DestroyWindow / WM_DESTROY
+      break;
+    }
+
+    case WM_DESTROY:
+    {
       PostQuitMessage(0);
       break;
     }
diff --git a/CPP/7zip/UI/FileManager/LangUtils.cpp b/CPP/7zip/UI/FileManager/LangUtils.cpp
index 8fcb507..4712192 100644
--- a/CPP/7zip/UI/FileManager/LangUtils.cpp
+++ b/CPP/7zip/UI/FileManager/LangUtils.cpp
@@ -309,15 +309,13 @@ void ReloadLang()
 {
   g_Lang.Clear();
   ReadRegLang(g_LangID);
-  #ifndef _UNICODE
-  if (g_IsNT)
-  #endif
+  if (g_LangID.IsEmpty())
   {
-    if (g_LangID.IsEmpty())
-    {
+#ifndef _UNICODE
+    if (g_IsNT)
+#endif
       OpenDefaultLang();
-      return;
-    }
+    return;
   }
   if (g_LangID.Len() > 1 || g_LangID[0] != L'-')
   {
diff --git a/CPP/7zip/UI/FileManager/LinkDialog.cpp b/CPP/7zip/UI/FileManager/LinkDialog.cpp
index 0f24761..a92ee4d 100644
--- a/CPP/7zip/UI/FileManager/LinkDialog.cpp
+++ b/CPP/7zip/UI/FileManager/LinkDialog.cpp
@@ -45,28 +45,24 @@ static bool GetSymLink(CFSTR path, CReparseAttr &attr, UString &errorMessage)
   CByteBuffer buf;
   if (!NIO::GetReparseData(path, buf, NULL))
     return false;
-  
   if (!attr.Parse(buf, buf.Size()))
   {
     SetLastError(attr.ErrorCode);
     return false;
   }
-
   CByteBuffer data2;
-  if (!FillLinkData(data2, attr.GetPath(),
-      !attr.IsMountPoint(), attr.IsSymLink_WSL()))
+  FillLinkData(data2, attr.GetPath(),
+      !attr.IsMountPoint(), attr.IsSymLink_WSL());
+  if (data2.Size() == 0)
   {
     errorMessage = "Cannot reproduce reparse point";
     return false;
   }
-    
-  if (data2.Size() != buf.Size() ||
-      memcmp(data2, buf, buf.Size()) != 0)
+  if (data2 != buf)
   {
     errorMessage = "mismatch for reproduced reparse point";
     return false;
   }
-
   return true;
 }
 
@@ -113,8 +109,8 @@ bool CLinkDialog::OnInit()
         const bool res = GetSymLink(us2fs(FilePath), attr, error);
         if (!res && error.IsEmpty())
         {
-          DWORD lastError = GetLastError();
-          if (lastError != 0)
+          const DWORD lastError = GetLastError();
+          if (lastError)
             error = NError::MyFormatMessage(lastError);
         }
         
@@ -319,10 +315,10 @@ void CLinkDialog::OnButton_Link()
       return;
     }
 
-    const bool isSymLink = (idb != IDR_LINK_TYPE_JUNCTION);
-    
     CByteBuffer data;
-    if (!FillLinkData(data, to, isSymLink, isWSL))
+    const bool isSymLink = (idb != IDR_LINK_TYPE_JUNCTION);
+    FillLinkData(data, to, isSymLink, isWSL);
+    if (data.Size() == 0)
     {
       ShowError(L"Incorrect link");
       return;
@@ -386,6 +382,9 @@ void CApp::Link()
         path = destPanel.GetFsPath();
   }
 
+  CSelectedState srcSelState;
+  srcPanel.SaveSelectedState(srcSelState);
+
   CLinkDialog dlg;
   dlg.CurDirPrefix = fsPrefix;
   dlg.FilePath = srcPath + itemName;
@@ -394,7 +393,10 @@ void CApp::Link()
   if (dlg.Create(srcPanel.GetParent()) != IDOK)
     return;
 
-  // fix it: we should refresh panel with changed link
+  // we refresh srcPanel to show changes in "Link" (kpidNtReparse) column.
+  // maybe we should refresh another panel also?
+  if (srcPanel._visibleColumns.FindItem_for_PropID(kpidNtReparse) >= 0)
+    srcPanel.RefreshListCtrl(srcSelState);
 
   RefreshTitleAlways();
 }
diff --git a/CPP/7zip/UI/FileManager/MemDialog.cpp b/CPP/7zip/UI/FileManager/MemDialog.cpp
index 1ba717e..5d26d3a 100644
--- a/CPP/7zip/UI/FileManager/MemDialog.cpp
+++ b/CPP/7zip/UI/FileManager/MemDialog.cpp
@@ -55,13 +55,13 @@ static void AddSize_GB(UString &s, UInt32 size_GB, UInt32 id)
   AddLangString(s, id);
 }
 
-void CMemDialog::AddInfoMessage_To_String(UString &s, UInt64 *ramSize_GB)
+void CMemDialog::AddInfoMessage_To_String(UString &s, const UInt32 *ramSize_GB)
 {
   AddLangString(s, IDS_MEM_REQUIRES_BIG_MEM);
   AddSize_GB(s, Required_GB, IDS_MEM_REQUIRED_MEM_SIZE);
   AddSize_GB(s, Limit_GB, IDS_MEM_CURRENT_MEM_LIMIT);
   if (ramSize_GB)
-    AddSize_GB(s, (UInt32)*ramSize_GB, IDS_MEM_RAM_SIZE);
+    AddSize_GB(s, *ramSize_GB, IDS_MEM_RAM_SIZE);
   if (!FilePath.IsEmpty())
   {
     s.Add_LF();
@@ -88,11 +88,11 @@ bool CMemDialog::OnInit()
 
   // m_Action.Attach(GetItem(IDC_MEM_ACTION));
 
-  UInt64 ramSize = (UInt64)sizeof(size_t) << 29;
+  size_t ramSize = (size_t)sizeof(size_t) << 29;
   const bool ramSize_defined = NWindows::NSystem::GetRamSize(ramSize);
   // ramSize *= 10; // for debug
 
-  UInt64 ramSize_GB = (ramSize + (1u << 29)) >> 30;
+  UInt32 ramSize_GB = (UInt32)(((UInt64)ramSize + (1u << 29)) >> 30);
   if (ramSize_GB == 0)
     ramSize_GB = 1;
 
@@ -121,7 +121,7 @@ bool CMemDialog::OnInit()
     if (ramSize_defined)
     {
       s += " / ";
-      s.Add_UInt64(ramSize_GB);
+      s.Add_UInt32(ramSize_GB);
       s += " GB (RAM)";
     }
     SetItemText(IDT_MEM_GB, s);
diff --git a/CPP/7zip/UI/FileManager/MemDialog.h b/CPP/7zip/UI/FileManager/MemDialog.h
index 79de658..67f6b33 100644
--- a/CPP/7zip/UI/FileManager/MemDialog.h
+++ b/CPP/7zip/UI/FileManager/MemDialog.h
@@ -30,7 +30,7 @@ public:
   UString ArcPath;
   UString FilePath;
 
-  void AddInfoMessage_To_String(UString &s, UInt64 *ramSize_GB = NULL);
+  void AddInfoMessage_To_String(UString &s, const UInt32 *ramSize_GB = NULL);
   
   CMemDialog():
     NeedSave(false),
diff --git a/CPP/7zip/UI/FileManager/MyLoadMenu.cpp b/CPP/7zip/UI/FileManager/MyLoadMenu.cpp
index 51b8648..f190929 100644
--- a/CPP/7zip/UI/FileManager/MyLoadMenu.cpp
+++ b/CPP/7zip/UI/FileManager/MyLoadMenu.cpp
@@ -764,8 +764,12 @@ bool ExecuteFileCommand(unsigned id)
     case IDM_CRC32: g_App.CalculateCrc("CRC32"); break;
     case IDM_CRC64: g_App.CalculateCrc("CRC64"); break;
     case IDM_XXH64: g_App.CalculateCrc("XXH64"); break;
+    case IDM_MD5: g_App.CalculateCrc("MD5"); break;
     case IDM_SHA1: g_App.CalculateCrc("SHA1"); break;
     case IDM_SHA256: g_App.CalculateCrc("SHA256"); break;
+    case IDM_SHA384: g_App.CalculateCrc("SHA384"); break;
+    case IDM_SHA512: g_App.CalculateCrc("SHA512"); break;
+    case IDM_SHA3_256: g_App.CalculateCrc("SHA3-256"); break;
     case IDM_BLAKE2SP: g_App.CalculateCrc("BLAKE2sp"); break;
     
     case IDM_DIFF: g_App.DiffFiles(); break;
@@ -807,8 +811,8 @@ bool OnMenuCommand(HWND hWnd, unsigned id)
   {
     // File
     case IDCLOSE:
-      SendMessage(hWnd, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), (LPARAM)hWnd);
-      g_ExitEventLauncher.Exit(false);
+      // SendMessage(hWnd, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), (LPARAM)hWnd);
+      // g_ExitEventLauncher.Exit(false);
       SendMessage(hWnd, WM_CLOSE, 0, 0);
       break;
     
diff --git a/CPP/7zip/UI/FileManager/OpenCallback.cpp b/CPP/7zip/UI/FileManager/OpenCallback.cpp
index 5b6df50..e3cb2ec 100644
--- a/CPP/7zip/UI/FileManager/OpenCallback.cpp
+++ b/CPP/7zip/UI/FileManager/OpenCallback.cpp
@@ -27,7 +27,7 @@ HRESULT COpenArchiveCallback::Open_SetTotal(const UInt64 *numFiles, const UInt64
     ProgressDialog.Sync.Set_NumFilesTotal(numFiles ? *numFiles : (UInt64)(Int64)-1);
     // if (numFiles)
     {
-      ProgressDialog.Sync.Set_BytesProgressMode(numFiles == NULL);
+      ProgressDialog.Sync.Set_FilesProgressMode(numFiles != NULL);
     }
     if (numBytes)
       ProgressDialog.Sync.Set_NumBytesTotal(*numBytes);
diff --git a/CPP/7zip/UI/FileManager/Panel.cpp b/CPP/7zip/UI/FileManager/Panel.cpp
index f3fb38e..84bd88c 100644
--- a/CPP/7zip/UI/FileManager/Panel.cpp
+++ b/CPP/7zip/UI/FileManager/Panel.cpp
@@ -7,8 +7,8 @@
 #include "../../../Common/IntToString.h"
 #include "../../../Common/StringConvert.h"
 
-#include "../../../Windows/FileName.h"
 #include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileName.h"
 #include "../../../Windows/PropVariant.h"
 #include "../../../Windows/Thread.h"
 
@@ -49,8 +49,9 @@ static DWORD kStyles[4] = { LVS_ICON, LVS_SMALLICON, LVS_LIST, LVS_REPORT };
 
 extern HINSTANCE g_hInstance;
 
-void CPanel::Release()
+void CPanel::ReleasePanel()
 {
+  Disable_Processing_Timer_Notify_StatusBar();
   // It's for unloading COM dll's: don't change it.
   CloseOpenFolders();
   _sevenZipContextMenu.Release();
@@ -893,7 +894,7 @@ void CPanel::SetListViewMode(UInt32 index)
 void CPanel::ChangeFlatMode()
 {
   _flatMode = !_flatMode;
-  if (_parentFolders.Size() > 0)
+  if (!_parentFolders.IsEmpty())
     _flatModeForArc = _flatMode;
   else
     _flatModeForDisk = _flatMode;
@@ -904,7 +905,7 @@ void CPanel::ChangeFlatMode()
 void CPanel::Change_ShowNtfsStrems_Mode()
 {
   _showNtfsStrems_Mode = !_showNtfsStrems_Mode;
-  if (_parentFolders.Size() > 0)
+  if (!_parentFolders.IsEmpty())
     _showNtfsStrems_ModeForArc = _showNtfsStrems_Mode;
   else
     _showNtfsStrems_ModeForDisk = _showNtfsStrems_Mode;
@@ -1006,7 +1007,7 @@ void CPanel::GetFilePaths(const CRecordVector<UInt32> &operatedIndices, UStringV
 
 void CPanel::ExtractArchives()
 {
-  if (_parentFolders.Size() > 0)
+  if (!_parentFolders.IsEmpty())
   {
     _panelCallback->OnCopy(false, false);
     return;
diff --git a/CPP/7zip/UI/FileManager/Panel.h b/CPP/7zip/UI/FileManager/Panel.h
index 1b708f7..9ef0926 100644
--- a/CPP/7zip/UI/FileManager/Panel.h
+++ b/CPP/7zip/UI/FileManager/Panel.h
@@ -162,32 +162,39 @@ struct CTempFileInfo
       NWindows::NFile::NDir::RemoveDir(FolderPath);
     }
   }
-  bool WasChanged(const NWindows::NFile::NFind::CFileInfo &newFileInfo) const
+  bool WasChanged_from_TempFileInfo(const NWindows::NFile::NFind::CFileInfo &newFileInfo) const
   {
     return newFileInfo.Size != FileInfo.Size ||
         CompareFileTime(&newFileInfo.MTime, &FileInfo.MTime) != 0;
   }
 };
 
+
 struct CFolderLink: public CTempFileInfo
 {
-  bool IsVirtual;
+  bool IsVirtual; // == true (if archive was open via IInStream):
+                  //    archive was open from another archive,
+                  //    archive size meets the size conditions derived from g_RAM_Size.
+                  //    VirtFileSystem was used
+                  //    archive was fully extracted to memory.
   bool UsePassword;
   NWindows::NDLL::CLibrary Library;
   CMyComPtr<IFolderFolder> ParentFolder; // can be NULL, if parent is FS folder (in _parentFolders[0])
   UString ParentFolderPath; // including tail slash (doesn't include paths parts of parent in next level)
   UString Password;
-
   UString VirtualPath; // without tail slash
-  CFolderLink(): IsVirtual(false), UsePassword(false) {}
+  CByteBuffer ZoneBuf; // ZoneBuf for virtaul stream (IsVirtual)
 
-  bool WasChanged(const NWindows::NFile::NFind::CFileInfo &newFileInfo) const
+  CFolderLink(): IsVirtual(false), UsePassword(false) {}
+  bool WasChanged_from_FolderLink(const NWindows::NFile::NFind::CFileInfo &newFileInfo) const
   {
-    return IsVirtual || CTempFileInfo::WasChanged(newFileInfo);
+    // we call it, if we have two real files.
+    // if archive was virtual, it means that we have updated that virtual to real file.
+    return IsVirtual || CTempFileInfo::WasChanged_from_TempFileInfo(newFileInfo);
   }
-
 };
 
+
 enum MyMessages
 {
   // we can use WM_USER, since we have defined new window class.
@@ -268,13 +275,14 @@ struct CCopyToOptions
 
   bool NeedRegistryZone;
   NExtract::NZoneIdMode::EEnum ZoneIdMode;
+  CByteBuffer ZoneBuf;
 
   UString folder;
 
   UStringVector hashMethods;
 
   CVirtFileSystem *VirtFileSystemSpec;
-  ISequentialOutStream *VirtFileSystem;
+  // ISequentialOutStream *VirtFileSystem;
   
   CCopyToOptions():
       streamMode(false),
@@ -285,8 +293,8 @@ struct CCopyToOptions
       showErrorMessages(false),
       NeedRegistryZone(true),
       ZoneIdMode(NExtract::NZoneIdMode::kNone),
-      VirtFileSystemSpec(NULL),
-      VirtFileSystem(NULL)
+      VirtFileSystemSpec(NULL)
+      // , VirtFileSystem(NULL)
       {}
 };
   
@@ -310,11 +318,60 @@ struct COpenResult
 
 class CPanel Z7_final: public NWindows::NControl::CWindow2
 {
+  bool _thereAre_ListView_Items;
+  // bool _virtualMode;
+  bool _enableItemChangeNotify;
+  bool _thereAreDeletedItems;
+  bool _markDeletedItems;
+  bool _dontShowMode;
+  bool _needSaveInfo;
+
+public:
+  bool PanelCreated;
+  bool _mySelectMode;
+  bool _showDots;
+  bool _showRealFileIcons;
+  bool _flatMode;
+  bool _flatModeForArc;
+  bool _flatModeForDisk;
+  bool _selectionIsDefined;
+  // bool _showNtfsStrems_Mode;
+  // bool _showNtfsStrems_ModeForDisk;
+  // bool _showNtfsStrems_ModeForArc;
+
+  bool _selectMark;
+  bool _lastFocusedIsList;
+
+  bool _processTimer;
+  bool _processNotify;
+  bool _processStatusBar;
+
+public:
+  bool _ascending;
+  PROPID _sortID;
+  // int _sortIndex;
+  Int32 _isRawSortProp;
+
+  CMyListView _listView;
+  CPanelCallback *_panelCallback;
+
+private:
+
   // CExtToIconMap _extToIconMap;
   UINT _baseID;
   unsigned _comboBoxID;
   UINT _statusBarID;
 
+public:
+  DWORD _exStyle;
+  // CUIntVector _realIndices;
+  int _timestampLevel;
+  UInt32 _listViewMode;
+  int _xSize;
+private:
+  int _startGroupSelect;
+  int _prevFocusedItem;
+
   CAppState *_appState;
 
   virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM lParam, LRESULT &result) Z7_override;
@@ -351,22 +408,7 @@ class CPanel Z7_final: public NWindows::NControl::CWindow2
   bool OnCustomDraw(LPNMLVCUSTOMDRAW lplvcd, LRESULT &result);
 
 
-public:
-  HWND _mainWindow;
-  CPanelCallback *_panelCallback;
-
-  // void SysIconsWereChanged() { _extToIconMap.Clear(); }
-
-  void DeleteItems(bool toRecycleBin);
-  void CreateFolder();
-  void CreateFile();
-  bool CorrectFsPath(const UString &path, UString &result);
-  // bool IsPathForPlugin(const UString &path);
-
-private:
-
   void ChangeWindowSize(int xSize, int ySize);
- 
   HRESULT InitColumns();
   void DeleteColumn(unsigned index);
   void AddColumn(const CPropColumn &prop);
@@ -379,20 +421,13 @@ private:
   void OnInsert();
   // void OnUpWithShift();
   // void OnDownWithShift();
-public:
-  void UpdateSelection();
-  void SelectSpec(bool selectMode);
-  void SelectByType(bool selectMode);
-  void SelectAll(bool selectMode);
-  void InvertSelection();
-private:
-
   // UString GetFileType(UInt32 index);
   LRESULT SetItemText(LVITEMW &item);
-
   // CRecordVector<PROPID> m_ColumnsPropIDs;
 
 public:
+  HWND _mainWindow;
+
   NWindows::NControl::CReBar _headerReBar;
   NWindows::NControl::CToolBar _headerToolBar;
   NWindows::NControl::
@@ -405,42 +440,57 @@ public:
   UStringVector ComboBoxPaths;
   // CMyComboBox _headerComboBox;
   CMyComboBoxEdit _comboBoxEdit;
-  CMyListView _listView;
-  bool _thereAre_ListView_Items;
   NWindows::NControl::CStatusBar _statusBar;
-  bool _lastFocusedIsList;
   // NWindows::NControl::CStatusBar _statusBar2;
 
-  DWORD _exStyle;
-  bool _showDots;
-  bool _showRealFileIcons;
-  // bool _virtualMode;
-  // CUIntVector _realIndices;
-  bool _enableItemChangeNotify;
-  bool _mySelectMode;
+  CBoolVector _selectedStatusVector;
+  CSelectedState _selectedState;
 
-  int _timestampLevel;
+  UString _currentFolderPrefix;
+  
+  CObjectVector<CFolderLink> _parentFolders;
+  NWindows::NDLL::CLibrary _library;
+  
+  CMyComPtr<IFolderFolder> _folder;
+  CBoolVector _isDirVector;
+  CMyComPtr<IFolderCompare> _folderCompare;
+  CMyComPtr<IFolderGetItemName> _folderGetItemName;
+  CMyComPtr<IArchiveGetRawProps> _folderRawProps;
+  CMyComPtr<IFolderAltStreams> _folderAltStreams;
+  CMyComPtr<IFolderOperations> _folderOperations;
 
+  // for drag and drop highliting
+  int m_DropHighlighted_SelectionIndex;
+  // int m_SubFolderIndex;      // realIndex of item in m_Panel list (if drop cursor to that item)
+  UString m_DropHighlighted_SubFolderName;   // name of folder in m_Panel list (if drop cursor to that folder)
+
+  // CMyComPtr<IFolderGetSystemIconIndex> _folderGetSystemIconIndex;
+  UStringVector _fastFolders;
+
+  UString _typeIDString;
+  CListViewInfo _listViewInfo;
+  
+  CPropColumns _columns;
+  CPropColumns _visibleColumns;
+  
+  CMyComPtr<IContextMenu> _sevenZipContextMenu;
+  CMyComPtr<IContextMenu> _systemContextMenu;
+  
+  void UpdateSelection();
+  void SelectSpec(bool selectMode);
+  void SelectByType(bool selectMode);
+  void SelectAll(bool selectMode);
+  void InvertSelection();
 
   void RedrawListItems()
   {
     _listView.RedrawAllItems();
   }
-
-
-  CBoolVector _selectedStatusVector;
-
-  CSelectedState _selectedState;
-  bool _thereAreDeletedItems;
-  bool _markDeletedItems;
-
-  bool PanelCreated;
-
   void DeleteListItems()
   {
     if (_thereAre_ListView_Items)
     {
-      bool b = _enableItemChangeNotify;
+      const bool b = _enableItemChangeNotify;
       _enableItemChangeNotify = false;
       _listView.DeleteAllItems();
       _thereAre_ListView_Items = false;
@@ -448,6 +498,15 @@ public:
     }
   }
 
+  // void SysIconsWereChanged() { _extToIconMap.Clear(); }
+
+  void DeleteItems(bool toRecycleBin);
+  void CreateFolder();
+  void CreateFile();
+  bool CorrectFsPath(const UString &path, UString &result);
+  // bool IsPathForPlugin(const UString &path);
+
+
   HWND GetParent() const;
 
   UInt32 GetRealIndex(const LVITEMW &item) const
@@ -471,46 +530,8 @@ public:
     return (unsigned)param;
   }
 
-  UInt32 _listViewMode;
-  int _xSize;
-
-  bool _flatMode;
-  bool _flatModeForDisk;
-  bool _flatModeForArc;
-
-  // bool _showNtfsStrems_Mode;
-  // bool _showNtfsStrems_ModeForDisk;
-  // bool _showNtfsStrems_ModeForArc;
-
-  bool _dontShowMode;
-
-
-  UString _currentFolderPrefix;
-  
-  CObjectVector<CFolderLink> _parentFolders;
-  NWindows::NDLL::CLibrary _library;
-  
-  CMyComPtr<IFolderFolder> _folder;
-  CBoolVector _isDirVector;
-  CMyComPtr<IFolderCompare> _folderCompare;
-  CMyComPtr<IFolderGetItemName> _folderGetItemName;
-  CMyComPtr<IArchiveGetRawProps> _folderRawProps;
-  CMyComPtr<IFolderAltStreams> _folderAltStreams;
-  CMyComPtr<IFolderOperations> _folderOperations;
-
-
-  // for drag and drop highliting
-  int m_DropHighlighted_SelectionIndex;
-  // int m_SubFolderIndex;      // realIndex of item in m_Panel list (if drop cursor to that item)
-  UString m_DropHighlighted_SubFolderName;   // name of folder in m_Panel list (if drop cursor to that folder)
-
   void ReleaseFolder();
   void SetNewFolder(IFolderFolder *newFolder);
-
-  // CMyComPtr<IFolderGetSystemIconIndex> _folderGetSystemIconIndex;
-
-  UStringVector _fastFolders;
-
   void GetSelectedNames(UStringVector &selectedNames);
   void SaveSelectedState(CSelectedState &s);
   HRESULT RefreshListCtrl(const CSelectedState &s);
@@ -575,61 +596,44 @@ public:
 
   CPanel() :
       _thereAre_ListView_Items(false),
-      _exStyle(0),
-      _showDots(false),
-      _showRealFileIcons(false),
-      // _virtualMode(flase),
+      // _virtualMode(false),
       _enableItemChangeNotify(true),
-      _mySelectMode(false),
-      _timestampLevel(kTimestampPrintLevel_MIN),
-
       _thereAreDeletedItems(false),
       _markDeletedItems(true),
-      PanelCreated(false),
-
-      _listViewMode(3),
-      _xSize(300),
+      _dontShowMode(false),
+      _needSaveInfo(false),
 
+      PanelCreated(false),
+      _mySelectMode(false),
+      _showDots(false),
+      _showRealFileIcons(false),
       _flatMode(false),
-      _flatModeForDisk(false),
       _flatModeForArc(false),
-
+      _flatModeForDisk(false),
+      _selectionIsDefined(false),
       // _showNtfsStrems_Mode(false),
       // _showNtfsStrems_ModeForDisk(false),
       // _showNtfsStrems_ModeForArc(false),
 
-      _dontShowMode(false),
-
-      m_DropHighlighted_SelectionIndex(-1),
-
-      _needSaveInfo(false),
+      _exStyle(0),
+      _timestampLevel(kTimestampPrintLevel_MIN),
+      _listViewMode(3),
+      _xSize(300),
       _startGroupSelect(0),
-      _selectionIsDefined(false)
+      m_DropHighlighted_SelectionIndex(-1)
   {}
 
+  ~CPanel() Z7_DESTRUCTOR_override;
+
+  void ReleasePanel();
+
   void SetExtendedStyle()
   {
     if (_listView)
       _listView.SetExtendedListViewStyle(_exStyle);
   }
 
-
-  bool _needSaveInfo;
-  UString _typeIDString;
-  CListViewInfo _listViewInfo;
-  
-  CPropColumns _columns;
-  CPropColumns _visibleColumns;
-  
-  PROPID _sortID;
-  // int _sortIndex;
-  bool _ascending;
-  Int32 _isRawSortProp;
-
   void SetSortRawStatus();
-
-  void Release();
-  ~CPanel() Z7_DESTRUCTOR_override;
   void OnLeftClick(MY_NMLISTVIEW_NMITEMACTIVATE *itemActivate);
   bool OnRightClick(MY_NMLISTVIEW_NMITEMACTIVATE *itemActivate, LRESULT &result);
   void ShowColumnsContextMenu(int x, int y);
@@ -638,9 +642,6 @@ public:
   void OnReload(bool onTimer = false);
   bool OnContextMenu(HANDLE windowHandle, int xPos, int yPos);
 
-  CMyComPtr<IContextMenu> _sevenZipContextMenu;
-  CMyComPtr<IContextMenu> _systemContextMenu;
-  
   HRESULT CreateShellContextMenu(
       const CRecordVector<UInt32> &operatedIndices,
       CMyComPtr<IContextMenu> &systemContextMenu);
@@ -672,12 +673,6 @@ public:
   void EditCopy();
   void EditPaste();
 
-  int _startGroupSelect;
-
-  bool _selectionIsDefined;
-  bool _selectMark;
-  int _prevFocusedItem;
-
  
   // void SortItems(int index);
   void SortItemsWithPropID(PROPID propID);
@@ -716,8 +711,8 @@ public:
   }
 
   // bool IsFsOrDrivesFolder() const { return IsFSFolder() || IsFSDrivesFolder(); }
-  bool IsDeviceDrivesPrefix() const { return _currentFolderPrefix == L"\\\\.\\"; }
-  bool IsSuperDrivesPrefix() const { return _currentFolderPrefix == L"\\\\?\\"; }
+  bool IsDeviceDrivesPrefix() const { return _currentFolderPrefix.IsEqualTo("\\\\.\\"); }
+  bool IsSuperDrivesPrefix() const { return _currentFolderPrefix.IsEqualTo("\\\\?\\"); }
   
   /*
     c:\Dir
@@ -751,9 +746,12 @@ public:
   bool IsThereReadOnlyFolder() const;
   bool CheckBeforeUpdate(UINT resourceID);
 
-  bool _processTimer;
-  bool _processNotify;
-  bool _processStatusBar;
+  void Disable_Processing_Timer_Notify_StatusBar()
+  {
+    _processTimer = false;
+    _processNotify = false;
+    _processStatusBar = false;
+  }
 
   class CDisableTimerProcessing
   {
@@ -926,6 +924,7 @@ public:
   void ExtractArchives();
   void TestArchives();
 
+  void Get_ZoneId_Stream_from_ParentFolders(CByteBuffer &buf);
 
   HRESULT CopyTo(CCopyToOptions &options,
       const CRecordVector<UInt32> &indices,
@@ -939,7 +938,7 @@ public:
   {
     bool usePassword = false;
     UString password;
-    if (_parentFolders.Size() > 0)
+    if (!_parentFolders.IsEmpty())
     {
       const CFolderLink &fl = _parentFolders.Back();
       usePassword = fl.UsePassword;
@@ -978,6 +977,7 @@ public:
   UString GetItemsInfoString(const CRecordVector<UInt32> &indices);
 };
 
+
 class CMyBuffer
 {
   void *_data;
@@ -994,13 +994,12 @@ public:
   ~CMyBuffer() { ::MidFree(_data); }
 };
 
-class CExitEventLauncher
+struct CExitEventLauncher
 {
-public:
   NWindows::NSynchronization::CManualResetEvent _exitEvent;
   bool _needExit;
-  CRecordVector< ::CThread > _threads;
   unsigned _numActiveThreads;
+  CRecordVector< ::CThread > _threads;
     
   CExitEventLauncher()
   {
diff --git a/CPP/7zip/UI/FileManager/PanelCopy.cpp b/CPP/7zip/UI/FileManager/PanelCopy.cpp
index 36a0f6d..f070be9 100644
--- a/CPP/7zip/UI/FileManager/PanelCopy.cpp
+++ b/CPP/7zip/UI/FileManager/PanelCopy.cpp
@@ -75,11 +75,21 @@ HRESULT CPanelCopyThread::ProcessVirt()
 
   if (FolderOperations)
   {
-    CMyComPtr<IFolderSetZoneIdMode> setZoneMode;
-    FolderOperations.QueryInterface(IID_IFolderSetZoneIdMode, &setZoneMode);
-    if (setZoneMode)
     {
-      RINOK(setZoneMode->SetZoneIdMode(options->ZoneIdMode))
+      CMyComPtr<IFolderSetZoneIdMode> setZoneMode;
+      FolderOperations.QueryInterface(IID_IFolderSetZoneIdMode, &setZoneMode);
+      if (setZoneMode)
+      {
+        RINOK(setZoneMode->SetZoneIdMode(options->ZoneIdMode))
+      }
+    }
+    {
+      CMyComPtr<IFolderSetZoneIdFile> setZoneFile;
+      FolderOperations.QueryInterface(IID_IFolderSetZoneIdFile, &setZoneFile);
+      if (setZoneFile)
+      {
+        RINOK(setZoneFile->SetZoneIdFile(options->ZoneBuf, (UInt32)options->ZoneBuf.Size()))
+      }
     }
   }
 
@@ -143,6 +153,32 @@ static void ThrowException_if_Error(HRESULT res)
 #endif
 */
 
+void CPanel::Get_ZoneId_Stream_from_ParentFolders(CByteBuffer &buf)
+{
+  // we suppose that ZoneId of top parent has priority over ZoneId from childs.
+  FOR_VECTOR (i, _parentFolders)
+  {
+    // _parentFolders[0] = is top level archive
+    // _parentFolders[1 ... ].isVirtual == true is possible
+    //           if extracted size meets size conditions derived from g_RAM_Size.
+    const CFolderLink &fl = _parentFolders[i];
+    if (fl.IsVirtual)
+    {
+      if (fl.ZoneBuf.Size() != 0)
+      {
+        buf = fl.ZoneBuf;
+        return;
+      }
+    }
+    else if (!fl.FilePath.IsEmpty())
+    {
+      ReadZoneFile_Of_BaseFile(fl.FilePath, buf);
+      if (buf.Size() != 0)
+        return;
+    }
+  }
+}
+
 HRESULT CPanel::CopyTo(CCopyToOptions &options,
     const CRecordVector<UInt32> &indices,
     UStringVector *messages,
@@ -157,6 +193,10 @@ HRESULT CPanel::CopyTo(CCopyToOptions &options,
       options.ZoneIdMode = (NExtract::NZoneIdMode::EEnum)(int)(Int32)ci.WriteZone;
   }
 
+  if (options.ZoneBuf.Size() == 0
+      && options.ZoneIdMode != NExtract::NZoneIdMode::kNone)
+    Get_ZoneId_Stream_from_ParentFolders(options.ZoneBuf);
+
   if (IsHashFolder())
   {
     if (!options.testMode)
@@ -205,9 +245,9 @@ HRESULT CPanel::CopyTo(CCopyToOptions &options,
     extracter.Hash.MainName = extracter.Hash.FirstFileName;
   }
 
-  if (options.VirtFileSystem)
+  if (options.VirtFileSystemSpec)
   {
-    extracter.ExtractCallbackSpec->VirtFileSystem = options.VirtFileSystem;
+    extracter.ExtractCallbackSpec->VirtFileSystem = options.VirtFileSystemSpec;
     extracter.ExtractCallbackSpec->VirtFileSystemSpec = options.VirtFileSystemSpec;
   }
   extracter.ExtractCallbackSpec->ProcessAltStreams = options.includeAltStreams;
@@ -244,7 +284,7 @@ HRESULT CPanel::CopyTo(CCopyToOptions &options,
       if (options.hashMethods.Size() == 1)
       {
         const UString &s = options.hashMethods[0];
-        if (s != L"*")
+        if (!s.IsEqualTo("*"))
           title = s;
       }
     }
diff --git a/CPP/7zip/UI/FileManager/PanelDrag.cpp b/CPP/7zip/UI/FileManager/PanelDrag.cpp
index 040444c..f9b0a6c 100644
--- a/CPP/7zip/UI/FileManager/PanelDrag.cpp
+++ b/CPP/7zip/UI/FileManager/PanelDrag.cpp
@@ -2614,11 +2614,11 @@ Z7_COMWF_B CDropTarget::Drop(IDataObject *dataObject, DWORD keyState,
     UString s = LangString(cmdEffect == DROPEFFECT_MOVE ?
         IDS_MOVE_TO : IDS_COPY_TO);
     s.Add_LF();
-    s += "\'";
+    // s += "\'";
     s += m_Panel->_currentFolderPrefix;
-    s += "\'";
+    // s += "\'";
     s.Add_LF();
-    s += LangString(IDS_WANT_TO_COPY_FILES);
+    AddLangString(s, IDS_WANT_TO_COPY_FILES);
     s += " ?";
     const int res = ::MessageBoxW(*m_Panel, s, title, MB_YESNOCANCEL | MB_ICONQUESTION);
     if (res != IDYES)
@@ -2954,7 +2954,7 @@ static unsigned Drag_OnContextMenu(int xPos, int yPos, UInt32 cmdFlags)
       name = MyFormatNew(name, destPath);
       */
       name.Add_Space();
-      name += LangString(IDS_CONTEXT_ARCHIVE);
+      AddLangString(name, IDS_CONTEXT_ARCHIVE);
     }
     if (cmdId == NDragMenu::k_Cancel)
       menu.AppendItem(MF_SEPARATOR, 0, (LPCTSTR)NULL);
diff --git a/CPP/7zip/UI/FileManager/PanelFolderChange.cpp b/CPP/7zip/UI/FileManager/PanelFolderChange.cpp
index c34cb74..b0fb53e 100644
--- a/CPP/7zip/UI/FileManager/PanelFolderChange.cpp
+++ b/CPP/7zip/UI/FileManager/PanelFolderChange.cpp
@@ -428,7 +428,7 @@ void CPanel::LoadFullPathAndShow()
       UString name_Computer = RootFolder_GetName_Computer(iconIndex);
       name_Computer.Add_PathSepar();
       if (path == name_Computer
-          || path == L"\\\\?\\")
+          || path.IsEqualTo("\\\\?\\"))
         item.iImage = iconIndex;
       else
       {
@@ -639,7 +639,7 @@ bool CPanel::OnComboBoxCommand(UINT code, LPARAM /* param */, LRESULT &result)
       unsigned indent = 0;
       {
         UString path = _currentFolderPrefix;
-        // path = L"\\\\.\\y:\\"; // for debug
+        // path = "\\\\.\\y:\\"; // for debug
         UString prefix0;
         if (path.IsPrefixedBy_Ascii_NoCase("\\\\"))
         {
@@ -702,7 +702,7 @@ bool CPanel::OnComboBoxCommand(UINT code, LPARAM /* param */, LRESULT &result)
       int iconIndex_Computer;
       const UString name_Computer = RootFolder_GetName_Computer(iconIndex_Computer);
 
-      // const bool is_devicePrefix = (sumPath == L"\\\\.\\");
+      // const bool is_devicePrefix = (sumPath.IsEqualTo("\\\\.\\"));
 
       if (pathParts.Size() > 1)
       if (!sumPath.IsEmpty()
@@ -901,8 +901,8 @@ UString CPanel::GetParentDirPrefix() const
     {
       s = _currentFolderPrefix;
       s.DeleteBack();
-      if (s != L"\\\\." &&
-          s != L"\\\\?")
+      if (!s.IsEqualTo("\\\\.") &&
+          !s.IsEqualTo("\\\\?"))
       {
         int pos = s.ReverseFind_PathSepar();
         if (pos >= 0)
@@ -935,8 +935,8 @@ void CPanel::OpenParentFolder()
       }
       else
       */
-      if (focusedName != L"\\\\." &&
-          focusedName != L"\\\\?")
+      if (!focusedName.IsEqualTo("\\\\.") &&
+          !focusedName.IsEqualTo("\\\\?"))
       {
         const int pos = focusedName.ReverseFind_PathSepar();
         if (pos >= 0)
diff --git a/CPP/7zip/UI/FileManager/PanelItemOpen.cpp b/CPP/7zip/UI/FileManager/PanelItemOpen.cpp
index 244a962..aa56ef5 100644
--- a/CPP/7zip/UI/FileManager/PanelItemOpen.cpp
+++ b/CPP/7zip/UI/FileManager/PanelItemOpen.cpp
@@ -39,7 +39,7 @@ using namespace NFile;
 using namespace NDir;
 
 extern bool g_RAM_Size_Defined;
-extern UInt64 g_RAM_Size;
+extern size_t g_RAM_Size;
 
 #ifndef _UNICODE
 extern bool g_IsNT;
@@ -606,9 +606,9 @@ HRESULT CPanel::OpenParentArchiveFolder()
   NFind::CFileInfo newFileInfo;
   if (newFileInfo.Find(folderLink.FilePath))
   {
-    if (folderLink.WasChanged(newFileInfo))
+    if (folderLink.WasChanged_from_FolderLink(newFileInfo))
     {
-      UString message = MyFormatNew(IDS_WANT_UPDATE_MODIFIED_FILE, folderLink.RelPath);
+      const UString message = MyFormatNew(IDS_WANT_UPDATE_MODIFIED_FILE, folderLink.RelPath);
       if (::MessageBoxW((HWND)*this, message, L"7-Zip", MB_YESNOCANCEL | MB_ICONQUESTION) == IDYES)
       {
         if (OnOpenItemChanged(folderLink.FileIndex, fs2us(folderLink.FilePath),
@@ -1083,13 +1083,11 @@ void CExitEventLauncher::Exit(bool hardExit)
   FOR_VECTOR (i, _threads)
   {
     ::CThread &th = _threads[i];
-    DWORD wait = (hardExit ? 100 : INFINITE);
     if (Thread_WasCreated(&th))
     {
-      DWORD waitResult = WaitForSingleObject(th, wait);
+      const DWORD waitResult = WaitForSingleObject(th, hardExit ? 100 : INFINITE);
       // Thread_Wait(&th);
-      if (waitResult == WAIT_TIMEOUT)
-        wait = 1;
+      // if (waitResult == WAIT_TIMEOUT) wait = 1;
       if (!hardExit && waitResult != WAIT_OBJECT_0)
         continue;
       Thread_Close(&th);
@@ -1107,7 +1105,7 @@ static THREAD_FUNC_DECL MyThreadFunction(void *param)
   CMyUniquePtr<CTmpProcessInfo> tpi((CTmpProcessInfo *)param);
   CChildProcesses &processes = tpi->Processes;
 
-  bool mainProcessWasSet = !processes.Handles.IsEmpty();
+  const bool mainProcessWasSet = !processes.Handles.IsEmpty();
 
   bool isComplexMode = true;
 
@@ -1195,7 +1193,7 @@ static THREAD_FUNC_DECL MyThreadFunction(void *param)
         {
           NFind::CFileInfo newFileInfo;
           if (newFileInfo.Find(tpi->FilePath))
-            if (tpi->WasChanged(newFileInfo))
+            if (tpi->WasChanged_from_TempFileInfo(newFileInfo))
               needFindProcessByPath = false;
         }
         
@@ -1235,7 +1233,7 @@ static THREAD_FUNC_DECL MyThreadFunction(void *param)
 
     if (mainProcessWasSet)
     {
-      if (tpi->WasChanged(newFileInfo))
+      if (tpi->WasChanged_from_TempFileInfo(newFileInfo))
       {
         UString m = MyFormatNew(IDS_CANNOT_UPDATE_FILE, fs2us(tpi->FilePath));
         if (tpi->ReadOnly)
@@ -1279,10 +1277,10 @@ static THREAD_FUNC_DECL MyThreadFunction(void *param)
 
   {
     NFind::CFileInfo newFileInfo;
-    
-    bool finded = newFileInfo.Find(tpi->FilePath);
-
-    if (!needCheckTimestamp || !finded || !tpi->WasChanged(newFileInfo))
+    const bool finded = newFileInfo.Find(tpi->FilePath);
+    if (!needCheckTimestamp
+        || !finded
+        || !tpi->WasChanged_from_TempFileInfo(newFileInfo))
     {
       DEBUG_PRINT("Delete Temp file");
       tpi->DeleteDirAndFile();
@@ -1534,7 +1532,7 @@ void CPanel::OpenItemInArchive(unsigned index, bool tryInternal, bool tryExterna
 
   bool usePassword = false;
   UString password;
-  if (_parentFolders.Size() > 0)
+  if (!_parentFolders.IsEmpty())
   {
     const CFolderLink &fl = _parentFolders.Back();
     usePassword = fl.UsePassword;
@@ -1547,7 +1545,7 @@ void CPanel::OpenItemInArchive(unsigned index, bool tryInternal, bool tryExterna
   #ifndef _UNICODE
   if (g_IsNT)
   #endif
-  if (_parentFolders.Size() > 0)
+  if (!_parentFolders.IsEmpty())
   {
     const CFolderLink &fl = _parentFolders.Front();
     if (!fl.IsVirtual && !fl.FilePath.IsEmpty())
@@ -1576,39 +1574,42 @@ void CPanel::OpenItemInArchive(unsigned index, bool tryInternal, bool tryExterna
   
   if (tryAsArchive)
   {
+    // actually we want to get sum: size of main file plus sizes of altStreams.
+    // but now there is no interface to get altStreams sizes.
     NCOM::CPropVariant prop;
     _folder->GetProperty(index, kpidSize, &prop);
-    UInt64 fileLimit = 1 << 22;
-    if (g_RAM_Size_Defined)
-      fileLimit = g_RAM_Size / 4;
-
+    const size_t fileLimit = g_RAM_Size_Defined ?
+        g_RAM_Size >> MyMax(_parentFolders.Size() + 1, 8u):
+        1u << 22;
     UInt64 fileSize = 0;
     if (!ConvertPropVariantToUInt64(prop, fileSize))
       fileSize = fileLimit;
-    if (fileSize <= fileLimit && fileSize > 0)
+#if 0  // 1 : for debug
+    fileLimit = 1;
+#endif
+
+    if (fileSize <= fileLimit)
     {
       options.streamMode = true;
       virtFileSystemSpec = new CVirtFileSystem;
       virtFileSystem = virtFileSystemSpec;
+      virtFileSystemSpec->FileName = name;
+      virtFileSystemSpec->IsAltStreamFile = isAltStream;
 
 #if defined(_WIN32) && !defined(UNDER_CE)
 #ifndef _UNICODE
       if (g_IsNT)
 #endif
-      if (_parentFolders.Size() > 0)
       {
-        const CFolderLink &fl = _parentFolders.Front();
-        if (!fl.IsVirtual && !fl.FilePath.IsEmpty())
-          ReadZoneFile_Of_BaseFile(fl.FilePath, virtFileSystemSpec->ZoneBuf);
+        Get_ZoneId_Stream_from_ParentFolders(virtFileSystemSpec->ZoneBuf);
+        options.ZoneBuf = virtFileSystemSpec->ZoneBuf;
       }
 #endif
 
-      // we allow additional total size for small alt streams;
-      virtFileSystemSpec->MaxTotalAllocSize = fileSize + (1 << 10);
-      
+      virtFileSystemSpec->MaxTotalAllocSize = (size_t)fileSize
+            + (1 << 16); // we allow additional total size for small alt streams.
       virtFileSystemSpec->DirPrefix = tempDirNorm;
-      virtFileSystemSpec->Init();
-      options.VirtFileSystem = virtFileSystem;
+      // options.VirtFileSystem = virtFileSystem;
       options.VirtFileSystemSpec = virtFileSystemSpec;
     }
   }
@@ -1618,7 +1619,7 @@ void CPanel::OpenItemInArchive(unsigned index, bool tryInternal, bool tryExterna
 
   const HRESULT result = CopyTo(options, indices, &messages, usePassword, password);
 
-  if (_parentFolders.Size() > 0)
+  if (!_parentFolders.IsEmpty())
   {
     CFolderLink &fl = _parentFolders.Back();
     fl.UsePassword = usePassword;
@@ -1634,34 +1635,46 @@ void CPanel::OpenItemInArchive(unsigned index, bool tryInternal, bool tryExterna
     return;
   }
 
-  if (options.VirtFileSystem)
+  if (virtFileSystemSpec && !virtFileSystemSpec->WasStreamFlushedToFS())
   {
-    if (virtFileSystemSpec->IsStreamInMem())
+    int index_in_Files = virtFileSystemSpec->Index_of_MainExtractedFile_in_Files;
+    if (index_in_Files < 0)
     {
-      const CVirtFile &file = virtFileSystemSpec->Files[0];
-
-      size_t streamSize = (size_t)file.Size;
-      CBufInStream *bufInStreamSpec = new CBufInStream;
-      CMyComPtr<IInStream> bufInStream = bufInStreamSpec;
-      bufInStreamSpec->Init(file.Data, streamSize, virtFileSystem);
-
-      HRESULT res = OpenAsArc_Msg(bufInStream, tempFileInfo, fullVirtPath, type ? type : L""
+      if (virtFileSystemSpec->Files.Size() != 1)
+      {
+        MessageBox_Error_HRESULT(E_FAIL);
+        return;
+      }
+      // it's not expected case that index was not set, but we support that case
+      index_in_Files = 0;
+    }
+    {
+      const CVirtFile &file = virtFileSystemSpec->Files[index_in_Files];
+      CMyComPtr2_Create<IInStream, CBufInStream> bufInStream;
+      bufInStream->Init(file.Data, file.WrittenSize, virtFileSystem);
+      const HRESULT res = OpenAsArc_Msg(bufInStream, tempFileInfo,
+          fullVirtPath, type ? type : L""
           // , encrypted
           // , true // showErrorMessage
           );
-
       if (res == S_OK)
       {
+        if (virtFileSystemSpec->Index_of_ZoneBuf_AltStream_in_Files >= 0
+            && !_parentFolders.IsEmpty())
+        {
+          const CVirtFile &fileZone = virtFileSystemSpec->Files[
+              virtFileSystemSpec->Index_of_ZoneBuf_AltStream_in_Files];
+          _parentFolders.Back().ZoneBuf.CopyFrom(fileZone.Data, fileZone.WrittenSize);
+        }
+
         tempDirectory.DisableDeleting();
         RefreshListCtrl();
         return;
       }
-
       if (res == E_ABORT || res != S_FALSE)
         return;
       if (!tryExternal)
         return;
-      
       tryAsArchive = false;
       if (virtFileSystemSpec->FlushToDisk(true) != S_OK)
         return;
@@ -1684,7 +1697,7 @@ void CPanel::OpenItemInArchive(unsigned index, bool tryInternal, bool tryExterna
 
   if (tryAsArchive)
   {
-    HRESULT res = OpenAsArc_Msg(NULL, tempFileInfo, fullVirtPath, type ? type : L""
+    const HRESULT res = OpenAsArc_Msg(NULL, tempFileInfo, fullVirtPath, type ? type : L""
         // , encrypted
         // , true // showErrorMessage
         );
@@ -1732,7 +1745,7 @@ void CPanel::OpenItemInArchive(unsigned index, bool tryInternal, bool tryExterna
       return;
   }
 
-  tpi->Window = (HWND)(*this);
+  tpi->Window = (HWND)*this;
   tpi->FullPathFolderPrefix = _currentFolderPrefix;
   tpi->FileIndex = index;
   tpi->RelPath = relPath;
diff --git a/CPP/7zip/UI/FileManager/PanelItems.cpp b/CPP/7zip/UI/FileManager/PanelItems.cpp
index 544e9bf..868ad22 100644
--- a/CPP/7zip/UI/FileManager/PanelItems.cpp
+++ b/CPP/7zip/UI/FileManager/PanelItems.cpp
@@ -1438,13 +1438,16 @@ void CPanel::OnTimer()
     return;
   if (!AutoRefresh_Mode)
     return;
-  CMyComPtr<IFolderWasChanged> folderWasChanged;
-  if (_folder.QueryInterface(IID_IFolderWasChanged, &folderWasChanged) != S_OK)
-    return;
-  Int32 wasChanged;
-  if (folderWasChanged->WasChanged(&wasChanged) != S_OK)
-    return;
-  if (wasChanged == 0)
+  if (!_folder) // it's unexpected case, but we use it as additional protection.
     return;
+  {
+    CMyComPtr<IFolderWasChanged> folderWasChanged;
+    _folder.QueryInterface(IID_IFolderWasChanged, &folderWasChanged);
+    if (!folderWasChanged)
+      return;
+    Int32 wasChanged;
+    if (folderWasChanged->WasChanged(&wasChanged) != S_OK || wasChanged == 0)
+      return;
+  }
   OnReload(true); // onTimer
 }
diff --git a/CPP/7zip/UI/FileManager/PanelListNotify.cpp b/CPP/7zip/UI/FileManager/PanelListNotify.cpp
index 4dbd9f6..05ab36b 100644
--- a/CPP/7zip/UI/FileManager/PanelListNotify.cpp
+++ b/CPP/7zip/UI/FileManager/PanelListNotify.cpp
@@ -785,7 +785,7 @@ void CPanel::Refresh_StatusBar()
     wchar_t selectSizeString[32];
     selectSizeString[0] = 0;
     
-    if (indices.Size() > 0)
+    if (!indices.IsEmpty())
     {
       // for (unsigned ttt = 0; ttt < 1000; ttt++) {
       UInt64 totalSize = 0;
diff --git a/CPP/7zip/UI/FileManager/PanelOperations.cpp b/CPP/7zip/UI/FileManager/PanelOperations.cpp
index af313ff..427464b 100644
--- a/CPP/7zip/UI/FileManager/PanelOperations.cpp
+++ b/CPP/7zip/UI/FileManager/PanelOperations.cpp
@@ -80,7 +80,7 @@ HRESULT CThreadFolderOperations::DoOperation(CPanel &panel, const UString &progr
 
   UpdateCallbackSpec->Init();
 
-  if (panel._parentFolders.Size() > 0)
+  if (!panel._parentFolders.IsEmpty())
   {
     const CFolderLink &fl = panel._parentFolders.Back();
     UpdateCallbackSpec->PasswordIsDefined = fl.UsePassword;
@@ -275,8 +275,8 @@ static bool IsCorrectFsName(const UString &name)
 {
   const UString lastPart = name.Ptr((unsigned)(name.ReverseFind_PathSepar() + 1));
   return
-      lastPart != L"." &&
-      lastPart != L"..";
+      !lastPart.IsEqualTo(".") &&
+      !lastPart.IsEqualTo("..");
 }
 
 bool CorrectFsPath(const UString &relBase, const UString &path, UString &result);
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog2.cpp b/CPP/7zip/UI/FileManager/ProgressDialog2.cpp
index 690ebec..a070a0a 100644
--- a/CPP/7zip/UI/FileManager/ProgressDialog2.cpp
+++ b/CPP/7zip/UI/FileManager/ProgressDialog2.cpp
@@ -78,8 +78,9 @@ static const UInt32 kLangIDs_Colon[] =
 #define IS_DEFINED_VAL(v)     ((v) != UNDEFINED_VAL)
 
 CProgressSync::CProgressSync():
-    _stopped(false), _paused(false),
-    _bytesProgressMode(true),
+    _stopped(false),
+    _paused(false),
+    _filesProgressMode(false),
     _isDir(false),
     _totalBytes(UNDEFINED_VAL), _completedBytes(0),
     _totalFiles(UNDEFINED_VAL), _curFiles(0),
@@ -108,6 +109,13 @@ HRESULT CProgressSync::CheckStop()
   }
 }
 
+void CProgressSync::Clear_Stop_Status()
+{
+  CRITICAL_LOCK
+  if (_stopped)
+    _stopped = false;
+}
+
 HRESULT CProgressSync::ScanProgress(UInt64 numFiles, UInt64 totalSize, const FString &fileName, bool isDir)
 {
   {
@@ -242,27 +250,27 @@ void CProgressSync::AddError_Code_Name(HRESULT systemError, const wchar_t *name)
 }
 
 CProgressDialog::CProgressDialog():
-   _timer(0),
-   CompressingMode(true),
-   MainWindow(NULL)
+    _isDir(false),
+    _wasCreated(false),
+    _needClose(false),
+    _errorsWereDisplayed(false),
+    _waitCloseByCancelButton(false),
+    _cancelWasPressed(false),
+    _inCancelMessageBox(false),
+    _externalCloseMessageWasReceived(false),
+    _background(false),
+    WaitMode(false),
+    MessagesDisplayed(false),
+    CompressingMode(true),
+    ShowCompressionInfo(true),
+    _numPostedMessages(0),
+    _numAutoSizeMessages(0),
+    _numMessages(0),
+    _timer(0),
+    IconID(-1),
+    MainWindow(NULL)
 {
-  _isDir = false;
-
-  _numMessages = 0;
-  IconID = -1;
-  MessagesDisplayed = false;
-  _wasCreated = false;
-  _needClose = false;
-  _inCancelMessageBox = false;
-  _externalCloseMessageWasReceived = false;
-  
-  _numPostedMessages = 0;
-  _numAutoSizeMessages = 0;
-  _errorsWereDisplayed = false;
-  _waitCloseByCancelButton = false;
-  _cancelWasPressed = false;
-  ShowCompressionInfo = true;
-  WaitMode = false;
+
   if (_dialogCreatedEvent.Create() != S_OK)
     throw 1334987;
   if (_createDialogEvent.Create() != S_OK)
@@ -357,8 +365,6 @@ bool CProgressDialog::OnInit()
   _filesStr_Prev.Empty();
   _filesTotStr_Prev.Empty();
 
-  _foreground = true;
-
   m_ProgressBar.Attach(GetItem(IDC_PROGRESS1));
   _messageList.Attach(GetItem(IDL_PROGRESS_MESSAGES));
   _messageList.SetUnicodeFormat();
@@ -388,9 +394,8 @@ bool CProgressDialog::OnInit()
   SetPauseText();
   SetPriorityText();
 
-  _messageList.InsertColumn(0, L"", 30);
-  _messageList.InsertColumn(1, L"", 600);
-
+  _messageList.InsertColumn(0, L"", 40);
+  _messageList.InsertColumn(1, L"", 460);
   _messageList.SetColumnWidthAuto(0);
   _messageList.SetColumnWidthAuto(1);
 
@@ -690,7 +695,7 @@ static UInt64 MyMultAndDiv(UInt64 mult1, UInt64 mult2, UInt64 divider)
 void CProgressDialog::UpdateStatInfo(bool showAll)
 {
   UInt64 total, completed, totalFiles, completedFiles, inSize, outSize;
-  bool bytesProgressMode;
+  bool filesProgressMode;
 
   bool titleFileName_Changed;
   bool curFilePath_Changed;
@@ -704,7 +709,7 @@ void CProgressDialog::UpdateStatInfo(bool showAll)
     completedFiles = Sync._curFiles;
     inSize = Sync._inSize;
     outSize = Sync._outSize;
-    bytesProgressMode = Sync._bytesProgressMode;
+    filesProgressMode = Sync._filesProgressMode;
 
     GetChangedString(Sync._titleFileName, _titleFileName, titleFileName_Changed);
     GetChangedString(Sync._filePath, _filePath, curFilePath_Changed);
@@ -719,8 +724,8 @@ void CProgressDialog::UpdateStatInfo(bool showAll)
 
   UInt32 curTime = ::GetTickCount();
 
-  const UInt64 progressTotal = bytesProgressMode ? total : totalFiles;
-  const UInt64 progressCompleted = bytesProgressMode ? completed : completedFiles;
+  const UInt64 progressTotal = filesProgressMode ? totalFiles : total;
+  const UInt64 progressCompleted = filesProgressMode ? completedFiles : completed;
   {
     if (IS_UNDEFINED_VAL(progressTotal))
     {
@@ -900,7 +905,7 @@ void CProgressDialog::UpdateStatInfo(bool showAll)
   {
     UString s = _status;
     ReduceString(s, _numReduceSymbols);
-    SetItemText(IDT_PROGRESS_STATUS, _status);
+    SetItemText(IDT_PROGRESS_STATUS, s);
   }
 
   if (curFilePath_Changed)
@@ -1086,12 +1091,10 @@ void CProgressDialog::SetTitleText()
   }
   if (IS_DEFINED_VAL(_prevPercentValue))
   {
-    char temp[32];
-    ConvertUInt64ToString(_prevPercentValue, temp);
-    s += temp;
+    s.Add_UInt64(_prevPercentValue);
     s.Add_Char('%');
   }
-  if (!_foreground)
+  if (_background)
   {
     s.Add_Space();
     s += _backgrounded_String;
@@ -1138,17 +1141,17 @@ void CProgressDialog::OnPauseButton()
 
 void CProgressDialog::SetPriorityText()
 {
-  SetItemText(IDB_PROGRESS_BACKGROUND, _foreground ?
-      _background_String :
-      _foreground_String);
+  SetItemText(IDB_PROGRESS_BACKGROUND, _background ?
+      _foreground_String :
+      _background_String);
   SetTitleText();
 }
 
 void CProgressDialog::OnPriorityButton()
 {
-  _foreground = !_foreground;
+  _background = !_background;
   #ifndef UNDER_CE
-  SetPriorityClass(GetCurrentProcess(), _foreground ? NORMAL_PRIORITY_CLASS: IDLE_PRIORITY_CLASS);
+  SetPriorityClass(GetCurrentProcess(), _background ? IDLE_PRIORITY_CLASS : NORMAL_PRIORITY_CLASS);
   #endif
   SetPriorityText();
 }
@@ -1184,12 +1187,16 @@ void CProgressDialog::AddMessage(LPCWSTR message)
   _numMessages++;
 }
 
-static unsigned GetNumDigits(UInt32 val)
+static unsigned GetNumDigits(unsigned val)
 {
-  unsigned i;
-  for (i = 0; val >= 10; i++)
+  unsigned i = 0;
+  for (;;)
+  {
+    i++;
     val /= 10;
-  return i;
+    if (val == 0)
+      return i;
+  }
 }
 
 void CProgressDialog::UpdateMessagesDialog()
@@ -1197,7 +1204,7 @@ void CProgressDialog::UpdateMessagesDialog()
   UStringVector messages;
   {
     NSynchronization::CCriticalSectionLock lock(Sync._cs);
-    unsigned num = Sync.Messages.Size();
+    const unsigned num = Sync.Messages.Size();
     if (num > _numPostedMessages)
     {
       messages.ClearAndReserve(num - _numPostedMessages);
@@ -1210,7 +1217,11 @@ void CProgressDialog::UpdateMessagesDialog()
   {
     FOR_VECTOR (i, messages)
       AddMessage(messages[i]);
-    if (_numAutoSizeMessages < 256 || GetNumDigits(_numPostedMessages) > GetNumDigits(_numAutoSizeMessages))
+    // SetColumnWidthAuto() can be slow for big number of files.
+    if (_numPostedMessages < 1000000 || _numAutoSizeMessages < 100)
+    if (_numAutoSizeMessages < 100 ||
+        GetNumDigits(_numPostedMessages) >
+        GetNumDigits(_numAutoSizeMessages))
     {
       _messageList.SetColumnWidthAuto(0);
       _messageList.SetColumnWidthAuto(1);
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog2.h b/CPP/7zip/UI/FileManager/ProgressDialog2.h
index 4ca9be7..60a5ca6 100644
--- a/CPP/7zip/UI/FileManager/ProgressDialog2.h
+++ b/CPP/7zip/UI/FileManager/ProgressDialog2.h
@@ -33,9 +33,8 @@ class CProgressSync
 {
   bool _stopped;
   bool _paused;
-
 public:
-  bool _bytesProgressMode;
+  bool _filesProgressMode;
   bool _isDir;
   UInt64 _totalBytes;
   UInt64 _completedBytes;
@@ -73,13 +72,14 @@ public:
     _paused = val;
   }
   
-  void Set_BytesProgressMode(bool bytesProgressMode)
+  void Set_FilesProgressMode(bool filesProgressMode)
   {
     NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
-    _bytesProgressMode = bytesProgressMode;
+    _filesProgressMode = filesProgressMode;
   }
   
   HRESULT CheckStop();
+  void Clear_Stop_Status();
   HRESULT ScanProgress(UInt64 numFiles, UInt64 totalSize, const FString &fileName, bool isDir = false);
 
   HRESULT Set_NumFilesTotal(UInt64 val);
@@ -102,12 +102,32 @@ public:
   bool ThereIsMessage() const { return !Messages.IsEmpty() || FinalMessage.ThereIsMessage(); }
 };
 
+
 class CProgressDialog: public NWindows::NControl::CModalDialog
 {
+  bool _isDir;
+  bool _wasCreated;
+  bool _needClose;
+  bool _errorsWereDisplayed;
+  bool _waitCloseByCancelButton;
+  bool _cancelWasPressed;
+  bool _inCancelMessageBox;
+  bool _externalCloseMessageWasReceived;
+  bool _background;
+public:
+  bool WaitMode;
+  bool MessagesDisplayed; // = true if user pressed OK on all messages or there are no messages.
+  bool CompressingMode;
+  bool ShowCompressionInfo;
+
+private:
+  unsigned _numPostedMessages;
+  unsigned _numAutoSizeMessages;
+  unsigned _numMessages;
+
   UString _titleFileName;
   UString _filePath;
   UString _status;
-  bool _isDir;
 
   UString _background_String;
   UString _backgrounded_String;
@@ -152,7 +172,6 @@ class CProgressDialog: public NWindows::NControl::CModalDialog
   NWindows::NControl::CProgressBar m_ProgressBar;
   NWindows::NControl::CListView _messageList;
   
-  unsigned _numMessages;
   UStringVector _messageStrings;
 
   // #ifdef __ITaskbarList3_INTERFACE_DEFINED__
@@ -175,28 +194,10 @@ class CProgressDialog: public NWindows::NControl::CModalDialog
   UString _filesStr_Prev;
   UString _filesTotStr_Prev;
 
+  unsigned _numReduceSymbols;
   unsigned _prevSpeed_MoveBits;
   UInt64 _prevSpeed;
 
-  bool _foreground;
-
-  unsigned _numReduceSymbols;
-
-  bool _wasCreated;
-  bool _needClose;
-
-  unsigned _numPostedMessages;
-  UInt32 _numAutoSizeMessages;
-
-  bool _errorsWereDisplayed;
-
-  bool _waitCloseByCancelButton;
-  bool _cancelWasPressed;
-  
-  bool _inCancelMessageBox;
-  bool _externalCloseMessageWasReceived;
-
-
   // #ifdef __ITaskbarList3_INTERFACE_DEFINED__
   void SetTaskbarProgressState(TBPFLAG tbpFlags)
   {
@@ -244,14 +245,10 @@ class CProgressDialog: public NWindows::NControl::CModalDialog
   void ShowAfterMessages(HWND wndParent);
 
   void CheckNeedClose();
+
 public:
   CProgressSync Sync;
-  bool CompressingMode;
-  bool WaitMode;
-  bool ShowCompressionInfo;
-  bool MessagesDisplayed; // = true if user pressed OK on all messages or there are no messages.
   int IconID;
-
   HWND MainWindow;
   #ifndef Z7_SFX
   UString MainTitle;
diff --git a/CPP/7zip/UI/FileManager/RegistryUtils.cpp b/CPP/7zip/UI/FileManager/RegistryUtils.cpp
index 7e61998..0284591 100644
--- a/CPP/7zip/UI/FileManager/RegistryUtils.cpp
+++ b/CPP/7zip/UI/FileManager/RegistryUtils.cpp
@@ -86,17 +86,15 @@ static bool Read7ZipOption(LPCTSTR value, bool defaultValue)
   if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) == ERROR_SUCCESS)
   {
     bool enabled;
-    if (key.QueryValue(value, enabled) == ERROR_SUCCESS)
+    if (key.GetValue_bool_IfOk(value, enabled) == ERROR_SUCCESS)
       return enabled;
   }
   return defaultValue;
 }
 
-static void ReadOption(CKey &key, LPCTSTR value, bool &dest)
+static void ReadOption(CKey &key, LPCTSTR name, bool &dest)
 {
-  bool enabled = false;
-  if (key.QueryValue(value, enabled) == ERROR_SUCCESS)
-    dest = enabled;
+  key.GetValue_bool_IfOk(name, dest);
 }
 
 /*
diff --git a/CPP/7zip/UI/FileManager/RootFolder.cpp b/CPP/7zip/UI/FileManager/RootFolder.cpp
index 192f660..b512f3b 100644
--- a/CPP/7zip/UI/FileManager/RootFolder.cpp
+++ b/CPP/7zip/UI/FileManager/RootFolder.cpp
@@ -249,7 +249,7 @@ Z7_COM7F_IMF(CRootFolder::BindToFolder(const wchar_t *name, IFolderFolder **resu
       AreEqualNames(name2, L"Documents"))
     return BindToFolder((UInt32)ROOT_INDEX_DOCUMENTS, resultFolder);
   #else
-  if (name2 == WSTRING_PATH_SEPARATOR)
+  if (name2.IsEqualTo(STRING_PATH_SEPARATOR))
     return BindToFolder((UInt32)ROOT_INDEX_COMPUTER, resultFolder);
   #endif
   
@@ -257,7 +257,7 @@ Z7_COM7F_IMF(CRootFolder::BindToFolder(const wchar_t *name, IFolderFolder **resu
       AreEqualNames(name2, L"Computer"))
     return BindToFolder((UInt32)ROOT_INDEX_COMPUTER, resultFolder);
   
-  if (name2 == WSTRING_PATH_SEPARATOR)
+  if (name2.IsEqualTo(STRING_PATH_SEPARATOR))
   {
     CMyComPtr<IFolderFolder> subFolder = this;
     *resultFolder = subFolder.Detach();
diff --git a/CPP/7zip/UI/FileManager/SettingsPage.cpp b/CPP/7zip/UI/FileManager/SettingsPage.cpp
index a5117be..8b5983a 100644
--- a/CPP/7zip/UI/FileManager/SettingsPage.cpp
+++ b/CPP/7zip/UI/FileManager/SettingsPage.cpp
@@ -161,7 +161,7 @@ bool CSettingsPage::OnInit()
     needSetCur = false;
   }
   {
-    _ramSize = (UInt64)(sizeof(size_t)) << 29;
+    _ramSize = (size_t)sizeof(size_t) << 29;
     _ramSize_Defined = NSystem::GetRamSize(_ramSize);
     UString s;
     if (_ramSize_Defined)
@@ -198,10 +198,10 @@ bool CSettingsPage::OnInit()
 
 
   {
-    UInt64 ramSize = (UInt64)sizeof(size_t) << 29;
+    size_t ramSize = (size_t)sizeof(size_t) << 29;
     const bool ramSize_defined = NWindows::NSystem::GetRamSize(ramSize);
     // ramSize *= 10; // for debug
-    UInt64 ramSize_GB = (ramSize + (1u << 29)) >> 30;
+    UInt32 ramSize_GB = (UInt32)(((UInt64)ramSize + (1u << 29)) >> 30);
     if (ramSize_GB == 0)
       ramSize_GB = 1;
     UString s ("GB");
diff --git a/CPP/7zip/UI/FileManager/SysIconUtils.cpp b/CPP/7zip/UI/FileManager/SysIconUtils.cpp
index 406c9e1..72fe5e7 100644
--- a/CPP/7zip/UI/FileManager/SysIconUtils.cpp
+++ b/CPP/7zip/UI/FileManager/SysIconUtils.cpp
@@ -109,7 +109,7 @@ DWORD_PTR Shell_GetFileInfo_SysIconIndex_for_Path_attrib_iconIndexRef(
     iconIndex = shFileInfo.iIcon;
     // we use SHGFI_USEFILEATTRIBUTES, and
     //   (res != 0) is expected for main cases, even if there are no such file.
-    //   (res == 0) for path with kSuperPrefix \\?\
+    //   (res == 0) for path with kSuperPrefix "\\?\"
     // Also SHGFI_USEFILEATTRIBUTES still returns icon inside exe.
     // So we can use SHGFI_USEFILEATTRIBUTES for any case.
     // UString temp = fs2us(path); // for debug
diff --git a/CPP/7zip/UI/FileManager/UpdateCallback100.cpp b/CPP/7zip/UI/FileManager/UpdateCallback100.cpp
index 71ad710..0796eba 100644
--- a/CPP/7zip/UI/FileManager/UpdateCallback100.cpp
+++ b/CPP/7zip/UI/FileManager/UpdateCallback100.cpp
@@ -113,6 +113,29 @@ Z7_COM7F_IMF(CUpdateCallback100Imp::SetCompleted(const UInt64 * /* files */, con
   return ProgressDialog->Sync.CheckStop();
 }
 
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::MoveArc_Start(const wchar_t *srcTempPath, const wchar_t *destFinalPath, UInt64 size, Int32 updateMode))
+{
+  return MoveArc_Start_Base(srcTempPath, destFinalPath, size, updateMode);
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::MoveArc_Progress(UInt64 totalSize, UInt64 currentSize))
+{
+  return MoveArc_Progress_Base(totalSize, currentSize);
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::MoveArc_Finish())
+{
+  return MoveArc_Finish_Base();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::Before_ArcReopen())
+{
+  ProgressDialog->Sync.Clear_Stop_Status();
+  return S_OK;
+}
+
+
 Z7_COM7F_IMF(CUpdateCallback100Imp::CryptoGetTextPassword(BSTR *password))
 {
   *password = NULL;
diff --git a/CPP/7zip/UI/FileManager/UpdateCallback100.h b/CPP/7zip/UI/FileManager/UpdateCallback100.h
index 5d56dfb..adae94f 100644
--- a/CPP/7zip/UI/FileManager/UpdateCallback100.h
+++ b/CPP/7zip/UI/FileManager/UpdateCallback100.h
@@ -16,6 +16,7 @@
 class CUpdateCallback100Imp Z7_final:
   public IFolderArchiveUpdateCallback,
   public IFolderArchiveUpdateCallback2,
+  public IFolderArchiveUpdateCallback_MoveArc,
   public IFolderScanProgress,
   public ICryptoGetTextPassword2,
   public ICryptoGetTextPassword,
@@ -24,9 +25,10 @@ class CUpdateCallback100Imp Z7_final:
   public CUpdateCallbackGUI2,
   public CMyUnknownImp
 {
-  Z7_COM_UNKNOWN_IMP_7(
+  Z7_COM_UNKNOWN_IMP_8(
     IFolderArchiveUpdateCallback,
     IFolderArchiveUpdateCallback2,
+    IFolderArchiveUpdateCallback_MoveArc,
     IFolderScanProgress,
     ICryptoGetTextPassword2,
     ICryptoGetTextPassword,
@@ -36,6 +38,7 @@ class CUpdateCallback100Imp Z7_final:
   Z7_IFACE_COM7_IMP(IProgress)
   Z7_IFACE_COM7_IMP(IFolderArchiveUpdateCallback)
   Z7_IFACE_COM7_IMP(IFolderArchiveUpdateCallback2)
+  Z7_IFACE_COM7_IMP(IFolderArchiveUpdateCallback_MoveArc)
   Z7_IFACE_COM7_IMP(IFolderScanProgress)
   Z7_IFACE_COM7_IMP(ICryptoGetTextPassword2)
   Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
diff --git a/CPP/7zip/UI/FileManager/ViewSettings.cpp b/CPP/7zip/UI/FileManager/ViewSettings.cpp
index 3d64602..4a8f58d 100644
--- a/CPP/7zip/UI/FileManager/ViewSettings.cpp
+++ b/CPP/7zip/UI/FileManager/ViewSettings.cpp
@@ -81,15 +81,15 @@ void CListViewInfo::Read(const UString &id)
 {
   Clear();
   CByteBuffer buf;
-  UInt32 size;
   {
     NSynchronization::CCriticalSectionLock lock(g_CS);
     CKey key;
     if (key.Open(HKEY_CURRENT_USER, kCulumnsKeyName, KEY_READ) != ERROR_SUCCESS)
       return;
-    if (key.QueryValue(GetSystemString(id), buf, size) != ERROR_SUCCESS)
+    if (key.QueryValue_Binary(GetSystemString(id), buf) != ERROR_SUCCESS)
       return;
   }
+  unsigned size = (unsigned)buf.Size();
   if (size < kListViewHeaderSize)
     return;
   UInt32 version;
@@ -104,7 +104,9 @@ void CListViewInfo::Read(const UString &id)
   size -= kListViewHeaderSize;
   if (size % kColumnInfoSize != 0)
     return;
-  unsigned numItems = size / kColumnInfoSize;
+  if (size > 1000 * kColumnInfoSize)
+    return;
+  const unsigned numItems = size / kColumnInfoSize;
   Columns.ClearAndReserve(numItems);
   for (unsigned i = 0; i < numItems; i++)
   {
@@ -161,8 +163,7 @@ void CWindowInfo::Save() const
 
 static bool QueryBuf(CKey &key, LPCTSTR name, CByteBuffer &buf, UInt32 dataSize)
 {
-  UInt32 size;
-  return key.QueryValue(name, buf, size) == ERROR_SUCCESS && size == dataSize;
+  return key.QueryValue_Binary(name, buf) == ERROR_SUCCESS && buf.Size() == dataSize;
 }
 
 void CWindowInfo::Read(bool &windowPosDefined, bool &panelInfoDefined)
@@ -206,7 +207,7 @@ static bool ReadUi32Val(const TCHAR *name, UInt32 &value)
   CKey key;
   if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) != ERROR_SUCCESS)
     return false;
-  return key.QueryValue(name, value) == ERROR_SUCCESS;
+  return key.GetValue_UInt32_IfOk(name, value) == ERROR_SUCCESS;
 }
 
 void SaveToolbarsMask(UInt32 toolbarMask)
@@ -229,7 +230,7 @@ void CListMode::Save() const
 {
   UInt32 t = 0;
   for (int i = 0; i < 2; i++)
-    t |= ((Panels[i]) & 0xFF) << (i * 8);
+    t |= (Panels[i] & 0xFF) << (i * 8);
   SaveUi32Val(kListMode, t);
 }
 
@@ -241,7 +242,7 @@ void CListMode::Read()
     return;
   for (int i = 0; i < 2; i++)
   {
-    Panels[i] = (t & 0xFF);
+    Panels[i] = t & 0xFF;
     t >>= 8;
   }
 }
diff --git a/CPP/7zip/UI/FileManager/makefile b/CPP/7zip/UI/FileManager/makefile
index 0ca5caa..24dc4ca 100644
--- a/CPP/7zip/UI/FileManager/makefile
+++ b/CPP/7zip/UI/FileManager/makefile
@@ -104,7 +104,7 @@ AR_COMMON_OBJS = \
 C_OBJS = $(C_OBJS) \
   $O\Alloc.obj \
   $O\CpuArch.obj \
-  $O\Sort.obj \
   $O\Threads.obj \
 
+!include "../../Sort.mak"
 !include "../../7zip.mak"
diff --git a/CPP/7zip/UI/FileManager/resource.h b/CPP/7zip/UI/FileManager/resource.h
index 4e22230..36c4b53 100644
--- a/CPP/7zip/UI/FileManager/resource.h
+++ b/CPP/7zip/UI/FileManager/resource.h
@@ -25,9 +25,12 @@
 #define IDM_CRC64                103
 #define IDM_SHA1                 104
 #define IDM_SHA256               105
-#define IDM_XXH64                106
-#define IDM_BLAKE2SP             107
-
+#define IDM_SHA384               106
+#define IDM_SHA512               107
+#define IDM_SHA3_256             108
+#define IDM_XXH64                120
+#define IDM_BLAKE2SP             121
+#define IDM_MD5                  122
 
 #define IDM_FILE                 500
 #define IDM_EDIT                 501
@@ -134,7 +137,7 @@
 #define IDS_COPY_TO                     6002
 #define IDS_MOVE_TO                     6003
 #define IDS_COPYING                     6004
-#define IDS_MOVING                      6005
+// #define IDS_MOVING                      6005
 #define IDS_RENAMING                    6006
 
 #define IDS_OPERATION_IS_NOT_SUPPORTED  6008
diff --git a/CPP/7zip/UI/FileManager/resource.rc b/CPP/7zip/UI/FileManager/resource.rc
index feeeaf5..d9fc6f2 100644
--- a/CPP/7zip/UI/FileManager/resource.rc
+++ b/CPP/7zip/UI/FileManager/resource.rc
@@ -58,8 +58,12 @@ BEGIN
       MENUITEM "CRC-32",                    IDM_CRC32
       MENUITEM "CRC-64",                    IDM_CRC64
       MENUITEM "XXH64",                     IDM_XXH64
+      MENUITEM "MD5",                       IDM_MD5
       MENUITEM "SHA-1",                     IDM_SHA1
       MENUITEM "SHA-256",                   IDM_SHA256
+      MENUITEM "SHA-384",                   IDM_SHA384
+      MENUITEM "SHA-512",                   IDM_SHA512
+      MENUITEM "SHA3-256",                  IDM_SHA3_256
       MENUITEM "BLAKE2sp",                  IDM_BLAKE2SP
       MENUITEM "*",                         IDM_HASH_ALL
     END
@@ -202,7 +206,7 @@ BEGIN
   IDS_COPY_TO   "Copy to:"
   IDS_MOVE_TO   "Move to:"
   IDS_COPYING   "Copying..."
-  IDS_MOVING    "Moving..."
+//  IDS_MOVING    "Moving..."
   IDS_RENAMING  "Renaming..."
 
   IDS_OPERATION_IS_NOT_SUPPORTED  "Operation is not supported."
diff --git a/CPP/7zip/UI/FileManager/resourceGui.h b/CPP/7zip/UI/FileManager/resourceGui.h
index 848b36f..2e1bab3 100644
--- a/CPP/7zip/UI/FileManager/resourceGui.h
+++ b/CPP/7zip/UI/FileManager/resourceGui.h
@@ -6,6 +6,8 @@
 #define IDS_OPENNING                    3303
 #define IDS_SCANNING                    3304
 
+#define IDS_MOVING                      6005
+
 #define IDS_CHECKSUM_CALCULATING        7500
 #define IDS_CHECKSUM_INFORMATION        7501
 #define IDS_CHECKSUM_CRC_DATA           7502
diff --git a/CPP/7zip/UI/FileManager/resourceGui.rc b/CPP/7zip/UI/FileManager/resourceGui.rc
index 143e9f6..ad0d1f4 100644
--- a/CPP/7zip/UI/FileManager/resourceGui.rc
+++ b/CPP/7zip/UI/FileManager/resourceGui.rc
@@ -6,6 +6,8 @@ BEGIN
 
   IDS_PROGRESS_TESTING      "Testing"
 
+  IDS_MOVING    "Moving..."
+
   IDS_CHECKSUM_CALCULATING    "Checksum calculating..."
   IDS_CHECKSUM_INFORMATION    "Checksum information"
   IDS_CHECKSUM_CRC_DATA       "CRC checksum for data:"
diff --git a/CPP/7zip/UI/GUI/BenchmarkDialog.cpp b/CPP/7zip/UI/GUI/BenchmarkDialog.cpp
index 7f2edfa..1686c69 100644
--- a/CPP/7zip/UI/GUI/BenchmarkDialog.cpp
+++ b/CPP/7zip/UI/GUI/BenchmarkDialog.cpp
@@ -61,9 +61,9 @@ struct CBenchPassResult
 {
   CTotalBenchRes Enc;
   CTotalBenchRes Dec;
-  #ifdef PRINT_ITER_TIME
+#ifdef PRINT_ITER_TIME
   DWORD Ticks;
-  #endif
+#endif
   // CBenchInfo EncInfo; // for debug
   // CBenchPassResult() {};
 };
@@ -97,21 +97,9 @@ struct CTotalBenchRes2: public CTotalBenchRes
 struct CSyncData
 {
   UInt32 NumPasses_Finished;
-
-  // UInt64 NumEncProgress; // for debug
-  // UInt64 NumDecProgress; // for debug
-  // CBenchInfo EncInfo; // for debug
-
-  CTotalBenchRes2 Enc_BenchRes_1;
-  CTotalBenchRes2 Enc_BenchRes;
-
-  CTotalBenchRes2 Dec_BenchRes_1;
-  CTotalBenchRes2 Dec_BenchRes;
-
-  #ifdef PRINT_ITER_TIME
+#ifdef PRINT_ITER_TIME
   DWORD TotalTicks;
-  #endif
-
+#endif
   int RatingVector_DeletedIndex;
   // UInt64 RatingVector_NumDeleted;
 
@@ -124,6 +112,16 @@ struct CSyncData
   bool NeedPrint_Dec;
   bool NeedPrint_Tot; // intermediate Total was updated after current pass
 
+  // UInt64 NumEncProgress; // for debug
+  // UInt64 NumDecProgress; // for debug
+  // CBenchInfo EncInfo; // for debug
+
+  CTotalBenchRes2 Enc_BenchRes_1;
+  CTotalBenchRes2 Enc_BenchRes;
+
+  CTotalBenchRes2 Dec_BenchRes_1;
+  CTotalBenchRes2 Dec_BenchRes;
+
   void Init();
 };
 
@@ -161,24 +159,18 @@ void CSyncData::Init()
 struct CBenchProgressSync
 {
   bool Exit; // GUI asks BenchThread to Exit, and BenchThread reads that variable
+  bool TextWasChanged;
+
   UInt32 NumThreads;
   UInt64 DictSize;
   UInt32 NumPasses_Limit;
   int Level;
-  
-  // must be written by benchmark thread, read by GUI thread */
-  CSyncData sd;
-  CRecordVector<CBenchPassResult> RatingVector;
-
-  NWindows::NSynchronization::CCriticalSection CS;
 
   AString Text;
-  bool TextWasChanged;
 
   /* BenchFinish_Task_HRESULT    - for result from benchmark code
      BenchFinish_Thread_HRESULT  - for Exceptions and service errors
              these arreos must be shown even if user escapes benchmark */
-
   HRESULT BenchFinish_Task_HRESULT;
   HRESULT BenchFinish_Thread_HRESULT;
 
@@ -186,6 +178,12 @@ struct CBenchProgressSync
   UString FreqString_Sync;
   UString FreqString_GUI;
 
+  // must be written by benchmark thread, read by GUI thread */
+  CRecordVector<CBenchPassResult> RatingVector;
+  CSyncData sd;
+
+  NWindows::NSynchronization::CCriticalSection CS;
+
   CBenchProgressSync()
   {
     NumPasses_Limit = 1;
@@ -258,6 +256,19 @@ struct CThreadBenchmark
 class CBenchmarkDialog:
   public NWindows::NControl::CModalDialog
 {
+  bool _finishTime_WasSet;
+  
+  bool WasStopped_in_GUI;
+  bool ExitWasAsked_in_GUI;
+  bool NeedRestart;
+
+  bool RamSize_Defined;
+
+public:
+  bool TotalMode;
+
+private:
+
   NWindows::NControl::CComboBox m_Dictionary;
   NWindows::NControl::CComboBox m_NumThreads;
   NWindows::NControl::CComboBox m_NumPasses;
@@ -266,17 +277,11 @@ class CBenchmarkDialog:
 
   UInt32 _startTime;
   UInt32 _finishTime;
-  bool _finishTime_WasSet;
-  
-  bool WasStopped_in_GUI;
-  bool ExitWasAsked_in_GUI;
-  bool NeedRestart;
 
   CMyFont _font;
 
-  UInt64 RamSize;
-  UInt64 RamSize_Limit;
-  bool RamSize_Defined;
+  size_t RamSize;
+  size_t RamSize_Limit;
 
   UInt32 NumPasses_Finished_Prev;
 
@@ -330,7 +335,6 @@ class CBenchmarkDialog:
 public:
   CBenchProgressSync Sync;
 
-  bool TotalMode;
   CObjectVector<CProperty> Props;
 
   CSysString Bench2Text;
@@ -339,11 +343,11 @@ public:
   CThreadBenchmark _threadBenchmark;
 
   CBenchmarkDialog():
-      _timer(0),
       WasStopped_in_GUI(false),
       ExitWasAsked_in_GUI(false),
       NeedRestart(false),
-      TotalMode(false)
+      TotalMode(false),
+      _timer(0)
       {}
 
   ~CBenchmarkDialog() Z7_DESTRUCTOR_override;
@@ -504,7 +508,8 @@ bool CBenchmarkDialog::OnInit()
         SetItemTextA(IDT_BENCH_SYS2, s2);
     }
     {
-      GetCpuName_MultiLine(s);
+      AString registers;
+      GetCpuName_MultiLine(s, registers);
       SetItemTextA(IDT_BENCH_CPU, s);
     }
     {
@@ -1851,7 +1856,7 @@ HRESULT Benchmark(
     const CProperty &prop = props[i];
     UString name = prop.Name;
     name.MakeLower_Ascii();
-    if (name.IsEqualTo_Ascii_NoCase("m") && prop.Value == L"*")
+    if (name.IsEqualTo_Ascii_NoCase("m") && prop.Value.IsEqualTo("*"))
     {
       bd.TotalMode = true;
       continue;
@@ -1860,7 +1865,7 @@ HRESULT Benchmark(
     NCOM::CPropVariant propVariant;
     if (!prop.Value.IsEmpty())
       ParseNumberString(prop.Value, propVariant);
-    if (name.IsPrefixedBy(L"mt"))
+    if (name.IsPrefixedBy("mt"))
     {
       #ifndef Z7_ST
       RINOK(ParseMtProp(name.Ptr(2), propVariant, numCPUs, numThreads))
diff --git a/CPP/7zip/UI/GUI/BenchmarkDialog.rc b/CPP/7zip/UI/GUI/BenchmarkDialog.rc
index 3e73e46..5df7ff2 100644
--- a/CPP/7zip/UI/GUI/BenchmarkDialog.rc
+++ b/CPP/7zip/UI/GUI/BenchmarkDialog.rc
@@ -81,7 +81,7 @@ BEGIN
 
   LTEXT  "&Number of CPU threads:", IDT_BENCH_NUM_THREADS, m, 30, g0xs, 8
   COMBOBOX  IDC_BENCH_NUM_THREADS, g1x, 29, g1xs, 140, MY_COMBO
-  LTEXT  "", IDT_BENCH_HARDWARE_THREADS, gc2x, 30, g7xs, MY_TEXT_NOPREFIX
+  LTEXT  "", IDT_BENCH_HARDWARE_THREADS, gc2x, 30, g7xs, 24, SS_NOPREFIX
 
   RTEXT  "Size", IDT_BENCH_SIZE,                xSize,   54, sSize,   MY_TEXT_NOPREFIX
   RTEXT  "CPU Usage", IDT_BENCH_USAGE_LABEL,    xUsage,  54, sUsage,  MY_TEXT_NOPREFIX
diff --git a/CPP/7zip/UI/GUI/CompressDialog.cpp b/CPP/7zip/UI/GUI/CompressDialog.cpp
index fd53062..85d7186 100644
--- a/CPP/7zip/UI/GUI/CompressDialog.cpp
+++ b/CPP/7zip/UI/GUI/CompressDialog.cpp
@@ -211,11 +211,13 @@ static const EMethodID g_ZstdMethods[] =
 };
 */
 
+/*
 static const EMethodID g_SwfcMethods[] =
 {
   kDeflate
   // kLZMA
 };
+*/
 
 static const EMethodID g_TarMethods[] =
 {
@@ -278,7 +280,8 @@ static const CFormatInfo g_Formats[] =
   },
   {
     "7z",
-    (1 << 0) | (1 << 1) | (1 << 3) | (1 << 5) | (1 << 7) | (1 << 9),
+    // (1 << 0) | (1 << 1) | (1 << 3) | (1 << 5) | (1 << 7) | (1 << 9),
+    (1 << 10) - 1,
     METHODS_PAIR(g_7zMethods),
     kFF_Filter | kFF_Solid | kFF_MultiThread | kFF_Encrypt |
     kFF_EncryptFileNames | kFF_MemUse | kFF_SFX
@@ -306,7 +309,8 @@ static const CFormatInfo g_Formats[] =
   },
   {
     "xz",
-    (1 << 1) | (1 << 3) | (1 << 5) | (1 << 7) | (1 << 9),
+    // (1 << 1) | (1 << 3) | (1 << 5) | (1 << 7) | (1 << 9),
+    (1 << 10) - 1 - (1 << 0), // store (1 << 0) is not supported
     METHODS_PAIR(g_XzMethods),
     kFF_Solid | kFF_MultiThread | kFF_MemUse
   },
@@ -321,12 +325,14 @@ static const CFormatInfo g_Formats[] =
     | kFF_MemUse
   },
   */
+/*
   {
     "Swfc",
     (1 << 1) | (1 << 3) | (1 << 5) | (1 << 7) | (1 << 9),
     METHODS_PAIR(g_SwfcMethods),
     0
   },
+*/
   {
     "Tar",
     (1 << 0),
@@ -429,22 +435,23 @@ bool CCompressDialog::OnInit()
   #endif
 
   {
-    UInt64 size = (UInt64)(sizeof(size_t)) << 29;
+    size_t size = (size_t)sizeof(size_t) << 29;
     _ramSize_Defined = NSystem::GetRamSize(size);
     // size = (UInt64)3 << 62; // for debug only;
-    _ramSize = size;
-    const UInt64 kMinUseSize = (1 << 26);
-    if (size < kMinUseSize)
-      size = kMinUseSize;
-
-    unsigned bits = sizeof(size_t) * 8;
-    if (bits == 32)
     {
-      const UInt32 limit2 = (UInt32)7 << 28;
-      if (size > limit2)
-        size = limit2;
+      // we use reduced limit for 32-bit version:
+      unsigned bits = sizeof(size_t) * 8;
+      if (bits == 32)
+      {
+        const UInt32 limit2 = (UInt32)7 << 28;
+        if (size > limit2)
+            size = limit2;
+      }
     }
-
+    _ramSize = size;
+    const size_t kMinUseSize = 1 << 26;
+    if (size < kMinUseSize)
+        size = kMinUseSize;
     _ramSize_Reduced = size;
 
     // 80% - is auto usage limit in handlers
@@ -1580,24 +1587,26 @@ void CCompressDialog::SetLevel2()
 
   for (unsigned i = 0; i < sizeof(UInt32) * 8; i++)
   {
-    const UInt32 mask = (UInt32)1 << i;
-    if ((fi.LevelsMask & mask) != 0)
+    const UInt32 mask = fi.LevelsMask >> i;
+    // if (mask == 0) break;
+    if (mask & 1)
     {
-      const UInt32 langID = g_Levels[i];
       UString s;
       s.Add_UInt32(i);
-      // if (fi.LevelsMask < (1 << (MY_ZSTD_LEVEL_MAX + 1)) - 1)
-      if (langID)
-      if (i != 0 || !isZstd)
+      if (i < Z7_ARRAY_SIZE(g_Levels))
       {
-        s += " - ";
-        s += LangString(langID);
+        const UInt32 langID = g_Levels[i];
+        // if (fi.LevelsMask < (1 << (MY_ZSTD_LEVEL_MAX + 1)) - 1)
+        if (langID)
+          if (i != 0 || !isZstd)
+          {
+            s += " - ";
+            AddLangString(s, langID);
+          }
       }
       const int index = (int)m_Level.AddString(s);
       m_Level.SetItemData(index, (LPARAM)i);
     }
-    if (fi.LevelsMask <= mask)
-      break;
   }
   SetNearestSelectComboBox(m_Level, level);
 }
@@ -1931,11 +1940,11 @@ void CCompressDialog::SetDictionary2()
     case kLZMA2:
     {
       {
-        _auto_Dict =
-            ( level <= 3 ? ((UInt32)1 << (level * 2 + 16)) :
-            ( level <= 6 ? ((UInt32)1 << (level + 19)) :
-            ( level <= 7 ? ((UInt32)1 << 25) : ((UInt32)1 << 26)
-            )));
+        _auto_Dict = level <= 4 ?
+            (UInt32)1 << (level * 2 + 16) :
+            level <= sizeof(size_t) / 2 + 4 ?
+              (UInt32)1 << (level + 20) :
+              (UInt32)1 << (sizeof(size_t) / 2 + 24);
       }
 
       // we use threshold 3.75 GiB to switch to kLzmaMaxDictSize.
@@ -2591,11 +2600,17 @@ void CCompressDialog::SetNumThreads2()
   UInt32 numAlgoThreadsMax = numHardwareThreads * 2;
   const int methodID = GetMethodID();
 
-  switch (methodID)
+  const bool isZip = IsZipFormat();
+  if (isZip)
+    numAlgoThreadsMax =
+        8 << (sizeof(size_t) / 2); // 32 threads for 32-bit : 128 threads for 64-bit
+  else if (IsXzFormat())
+    numAlgoThreadsMax = 256 * 2;
+  else switch (methodID)
   {
     case kLZMA: numAlgoThreadsMax = 2; break;
     case kLZMA2: numAlgoThreadsMax = 256; break;
-    case kBZip2: numAlgoThreadsMax = 32; break;
+    case kBZip2: numAlgoThreadsMax = 64; break;
     // case kZSTD: numAlgoThreadsMax = num_ZSTD_threads_MAX; break;
     case kCopy:
     case kPPMd:
@@ -2604,17 +2619,6 @@ void CCompressDialog::SetNumThreads2()
     case kPPMdZip:
       numAlgoThreadsMax = 1;
   }
-  const bool isZip = IsZipFormat();
-  if (isZip)
-  {
-    numAlgoThreadsMax =
-      #ifdef _WIN32
-        64; // _WIN32 supports only 64 threads in one group. So no need for more threads here
-      #else
-        128;
-      #endif
-  }
-
   UInt32 autoThreads = numHardwareThreads;
   if (autoThreads > numAlgoThreadsMax)
     autoThreads = numAlgoThreadsMax;
@@ -2999,7 +3003,7 @@ UInt64 CCompressDialog::GetMemoryUsage_Threads_Dict_DecompMem(UInt32 numThreads,
       else
       {
         size += numBlockThreads * (size1 + chunkSize);
-        UInt32 numPackChunks = numBlockThreads + (numBlockThreads / 8) + 1;
+        const UInt32 numPackChunks = numBlockThreads + (numBlockThreads / 8) + 1;
         if (chunkSize < ((UInt32)1 << 26)) numBlockThreads++;
         if (chunkSize < ((UInt32)1 << 24)) numBlockThreads++;
         if (chunkSize < ((UInt32)1 << 22)) numBlockThreads++;
diff --git a/CPP/7zip/UI/GUI/CompressDialog.h b/CPP/7zip/UI/GUI/CompressDialog.h
index c2d2699..e0f3aa5 100644
--- a/CPP/7zip/UI/GUI/CompressDialog.h
+++ b/CPP/7zip/UI/GUI/CompressDialog.h
@@ -141,6 +141,15 @@ struct CBool1
 
 class CCompressDialog: public NWindows::NControl::CModalDialog
 {
+public:
+  CBool1 SymLinks;
+  CBool1 HardLinks;
+  CBool1 AltStreams;
+  CBool1 NtSecurity;
+  CBool1 PreserveATime;
+private:
+  bool _ramSize_Defined;
+
   NWindows::NControl::CComboBox m_ArchivePath;
   NWindows::NControl::CComboBox m_Format;
   NWindows::NControl::CComboBox m_Level;
@@ -179,20 +188,13 @@ class CCompressDialog: public NWindows::NControl::CModalDialog
   UString DirPrefix;
   UString StartDirPrefix;
 
-  bool _ramSize_Defined;
-  UInt64 _ramSize;         // full RAM size avail
-  UInt64 _ramSize_Reduced; // full for 64-bit and reduced for 32-bit
+  size_t _ramSize;         // full RAM size avail
+  size_t _ramSize_Reduced; // full for 64-bit and reduced for 32-bit
   UInt64 _ramUsage_Auto;
 
 public:
   NCompression::CInfo m_RegistryInfo;
 
-  CBool1 SymLinks;
-  CBool1 HardLinks;
-  CBool1 AltStreams;
-  CBool1 NtSecurity;
-  CBool1 PreserveATime;
-
   void SetArchiveName(const UString &name);
   int FindRegistryFormat(const UString &name);
   unsigned FindRegistryFormat_Always(const UString &name);
diff --git a/CPP/7zip/UI/GUI/UpdateCallbackGUI.cpp b/CPP/7zip/UI/GUI/UpdateCallbackGUI.cpp
index 26057a7..424c6e4 100644
--- a/CPP/7zip/UI/GUI/UpdateCallbackGUI.cpp
+++ b/CPP/7zip/UI/GUI/UpdateCallbackGUI.cpp
@@ -252,6 +252,21 @@ HRESULT CUpdateCallbackGUI::DeletingAfterArchiving(const FString &path, bool isD
   return ProgressDialog->Sync.Set_Status2(_lang_Removing, fs2us(path), isDir);
 }
 
+
+HRESULT CUpdateCallbackGUI::MoveArc_Start(const wchar_t *srcTempPath, const wchar_t *destFinalPath, UInt64 totalSize, Int32 updateMode)
+{
+  return MoveArc_Start_Base(srcTempPath, destFinalPath, totalSize, updateMode);
+}
+HRESULT CUpdateCallbackGUI::MoveArc_Progress(UInt64 totalSize, UInt64 currentSize)
+{
+  return MoveArc_Progress_Base(totalSize, currentSize);
+}
+HRESULT CUpdateCallbackGUI::MoveArc_Finish()
+{
+  return MoveArc_Finish_Base();
+}
+
+
 HRESULT CUpdateCallbackGUI::StartOpenArchive(const wchar_t * /* name */)
 {
   return S_OK;
diff --git a/CPP/7zip/UI/GUI/UpdateCallbackGUI2.cpp b/CPP/7zip/UI/GUI/UpdateCallbackGUI2.cpp
index 966f57e..53fed91 100644
--- a/CPP/7zip/UI/GUI/UpdateCallbackGUI2.cpp
+++ b/CPP/7zip/UI/GUI/UpdateCallbackGUI2.cpp
@@ -8,6 +8,7 @@
 #include "resource2.h"
 #include "resource3.h"
 #include "ExtractRes.h"
+#include "../FileManager/resourceGui.h"
 
 #include "UpdateCallbackGUI.h"
 
@@ -29,7 +30,8 @@ void CUpdateCallbackGUI2::Init()
 {
   NumFiles = 0;
 
-  _lang_Removing = LangString(IDS_PROGRESS_REMOVE);
+  LangString(IDS_PROGRESS_REMOVE, _lang_Removing);
+  LangString(IDS_MOVING, _lang_Moving);
   _lang_Ops.Clear();
   for (unsigned i = 0; i < Z7_ARRAY_SIZE(k_UpdNotifyLangs); i++)
     _lang_Ops.Add(LangString(k_UpdNotifyLangs[i]));
@@ -57,3 +59,72 @@ HRESULT CUpdateCallbackGUI2::ShowAskPasswordDialog()
   PasswordIsDefined = true;
   return S_OK;
 }
+
+
+HRESULT CUpdateCallbackGUI2::MoveArc_UpdateStatus()
+{
+  UString s;
+  s.Add_UInt64(_arcMoving_percents);
+  s.Add_Char('%');
+
+  const bool totalDefined = (_arcMoving_total != 0 && _arcMoving_total != (UInt64)(Int64)-1);
+  if (totalDefined || _arcMoving_current != 0)
+  {
+    s += " : ";
+    s.Add_UInt64(_arcMoving_current >> 20);
+    s += " MiB";
+  }
+  if (totalDefined)
+  {
+    s += " / ";
+    s.Add_UInt64((_arcMoving_total + ((1 << 20) - 1)) >> 20);
+    s += " MiB";
+  }
+
+  s += " : ";
+  s += _lang_Moving;
+  s += " : ";
+  // s.Add_Char('\"');
+  s += _arcMoving_name1;
+  // s.Add_Char('\"');
+  return ProgressDialog->Sync.Set_Status2(s, _arcMoving_name2,
+      false); // isDir
+}
+
+
+HRESULT CUpdateCallbackGUI2::MoveArc_Start_Base(const wchar_t *srcTempPath, const wchar_t *destFinalPath, UInt64 totalSize, Int32 updateMode)
+{
+  _arcMoving_percents = 0;
+  _arcMoving_total = totalSize;
+  _arcMoving_current = 0;
+  _arcMoving_updateMode = updateMode;
+  _arcMoving_name1 = srcTempPath;
+  _arcMoving_name2 = destFinalPath;
+  return MoveArc_UpdateStatus();
+}
+
+
+HRESULT CUpdateCallbackGUI2::MoveArc_Progress_Base(UInt64 totalSize, UInt64 currentSize)
+{
+  _arcMoving_total = totalSize;
+  _arcMoving_current = currentSize;
+  UInt64 percents = 0;
+  if (totalSize != 0)
+  {
+    if (totalSize < ((UInt64)1 << 57))
+      percents = currentSize * 100 / totalSize;
+    else
+      percents = currentSize / (totalSize / 100);
+  }
+  if (percents == _arcMoving_percents)
+    return ProgressDialog->Sync.CheckStop();
+  // Sleep(300); // for debug
+  _arcMoving_percents = percents;
+  return MoveArc_UpdateStatus();
+}
+
+
+HRESULT CUpdateCallbackGUI2::MoveArc_Finish_Base()
+{
+  return ProgressDialog->Sync.Set_Status2(L"", L"", false);
+}
diff --git a/CPP/7zip/UI/GUI/UpdateCallbackGUI2.h b/CPP/7zip/UI/GUI/UpdateCallbackGUI2.h
index e32b602..56747ff 100644
--- a/CPP/7zip/UI/GUI/UpdateCallbackGUI2.h
+++ b/CPP/7zip/UI/GUI/UpdateCallbackGUI2.h
@@ -7,17 +7,38 @@
 
 class CUpdateCallbackGUI2
 {
-  UStringVector _lang_Ops;
-  UString _emptyString;
 public:
-  UString Password;
+  CProgressDialog *ProgressDialog;
+protected:
+  UString _arcMoving_name1;
+  UString _arcMoving_name2;
+  UInt64 _arcMoving_percents;
+  UInt64 _arcMoving_total;
+  UInt64 _arcMoving_current;
+  Int32  _arcMoving_updateMode;
+public:
   bool PasswordIsDefined;
   bool PasswordWasAsked;
   UInt64 NumFiles;
-
+  UString Password;
+protected:
+  UStringVector _lang_Ops;
   UString _lang_Removing;
+  UString _lang_Moving;
+  UString _emptyString;
+
+  HRESULT MoveArc_UpdateStatus();
+  HRESULT MoveArc_Start_Base(const wchar_t *srcTempPath, const wchar_t *destFinalPath, UInt64 /* totalSize */, Int32 updateMode);
+  HRESULT MoveArc_Progress_Base(UInt64 totalSize, UInt64 currentSize);
+  HRESULT MoveArc_Finish_Base();
+
+public:
 
   CUpdateCallbackGUI2():
+      _arcMoving_percents(0),
+      _arcMoving_total(0),
+      _arcMoving_current(0),
+      _arcMoving_updateMode(0),
       PasswordIsDefined(false),
       PasswordWasAsked(false),
       NumFiles(0)
@@ -25,8 +46,6 @@ public:
   
   void Init();
 
-  CProgressDialog *ProgressDialog;
-
   HRESULT SetOperation_Base(UInt32 notifyOp, const wchar_t *name, bool isDir);
   HRESULT ShowAskPasswordDialog();
 };
diff --git a/CPP/7zip/UI/GUI/makefile b/CPP/7zip/UI/GUI/makefile
index 22ae095..b879a5d 100644
--- a/CPP/7zip/UI/GUI/makefile
+++ b/CPP/7zip/UI/GUI/makefile
@@ -141,10 +141,9 @@ C_OBJS = \
   $O\Alloc.obj \
   $O\CpuArch.obj \
   $O\DllSecur.obj \
-  $O\Sort.obj \
   $O\Threads.obj \
 
 !include "../../Crc.mak"
-
+!include "../../Sort.mak"
 
 !include "../../7zip.mak"
diff --git a/CPP/7zip/warn_gcc.mak b/CPP/7zip/warn_gcc.mak
index b6ed9c3..6152ab1 100644
--- a/CPP/7zip/warn_gcc.mak
+++ b/CPP/7zip/warn_gcc.mak
@@ -11,16 +11,16 @@ CFLAGS_WARN_GCC_4_8 = \
   -Wunused \
   -Wunused-macros \
 
-CFLAGS_WARN_GCC_6 = $(CFLAGS_WARN_GCC_4_8)\
+CFLAGS_WARN_GCC_5 = $(CFLAGS_WARN_GCC_4_8)\
   -Wbool-compare \
+
+CFLAGS_WARN_GCC_6 = $(CFLAGS_WARN_GCC_5)\
   -Wduplicated-cond \
 
 #  -Wno-strict-aliasing
 
-CFLAGS_WARN_GCC_9 = $(CFLAGS_WARN_GCC_6)\
-  -Waddress-of-packed-member \
+CFLAGS_WARN_GCC_7 = $(CFLAGS_WARN_GCC_6)\
   -Wbool-operation \
-  -Wcast-align=strict \
   -Wconversion \
   -Wdangling-else \
   -Wduplicated-branches \
@@ -28,8 +28,14 @@ CFLAGS_WARN_GCC_9 = $(CFLAGS_WARN_GCC_6)\
   -Wint-in-bool-context \
   -Wmaybe-uninitialized \
   -Wmisleading-indentation \
+
+CFLAGS_WARN_GCC_8 = $(CFLAGS_WARN_GCC_7)\
+  -Wcast-align=strict \
   -Wmissing-attributes
 
+CFLAGS_WARN_GCC_9 = $(CFLAGS_WARN_GCC_8)\
+  -Waddress-of-packed-member \
+
 # In C: -Wsign-conversion enabled also by -Wconversion
 #  -Wno-sign-conversion \
 
@@ -39,7 +45,10 @@ CFLAGS_WARN_GCC_PPMD_UNALIGNED = \
 
 
 CFLAGS_WARN = $(CFLAGS_WARN_GCC_4_8)
+CFLAGS_WARN = $(CFLAGS_WARN_GCC_5)
 CFLAGS_WARN = $(CFLAGS_WARN_GCC_6)
+CFLAGS_WARN = $(CFLAGS_WARN_GCC_7)
+CFLAGS_WARN = $(CFLAGS_WARN_GCC_8)
 CFLAGS_WARN = $(CFLAGS_WARN_GCC_9)
 
 # CXX_STD_FLAGS = -std=c++11
diff --git a/CPP/Build.mak b/CPP/Build.mak
index afb7ae8..86cc2af 100644
--- a/CPP/Build.mak
+++ b/CPP/Build.mak
@@ -111,7 +111,13 @@ CFLAGS = $(CFLAGS) -Zc:forScope
 
 !IFNDEF UNDER_CE
 !IF "$(CC)" != "clang-cl"
-CFLAGS = $(CFLAGS) -MP4
+MP_NPROC = 16
+!IFDEF NUMBER_OF_PROCESSORS
+!IF $(NUMBER_OF_PROCESSORS) < $(MP_NPROC)
+MP_NPROC = $(NUMBER_OF_PROCESSORS)
+!ENDIF
+!ENDIF
+CFLAGS = $(CFLAGS) -MP$(MP_NPROC)
 !ENDIF
 !IFNDEF PLATFORM
 # CFLAGS = $(CFLAGS) -arch:IA32
diff --git a/CPP/Common/Md5Reg.cpp b/CPP/Common/Md5Reg.cpp
new file mode 100644
index 0000000..026fd41
--- /dev/null
+++ b/CPP/Common/Md5Reg.cpp
@@ -0,0 +1,44 @@
+// Md5Reg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/Md5.h"
+
+#include "../Common/MyBuffer2.h"
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+Z7_CLASS_IMP_COM_1(
+  CMd5Hasher
+  , IHasher
+)
+  CAlignedBuffer1 _buf;
+public:
+  Byte _mtDummy[1 << 7];
+
+  CMd5 *Md5() { return (CMd5 *)(void *)(Byte *)_buf; }
+public:
+  CMd5Hasher():
+    _buf(sizeof(CMd5))
+  {
+    Md5_Init(Md5());
+  }
+};
+
+Z7_COM7F_IMF2(void, CMd5Hasher::Init())
+{
+  Md5_Init(Md5());
+}
+
+Z7_COM7F_IMF2(void, CMd5Hasher::Update(const void *data, UInt32 size))
+{
+  Md5_Update(Md5(), (const Byte *)data, size);
+}
+
+Z7_COM7F_IMF2(void, CMd5Hasher::Final(Byte *digest))
+{
+  Md5_Final(Md5(), digest);
+}
+
+REGISTER_HASHER(CMd5Hasher, 0x208, "MD5", MD5_DIGEST_SIZE)
diff --git a/CPP/Common/MyCom.h b/CPP/Common/MyCom.h
index a3cc3c8..7dc21ba 100644
--- a/CPP/Common/MyCom.h
+++ b/CPP/Common/MyCom.h
@@ -468,6 +468,19 @@ EXTERN_C_END
   Z7_COM_QI_ENTRY(i7) \
   )
 
+#define Z7_COM_UNKNOWN_IMP_8(i1, i2, i3, i4, i5, i6, i7, i8) \
+  Z7_COM_UNKNOWN_IMP_SPEC( \
+  Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+  Z7_COM_QI_ENTRY(i1) \
+  Z7_COM_QI_ENTRY(i2) \
+  Z7_COM_QI_ENTRY(i3) \
+  Z7_COM_QI_ENTRY(i4) \
+  Z7_COM_QI_ENTRY(i5) \
+  Z7_COM_QI_ENTRY(i6) \
+  Z7_COM_QI_ENTRY(i7) \
+  Z7_COM_QI_ENTRY(i8) \
+  )
+
 
 #define Z7_IFACES_IMP_UNK_1(i1) \
   Z7_COM_UNKNOWN_IMP_1(i1) \
@@ -508,6 +521,16 @@ EXTERN_C_END
   Z7_IFACE_COM7_IMP(i5) \
   Z7_IFACE_COM7_IMP(i6) \
 
+#define Z7_IFACES_IMP_UNK_7(i1, i2, i3, i4, i5, i6, i7) \
+  Z7_COM_UNKNOWN_IMP_7(i1, i2, i3, i4, i5, i6, i7) \
+  Z7_IFACE_COM7_IMP(i1) \
+  Z7_IFACE_COM7_IMP(i2) \
+  Z7_IFACE_COM7_IMP(i3) \
+  Z7_IFACE_COM7_IMP(i4) \
+  Z7_IFACE_COM7_IMP(i5) \
+  Z7_IFACE_COM7_IMP(i6) \
+  Z7_IFACE_COM7_IMP(i7) \
+
 
 #define Z7_CLASS_IMP_COM_0(c) \
   Z7_class_final(c) : \
@@ -574,6 +597,20 @@ EXTERN_C_END
   private:
 
 
+#define Z7_CLASS_IMP_COM_7(c, i1, i2, i3, i4, i5, i6, i7) \
+  Z7_class_final(c) : \
+  public i1, \
+  public i2, \
+  public i3, \
+  public i4, \
+  public i5, \
+  public i6, \
+  public i7, \
+  public CMyUnknownImp { \
+  Z7_IFACES_IMP_UNK_7(i1, i2, i3, i4, i5, i6, i7) \
+  private:
+
+
 /*
 #define Z7_CLASS_IMP_NOQIB_0(c) \
   Z7_class_final(c) : \
diff --git a/CPP/Common/MyString.cpp b/CPP/Common/MyString.cpp
index b5f7e52..10e2331 100644
--- a/CPP/Common/MyString.cpp
+++ b/CPP/Common/MyString.cpp
@@ -208,35 +208,6 @@ bool StringsAreEqualNoCase(const wchar_t *s1, const wchar_t *s2) throw()
 
 // ---------- ASCII ----------
 
-bool AString::IsPrefixedBy_Ascii_NoCase(const char *s) const throw()
-{
-  const char *s1 = _chars;
-  for (;;)
-  {
-    const char c2 = *s++;
-    if (c2 == 0)
-      return true;
-    const char c1 = *s1++;
-    if (MyCharLower_Ascii(c1) !=
-        MyCharLower_Ascii(c2))
-      return false;
-  }
-}
-
-bool UString::IsPrefixedBy_Ascii_NoCase(const char *s) const throw()
-{
-  const wchar_t *s1 = _chars;
-  for (;;)
-  {
-    const char c2 = *s++;
-    if (c2 == 0)
-      return true;
-    const wchar_t c1 = *s1++;
-    if (MyCharLower_Ascii(c1) != (unsigned char)MyCharLower_Ascii(c2))
-      return false;
-  }
-}
-
 bool StringsAreEqual_Ascii(const char *u, const char *a) throw()
 {
   for (;;)
diff --git a/CPP/Common/MyString.h b/CPP/Common/MyString.h
index ba9914e..639b874 100644
--- a/CPP/Common/MyString.h
+++ b/CPP/Common/MyString.h
@@ -429,11 +429,11 @@ public:
   // int CompareNoCase(const char *s) const { return MyStringCompareNoCase(_chars, s); }
   // int CompareNoCase(const AString &s) const { return MyStringCompareNoCase(_chars, s._chars); }
   bool IsPrefixedBy(const char *s) const { return IsString1PrefixedByString2(_chars, s); }
-  bool IsPrefixedBy_Ascii_NoCase(const char *s) const throw();
+  bool IsPrefixedBy_Ascii_NoCase(const char *s) const { return IsString1PrefixedByString2_NoCase_Ascii(_chars, s); }
  
   bool IsAscii() const
   {
-    unsigned len = Len();
+    const unsigned len = Len();
     const char *s = _chars;
     for (unsigned i = 0; i < len; i++)
       if ((unsigned char)s[i] >= 0x80)
@@ -727,22 +727,23 @@ public:
   // int CompareNoCase(const wchar_t *s) const { return MyStringCompareNoCase(_chars, s); }
   // int CompareNoCase(const UString &s) const { return MyStringCompareNoCase(_chars, s._chars); }
   bool IsPrefixedBy(const wchar_t *s) const { return IsString1PrefixedByString2(_chars, s); }
+  bool IsPrefixedBy(const char *s) const { return IsString1PrefixedByString2(_chars, s); }
   bool IsPrefixedBy_NoCase(const wchar_t *s) const { return IsString1PrefixedByString2_NoCase(_chars, s); }
-  bool IsPrefixedBy_Ascii_NoCase(const char *s) const throw();
+  bool IsPrefixedBy_Ascii_NoCase(const char *s) const { return IsString1PrefixedByString2_NoCase_Ascii(_chars, s); }
 
   bool IsAscii() const
   {
-    unsigned len = Len();
+    const unsigned len = Len();
     const wchar_t *s = _chars;
     for (unsigned i = 0; i < len; i++)
-      if (s[i] >= 0x80)
+      if ((unsigned)(int)s[i] >= 0x80)
         return false;
     return true;
   }
   int Find(wchar_t c) const { return FindCharPosInString(_chars, c); }
   int Find(wchar_t c, unsigned startIndex) const
   {
-    int pos = FindCharPosInString(_chars + startIndex, c);
+    const int pos = FindCharPosInString(_chars + startIndex, c);
     return pos < 0 ? -1 : (int)startIndex + pos;
   }
 
diff --git a/CPP/Common/MyXml.cpp b/CPP/Common/MyXml.cpp
index cc891fc..8364aae 100644
--- a/CPP/Common/MyXml.cpp
+++ b/CPP/Common/MyXml.cpp
@@ -24,7 +24,7 @@ static bool IsSpaceChar(char c)
 int CXmlItem::FindProp(const char *propName) const throw()
 {
   FOR_VECTOR (i, Props)
-    if (Props[i].Name == propName)
+    if (Props[i].Name.IsEqualTo(propName))
       return (int)i;
   return -1;
 }
@@ -39,7 +39,7 @@ AString CXmlItem::GetPropVal(const char *propName) const
 
 bool CXmlItem::IsTagged(const char *tag) const throw()
 {
-  return (IsTag && Name == tag);
+  return (IsTag && Name.IsEqualTo(tag));
 }
 
 int CXmlItem::FindSubTag(const char *tag) const throw()
diff --git a/CPP/Common/Sha3Reg.cpp b/CPP/Common/Sha3Reg.cpp
new file mode 100644
index 0000000..cd2e288
--- /dev/null
+++ b/CPP/Common/Sha3Reg.cpp
@@ -0,0 +1,76 @@
+// Sha3Reg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/Sha3.h"
+
+#include "../Common/MyBuffer2.h"
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+Z7_CLASS_IMP_COM_1(
+  CSha3Hasher
+  , IHasher
+)
+  unsigned _digestSize;
+  bool _isShake;
+  CAlignedBuffer1 _buf;
+public:
+  Byte _mtDummy[1 << 7];
+
+  CSha3 *Sha() { return (CSha3 *)(void *)(Byte *)_buf; }
+public:
+  CSha3Hasher(unsigned digestSize, bool isShake, unsigned blockSize):
+     _digestSize(digestSize),
+     _isShake(isShake),
+    _buf(sizeof(CSha3))
+  {
+    CSha3 *p = Sha();
+    Sha3_SET_blockSize(p, blockSize)
+    Sha3_Init(Sha());
+  }
+};
+
+Z7_COM7F_IMF2(void, CSha3Hasher::Init())
+{
+  Sha3_Init(Sha());
+}
+
+Z7_COM7F_IMF2(void, CSha3Hasher::Update(const void *data, UInt32 size))
+{
+  Sha3_Update(Sha(), (const Byte *)data, size);
+}
+
+Z7_COM7F_IMF2(void, CSha3Hasher::Final(Byte *digest))
+{
+  Sha3_Final(Sha(), digest, _digestSize, _isShake);
+}
+
+Z7_COM7F_IMF2(UInt32, CSha3Hasher::GetDigestSize())
+{
+  return (UInt32)_digestSize;
+}
+
+
+#define REGISTER_SHA3_HASHER_2(cls, id, name, digestSize, isShake, digestSize_for_blockSize) \
+  namespace N ## cls { \
+  static IHasher *CreateHasherSpec() \
+    { return new CSha3Hasher(digestSize / 8, isShake, \
+        SHA3_BLOCK_SIZE_FROM_DIGEST_SIZE(digestSize_for_blockSize / 8)); } \
+  static const CHasherInfo g_HasherInfo = { CreateHasherSpec, id, name, digestSize / 8 }; \
+  struct REGISTER_HASHER_NAME(cls) { REGISTER_HASHER_NAME(cls)() { RegisterHasher(&g_HasherInfo); }}; \
+  static REGISTER_HASHER_NAME(cls) g_RegisterHasher; }
+
+#define REGISTER_SHA3_HASHER(  cls, id, name, size, isShake) \
+        REGISTER_SHA3_HASHER_2(cls, id, name, size, isShake, size)
+
+// REGISTER_SHA3_HASHER (Sha3_224_Hasher, 0x230, "SHA3-224", 224, false)
+REGISTER_SHA3_HASHER (Sha3_256_Hasher, 0x231, "SHA3-256", 256, false)
+// REGISTER_SHA3_HASHER (Sha3_386_Hasher, 0x232, "SHA3-384", 384, false)
+// REGISTER_SHA3_HASHER (Sha3_512_Hasher, 0x233, "SHA3-512", 512, false)
+// REGISTER_SHA3_HASHER (Shake128_Hasher, 0x240, "SHAKE128", 128, true)
+// REGISTER_SHA3_HASHER (Shake256_Hasher, 0x241, "SHAKE256", 256, true)
+// REGISTER_SHA3_HASHER_2 (Shake128_512_Hasher, 0x248, "SHAKE128-256", 256, true, 128) // -1344 (max)
+// REGISTER_SHA3_HASHER_2 (Shake256_512_Hasher, 0x249, "SHAKE256-512", 512, true, 256) // -1088 (max)
+// Shake supports different digestSize values for same blockSize
diff --git a/CPP/Common/Sha512Prepare.cpp b/CPP/Common/Sha512Prepare.cpp
new file mode 100644
index 0000000..e7beff5
--- /dev/null
+++ b/CPP/Common/Sha512Prepare.cpp
@@ -0,0 +1,7 @@
+// Sha512Prepare.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/Sha512.h"
+
+static struct CSha512Prepare { CSha512Prepare() { Sha512Prepare(); } } g_Sha512Prepare;
diff --git a/CPP/Common/Sha512Reg.cpp b/CPP/Common/Sha512Reg.cpp
new file mode 100644
index 0000000..21df6ba
--- /dev/null
+++ b/CPP/Common/Sha512Reg.cpp
@@ -0,0 +1,83 @@
+// Sha512Reg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/Sha512.h"
+
+#include "../Common/MyBuffer2.h"
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+Z7_CLASS_IMP_COM_2(
+  CSha512Hasher
+  , IHasher
+  , ICompressSetCoderProperties
+)
+  unsigned _digestSize;
+  CAlignedBuffer1 _buf;
+public:
+  Byte _mtDummy[1 << 7];
+
+  CSha512 *Sha() { return (CSha512 *)(void *)(Byte *)_buf; }
+public:
+  CSha512Hasher(unsigned digestSize):
+     _digestSize(digestSize),
+    _buf(sizeof(CSha512))
+  {
+    Sha512_SetFunction(Sha(), 0);
+    Sha512_InitState(Sha(), _digestSize);
+  }
+};
+
+Z7_COM7F_IMF2(void, CSha512Hasher::Init())
+{
+  Sha512_InitState(Sha(), _digestSize);
+}
+
+Z7_COM7F_IMF2(void, CSha512Hasher::Update(const void *data, UInt32 size))
+{
+  Sha512_Update(Sha(), (const Byte *)data, size);
+}
+
+Z7_COM7F_IMF2(void, CSha512Hasher::Final(Byte *digest))
+{
+  Sha512_Final(Sha(), digest, _digestSize);
+}
+
+Z7_COM7F_IMF2(UInt32, CSha512Hasher::GetDigestSize())
+{
+  return (UInt32)_digestSize;
+}
+
+Z7_COM7F_IMF(CSha512Hasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+{
+  unsigned algo = 0;
+  for (UInt32 i = 0; i < numProps; i++)
+  {
+    if (propIDs[i] == NCoderPropID::kDefaultProp)
+    {
+      const PROPVARIANT &prop = coderProps[i];
+      if (prop.vt != VT_UI4)
+        return E_INVALIDARG;
+      if (prop.ulVal > 2)
+        return E_NOTIMPL;
+      algo = (unsigned)prop.ulVal;
+    }
+  }
+  if (!Sha512_SetFunction(Sha(), algo))
+    return E_NOTIMPL;
+  return S_OK;
+}
+
+#define REGISTER_SHA512_HASHER(cls, id, name, size) \
+  namespace N ## cls { \
+  static IHasher *CreateHasherSpec() { return new CSha512Hasher(size); } \
+  static const CHasherInfo g_HasherInfo = { CreateHasherSpec, id, name, size }; \
+  struct REGISTER_HASHER_NAME(cls) { REGISTER_HASHER_NAME(cls)() { RegisterHasher(&g_HasherInfo); }}; \
+  static REGISTER_HASHER_NAME(cls) g_RegisterHasher; }
+
+// REGISTER_SHA512_HASHER (Sha512_224_Hasher, 0x220, "SHA512-224", SHA512_224_DIGEST_SIZE)
+// REGISTER_SHA512_HASHER (Sha512_256_Hasher, 0x221, "SHA512-256", SHA512_256_DIGEST_SIZE)
+REGISTER_SHA512_HASHER (Sha384Hasher,      0x222, "SHA384",     SHA512_384_DIGEST_SIZE)
+REGISTER_SHA512_HASHER (Sha512Hasher,      0x223, "SHA512",     SHA512_DIGEST_SIZE)
diff --git a/CPP/Common/Wildcard.cpp b/CPP/Common/Wildcard.cpp
index 798cbd9..b561a89 100644
--- a/CPP/Common/Wildcard.cpp
+++ b/CPP/Common/Wildcard.cpp
@@ -255,7 +255,8 @@ ForDir   nonrec         [0, M)                   same as ForBoth-File
 
 bool CItem::AreAllAllowed() const
 {
-  return ForFile && ForDir && WildcardMatching && PathParts.Size() == 1 && PathParts.Front() == L"*";
+  return ForFile && ForDir && WildcardMatching
+      && PathParts.Size() == 1 && PathParts.Front().IsEqualTo("*");
 }
 
 bool CItem::CheckPath(const UStringVector &pathParts, bool isFile) const
@@ -542,7 +543,7 @@ unsigned GetNumPrefixParts_if_DrivePath(UStringVector &pathParts)
   {
     if (pathParts.Size() < 4
         || !pathParts[1].IsEmpty()
-        || pathParts[2] != L"?")
+        || !pathParts[2].IsEqualTo("?"))
       return 0;
     testIndex = 3;
   }
@@ -574,11 +575,11 @@ static unsigned GetNumPrefixParts(const UStringVector &pathParts)
     return 1;
   if (pathParts.Size() == 2)
     return 2;
-  if (pathParts[2] == L".")
+  if (pathParts[2].IsEqualTo("."))
     return 3;
 
   unsigned networkParts = 2;
-  if (pathParts[2] == L"?")
+  if (pathParts[2].IsEqualTo("?"))
   {
     if (pathParts.Size() == 3)
       return 3;
@@ -642,7 +643,7 @@ void CCensor::AddItem(ECensorPathMode pathMode, bool include, const UString &pat
   if (pathParts.Size() >= 3
       && pathParts[0].IsEmpty()
       && pathParts[1].IsEmpty()
-      && pathParts[2] == L"?")
+      && pathParts[2].IsEqualTo("?"))
     ignoreWildcardIndex = 2;
   // #endif
 
@@ -665,7 +666,7 @@ void CCensor::AddItem(ECensorPathMode pathMode, bool include, const UString &pat
       for (unsigned i = numPrefixParts; i < pathParts.Size(); i++)
       {
         const UString &part = pathParts[i];
-        if (part == L".." || part == L".")
+        if (part.IsEqualTo("..") || part.IsEqualTo("."))
           dotsIndex = (int)i;
       }
 
diff --git a/CPP/Windows/FileDir.cpp b/CPP/Windows/FileDir.cpp
index dfeed82..ad0d8c9 100644
--- a/CPP/Windows/FileDir.cpp
+++ b/CPP/Windows/FileDir.cpp
@@ -15,8 +15,9 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
-#include "../Common/StringConvert.h"
 #include "../Common/C_FileIO.h"
+#include "../Common/MyBuffer2.h"
+#include "../Common/StringConvert.h"
 #endif
 
 #include "FileDir.h"
@@ -123,7 +124,7 @@ bool GetSystemDir(FString &path)
 #endif // UNDER_CE
 
 
-bool SetDirTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime)
+static bool SetFileTime_Base(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime, DWORD dwFlagsAndAttributes)
 {
   #ifndef _UNICODE
   if (!g_IsNT)
@@ -136,14 +137,14 @@ bool SetDirTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CF
   HANDLE hDir = INVALID_HANDLE_VALUE;
   IF_USE_MAIN_PATH
     hDir = ::CreateFileW(fs2us(path), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
-        NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+        NULL, OPEN_EXISTING, dwFlagsAndAttributes, NULL);
   #ifdef Z7_LONG_PATH
   if (hDir == INVALID_HANDLE_VALUE && USE_SUPER_PATH)
   {
     UString superPath;
     if (GetSuperPath(path, superPath, USE_MAIN_PATH))
       hDir = ::CreateFileW(superPath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
-          NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+          NULL, OPEN_EXISTING, dwFlagsAndAttributes, NULL);
   }
   #endif
 
@@ -156,6 +157,15 @@ bool SetDirTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CF
   return res;
 }
 
+bool SetDirTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime)
+{
+  return SetFileTime_Base(path, cTime, aTime, mTime, FILE_FLAG_BACKUP_SEMANTICS);
+}
+
+bool SetLinkFileTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime)
+{
+  return SetFileTime_Base(path, cTime, aTime, mTime, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT);
+}
 
 
 bool SetFileAttrib(CFSTR path, DWORD attrib)
@@ -222,6 +232,8 @@ bool RemoveDir(CFSTR path)
 }
 
 
+// When moving a directory, oldFile and newFile must be on the same drive.
+
 bool MyMoveFile(CFSTR oldFile, CFSTR newFile)
 {
   #ifndef _UNICODE
@@ -250,6 +262,59 @@ bool MyMoveFile(CFSTR oldFile, CFSTR newFile)
   return false;
 }
 
+#if defined(Z7_WIN32_WINNT_MIN) && Z7_WIN32_WINNT_MIN >= 0x0500
+static DWORD WINAPI CopyProgressRoutine_to_ICopyFileProgress(
+  LARGE_INTEGER TotalFileSize,          // file size
+  LARGE_INTEGER TotalBytesTransferred,  // bytes transferred
+  LARGE_INTEGER /* StreamSize */,             // bytes in stream
+  LARGE_INTEGER /* StreamBytesTransferred */, // bytes transferred for stream
+  DWORD /* dwStreamNumber */,                 // current stream
+  DWORD /* dwCallbackReason */,               // callback reason
+  HANDLE /* hSourceFile */,                   // handle to source file
+  HANDLE /* hDestinationFile */,              // handle to destination file
+  LPVOID lpData                         // from CopyFileEx
+)
+{
+  return ((ICopyFileProgress *)lpData)->CopyFileProgress(
+      (UInt64)TotalFileSize.QuadPart,
+      (UInt64)TotalBytesTransferred.QuadPart);
+}
+#endif
+
+bool MyMoveFile_with_Progress(CFSTR oldFile, CFSTR newFile,
+    ICopyFileProgress *progress)
+{
+#if defined(Z7_WIN32_WINNT_MIN) && Z7_WIN32_WINNT_MIN >= 0x0500
+#ifndef _UNICODE
+  if (g_IsNT)
+#endif
+  if (progress)
+  {
+    IF_USE_MAIN_PATH_2(oldFile, newFile)
+    {
+      if (::MoveFileWithProgressW(fs2us(oldFile), fs2us(newFile),
+          CopyProgressRoutine_to_ICopyFileProgress, progress, MOVEFILE_COPY_ALLOWED))
+        return true;
+      if (::GetLastError() == ERROR_REQUEST_ABORTED)
+        return false;
+    }
+    #ifdef Z7_LONG_PATH
+    if (USE_SUPER_PATH_2)
+    {
+      UString d1, d2;
+      if (GetSuperPaths(oldFile, newFile, d1, d2, USE_MAIN_PATH_2))
+        return BOOLToBool(::MoveFileWithProgressW(d1, d2,
+            CopyProgressRoutine_to_ICopyFileProgress, progress, MOVEFILE_COPY_ALLOWED));
+    }
+    #endif
+    return false;
+  }
+#else
+  UNUSED_VAR(progress)
+#endif
+  return MyMoveFile(oldFile, newFile);
+}
+
 #ifndef UNDER_CE
 #if !defined(Z7_WIN32_WINNT_MIN) || Z7_WIN32_WINNT_MIN < 0x0500  // Win2000
 #define Z7_USE_DYN_CreateHardLink
@@ -595,6 +660,35 @@ bool RemoveDirWithSubItems(const FString &path)
   return RemoveDir(path);
 }
 
+bool RemoveDirAlways_if_Empty(const FString &path)
+{
+  const DWORD attrib = NFind::GetFileAttrib(path);
+  if (attrib != INVALID_FILE_ATTRIBUTES
+      && (attrib & FILE_ATTRIBUTE_READONLY))
+  {
+    bool need_ClearAttrib = true;
+    if ((attrib & FILE_ATTRIBUTE_REPARSE_POINT) == 0)
+    {
+      FString s (path);
+      s.Add_PathSepar();
+      NFind::CEnumerator enumerator;
+      enumerator.SetDirPrefix(s);
+      NFind::CDirEntry fi;
+      if (enumerator.Next(fi))
+      {
+        // we don't want to change attributes, if there are files
+        // in directory, because RemoveDir(path) will fail.
+        need_ClearAttrib = false;
+        // SetLastError(ERROR_DIR_NOT_EMPTY);
+        // return false;
+      }
+    }
+    if (need_ClearAttrib)
+      SetFileAttrib(path, 0); // we clear read-only attrib to remove read-only dir
+  }
+  return RemoveDir(path);
+}
+
 #endif // _WIN32
 
 #ifdef UNDER_CE
@@ -878,9 +972,9 @@ bool CTempFile::Remove()
   return !_mustBeDeleted;
 }
 
-bool CTempFile::MoveTo(CFSTR name, bool deleteDestBefore)
+bool CTempFile::MoveTo(CFSTR name, bool deleteDestBefore,
+    ICopyFileProgress *progress)
 {
-  // DWORD attrib = 0;
   if (deleteDestBefore)
   {
     if (NFind::DoesFileExist_Raw(name))
@@ -891,8 +985,8 @@ bool CTempFile::MoveTo(CFSTR name, bool deleteDestBefore)
     }
   }
   DisableDeleting();
-  return MyMoveFile(_path, name);
-  
+  // if (!progress) return MyMoveFile(_path, name);
+  return MyMoveFile_with_Progress(_path, name, progress);
   /*
   if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_READONLY))
   {
@@ -941,34 +1035,59 @@ bool RemoveDir(CFSTR path)
 }
 
 
-static BOOL My_CopyFile(CFSTR oldFile, CFSTR newFile)
+static BOOL My_CopyFile(CFSTR oldFile, CFSTR newFile, ICopyFileProgress *progress)
 {
-  NWindows::NFile::NIO::COutFile outFile;
-  if (!outFile.Create_NEW(newFile))
-    return FALSE;
-  
-  NWindows::NFile::NIO::CInFile inFile;
-  if (!inFile.Open(oldFile))
-    return FALSE;
-
-  char buf[1 << 14];
-
-  for (;;)
   {
-    const ssize_t num = inFile.read_part(buf, sizeof(buf));
-    if (num == 0)
-      return TRUE;
-    if (num < 0)
+    NIO::COutFile outFile;
+    if (!outFile.Create_NEW(newFile))
       return FALSE;
-    size_t processed;
-    const ssize_t num2 = outFile.write_full(buf, (size_t)num, processed);
-    if (num2 != num || processed != (size_t)num)
+    NIO::CInFile inFile;
+    if (!inFile.Open(oldFile))
       return FALSE;
+    
+    const size_t k_BufSize = 1 << 16;
+    CAlignedBuffer1 buf(k_BufSize);
+    
+    UInt64 length = 0;
+    if (progress && !inFile.GetLength(length))
+      length = 0;
+    UInt64 prev = 0;
+    UInt64 cur = 0;
+    for (;;)
+    {
+      const ssize_t num = inFile.read_part(buf, k_BufSize);
+      if (num == 0)
+        return TRUE;
+      if (num < 0)
+        break;
+      size_t processed;
+      const ssize_t num2 = outFile.write_full(buf, (size_t)num, processed);
+      if (num2 != num || processed != (size_t)num)
+        break;
+      cur += (size_t)num2;
+      if (progress && cur - prev >= (1u << 20))
+      {
+        prev = cur;
+        if (progress->CopyFileProgress(length, cur) != PROGRESS_CONTINUE)
+        {
+          errno = EINTR; // instead of WIN32::ERROR_REQUEST_ABORTED
+          break;
+        }
+      }
+    }
   }
+  // There is file IO error or process was interrupted by user.
+  // We close output file and delete it.
+  // DeleteFileAlways doesn't change errno (if successed), but we restore errno.
+  const int errno_save = errno;
+  DeleteFileAlways(newFile);
+  errno = errno_save;
+  return FALSE;
 }
 
 
-bool MyMoveFile(CFSTR oldFile, CFSTR newFile)
+bool MyMoveFile_with_Progress(CFSTR oldFile, CFSTR newFile,
+    ICopyFileProgress *progress)
 {
   int res = rename(oldFile, newFile);
   if (res == 0)
@@ -976,7 +1095,7 @@ bool MyMoveFile(CFSTR oldFile, CFSTR newFile)
   if (errno != EXDEV) // (oldFile and newFile are not on the same mounted filesystem)
     return false;
 
-  if (My_CopyFile(oldFile, newFile) == FALSE)
+  if (My_CopyFile(oldFile, newFile, progress) == FALSE)
     return false;
     
   struct stat info_file;
@@ -990,6 +1109,11 @@ bool MyMoveFile(CFSTR oldFile, CFSTR newFile)
   return (unlink(oldFile) == 0);
 }
 
+bool MyMoveFile(CFSTR oldFile, CFSTR newFile)
+{
+  return MyMoveFile_with_Progress(oldFile, newFile, NULL);
+}
+
 
 bool CreateDir(CFSTR path)
 {
@@ -1058,17 +1182,15 @@ bool GetCurrentDir(FString &path)
 
 
 
-bool SetDirTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime)
+static bool SetFileTime_Base(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime, const int flags)
 {
   // need testing
   /*
   struct utimbuf buf;
   struct stat st;
   UNUSED_VAR(cTime)
- 
   printf("\nstat = %s\n", path);
   int ret = stat(path, &st);
-
   if (ret == 0)
   {
     buf.actime  = st.st_atime;
@@ -1080,47 +1202,42 @@ bool SetDirTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CF
     buf.actime  = cur_time;
     buf.modtime = cur_time;
   }
-
   if (aTime)
   {
     UInt32 ut;
     if (NTime::FileTimeToUnixTime(*aTime, ut))
       buf.actime = ut;
   }
-
   if (mTime)
   {
     UInt32 ut;
     if (NTime::FileTimeToUnixTime(*mTime, ut))
       buf.modtime = ut;
   }
-
   return utime(path, &buf) == 0;
   */
 
   // if (!aTime && !mTime) return true;
-
   struct timespec times[2];
   UNUSED_VAR(cTime)
-  
   bool needChange;
   needChange  = FiTime_To_timespec(aTime, times[0]);
   needChange |= FiTime_To_timespec(mTime, times[1]);
-
-  /*
-  if (mTime)
-  {
-    printf("\n time = %ld.%9ld\n", mTime->tv_sec, mTime->tv_nsec);
-  }
-  */
-
+  // if (mTime) { printf("\n time = %ld.%9ld\n", mTime->tv_sec, mTime->tv_nsec);  }
   if (!needChange)
     return true;
-  const int flags = 0; // follow link
-    // = AT_SYMLINK_NOFOLLOW; // don't follow link
   return utimensat(AT_FDCWD, path, times, flags) == 0;
 }
 
+bool SetDirTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime)
+{
+  return SetFileTime_Base(path, cTime, aTime, mTime, 0); // (flags = 0) means follow_link
+}
+
+bool SetLinkFileTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime)
+{
+  return SetFileTime_Base(path, cTime, aTime, mTime, AT_SYMLINK_NOFOLLOW);
+}
 
 
 struct C_umask
diff --git a/CPP/Windows/FileDir.h b/CPP/Windows/FileDir.h
index 573ffa2..9ba98fc 100644
--- a/CPP/Windows/FileDir.h
+++ b/CPP/Windows/FileDir.h
@@ -18,9 +18,20 @@ bool GetSystemDir(FString &path);
 WIN32 API : SetFileTime() doesn't allow to set zero timestamps in file
 but linux : allows unix time = 0 in filesystem
 */
-
+/*
+SetDirTime() can be used to set time for file or for dir.
+If path is symbolic link, SetDirTime() will follow symbolic link,
+and it will set timestamps of symbolic link's target file or dir.
+*/
 bool SetDirTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime);
 
+/*
+SetLinkFileTime() doesn't follow symbolic link,
+and it sets timestamps for symbolic link file itself.
+If (path) is not symbolic link, it still can work (at least in some new OS versions).
+*/
+bool SetLinkFileTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime);
+
 
 #ifdef _WIN32
 
@@ -41,7 +52,26 @@ int my_chown(CFSTR path, uid_t owner, gid_t group);
 bool SetFileAttrib_PosixHighDetect(CFSTR path, DWORD attrib);
 
 
+#ifndef _WIN32
+#define PROGRESS_CONTINUE   0
+#define PROGRESS_CANCEL     1
+// #define PROGRESS_STOP       2
+// #define PROGRESS_QUIET      3
+#endif
+Z7_PURE_INTERFACES_BEGIN
+DECLARE_INTERFACE(ICopyFileProgress)
+{
+  // in: total, current: include all/processed alt streams.
+  // it returns PROGRESS_CONTINUE or PROGRESS_CANCEL.
+  virtual DWORD CopyFileProgress(UInt64 total, UInt64 current) = 0;
+};
+Z7_PURE_INTERFACES_END
+
 bool MyMoveFile(CFSTR existFileName, CFSTR newFileName);
+// (progress == NULL) is allowed
+bool MyMoveFile_with_Progress(CFSTR oldFile, CFSTR newFile,
+    ICopyFileProgress *progress);
+
 
 #ifndef UNDER_CE
 bool MyCreateHardLink(CFSTR newFileName, CFSTR existFileName);
@@ -59,6 +89,11 @@ bool CreateComplexDir(CFSTR path);
 
 bool DeleteFileAlways(CFSTR name);
 bool RemoveDirWithSubItems(const FString &path);
+#ifdef _WIN32
+bool RemoveDirAlways_if_Empty(const FString &path);
+#else
+#define RemoveDirAlways_if_Empty RemoveDir
+#endif
 
 bool MyGetFullPathName(CFSTR path, FString &resFullPath);
 bool GetFullPathAndSplit(CFSTR path, FString &resDirPrefix, FString &resFileName);
@@ -87,7 +122,9 @@ public:
   bool Create(CFSTR pathPrefix, NIO::COutFile *outFile); // pathPrefix is not folder prefix
   bool CreateRandomInTempFolder(CFSTR namePrefix, NIO::COutFile *outFile);
   bool Remove();
-  bool MoveTo(CFSTR name, bool deleteDestBefore);
+  // bool MoveTo(CFSTR name, bool deleteDestBefore);
+  bool MoveTo(CFSTR name, bool deleteDestBefore,
+      ICopyFileProgress *progress);
 };
 
 
diff --git a/CPP/Windows/FileFind.cpp b/CPP/Windows/FileFind.cpp
index ca387f6..64075ab 100644
--- a/CPP/Windows/FileFind.cpp
+++ b/CPP/Windows/FileFind.cpp
@@ -731,7 +731,7 @@ bool CFileInfo::Find(CFSTR path, bool followLink)
             bool isOK = false;
             if (finder.FindFirst(s, *this))
             {
-              if (Name == FTEXT("."))
+              if (Name.IsEqualTo("."))
               {
                 Name = path + prefixSize;
                 return true;
@@ -769,6 +769,13 @@ bool CFileInfo::Find(CFSTR path, bool followLink)
 
   // return FollowReparse(path, IsDir());
   return Fill_From_ByHandleFileInfo(path);
+/*
+  // Fill_From_ByHandleFileInfo returns false (with Access Denied error),
+  // if there is reparse link file (not directory reparse item).
+  if (Fill_From_ByHandleFileInfo(path))
+    return true;
+  return HasReparsePoint();
+*/
 }
 
 bool CFileInfoBase::Fill_From_ByHandleFileInfo(CFSTR path)
diff --git a/CPP/Windows/FileIO.h b/CPP/Windows/FileIO.h
index 6ba40eb..26edef4 100644
--- a/CPP/Windows/FileIO.h
+++ b/CPP/Windows/FileIO.h
@@ -11,8 +11,7 @@
 
 #define Z7_WIN_SYMLINK_FLAG_RELATIVE 1
 
-// what the meaning of that FLAG or field (2)?
-#define Z7_WIN_LX_SYMLINK_FLAG 2
+#define Z7_WIN_LX_SYMLINK_VERSION_2 2
 
 #ifdef _WIN32
 
@@ -44,7 +43,33 @@ namespace NWindows {
 namespace NFile {
 
 #if defined(_WIN32) && !defined(UNDER_CE)
-bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool isWSL);
+/*
+  in:  (CByteBuffer &dest) is empty
+  in:  (path) uses Windows path separator (\).
+  out: (path) uses   Linux path separator (/).
+       if (isAbsPath == true), then "c:\\" prefix is replaced to "/mnt/c/" prefix
+*/
+void Convert_WinPath_to_WslLinuxPath(FString &path, bool convertDrivePath);
+// (path) must use Linux path separator (/).
+void FillLinkData_WslLink(CByteBuffer &dest, const wchar_t *path);
+
+/*
+  in:  (CByteBuffer &dest) is empty
+  if (isSymLink == false) : MOUNT_POINT : (path) must be absolute.
+  if (isSymLink == true)  : SYMLINK : Windows
+  (path) must use Windows path separator (\).
+  (path) must be without link "\\??\\" prefix.
+  link "\\??\\" prefix will be added inside FillLinkData(), if path is absolute.
+*/
+void FillLinkData_WinLink(CByteBuffer &dest, const wchar_t *path, bool isSymLink);
+// in: (CByteBuffer &dest) is empty
+inline void FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool isWSL)
+{
+  if (isWSL)
+    FillLinkData_WslLink(dest, path);
+  else
+    FillLinkData_WinLink(dest, path, isSymLink);
+}
 #endif
 
 struct CReparseShortInfo
@@ -61,7 +86,6 @@ struct CReparseAttr
   UInt32 Flags;
   UString SubsName;
   UString PrintName;
-
   AString WslName;
 
   bool HeaderError;
@@ -71,8 +95,7 @@ struct CReparseAttr
 
   CReparseAttr(): Tag(0), Flags(0) {}
 
-  // Parse()
-  // returns (true) and (ErrorCode = 0), if (it'a correct known link)
+  // returns (true) and (ErrorCode = 0), if (it's correct known link)
   // returns (false) and (ErrorCode = ERROR_REPARSE_TAG_INVALID), if unknown tag
   bool Parse(const Byte *p, size_t size);
 
@@ -80,18 +103,14 @@ struct CReparseAttr
   bool IsSymLink_Win() const { return Tag == Z7_WIN_IO_REPARSE_TAG_SYMLINK; }
   bool IsSymLink_WSL() const { return Tag == Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK; }
 
+  // note: "/dir1/path" is marked as relative.
   bool IsRelative_Win() const { return Flags == Z7_WIN_SYMLINK_FLAG_RELATIVE; }
 
   bool IsRelative_WSL() const
   {
-    if (WslName.IsEmpty())
-      return true;
-    char c = WslName[0];
-    return !IS_PATH_SEPAR(c);
+    return WslName[0] != '/'; // WSL uses unix path separator
   }
 
-  // bool IsVolume() const;
-
   bool IsOkNamePair() const;
   UString GetPath() const;
 };
diff --git a/CPP/Windows/FileLink.cpp b/CPP/Windows/FileLink.cpp
index bb380ec..2883c82 100644
--- a/CPP/Windows/FileLink.cpp
+++ b/CPP/Windows/FileLink.cpp
@@ -39,12 +39,24 @@ namespace NFile {
 using namespace NName;
 
 /*
+Win10 Junctions/SymLinks:
+  - (/) slash doesn't work as path separator
+  - Win10 preinstalled junctions don't use tail backslash, but tail backslashes also work.
+  - double backslash works only after drive prefix "c:\\dir1\dir2\",
+    and doesn't work in another places.
+  - absolute path without \??\ prefix doesn't work
+  - absolute path "c:" doesn't work
+*/
+
+/*
   Reparse Points (Junctions and Symbolic Links):
   struct
   {
     UInt32 Tag;
     UInt16 Size;     // not including starting 8 bytes
-    UInt16 Reserved; // = 0
+    UInt16 Reserved; // = 0, DOCs: // Length, in bytes, of the unparsed portion of
+       // the file name pointed to by the FileName member of the associated file object.
+       // This member is only valid for create operations when the I/O fails with STATUS_REPARSE.
     
     UInt16 SubstituteOffset; // offset in bytes from  start of namesChars
     UInt16 SubstituteLen;    // size in bytes, it doesn't include tailed NUL
@@ -68,6 +80,16 @@ using namespace NName;
     2) Default Order in table:
          Print Path
          Substitute Path
+
+DOCS:
+  The print name SHOULD be an informative pathname, suitable for display
+  to a user, that also identifies the target of the mount point.
+  Neither of these pathnames can contain dot directory names.
+
+reparse tags, with the exception of IO_REPARSE_TAG_SYMLINK,
+are processed on the server and are not processed by a client
+after transmission over the wire.
+Clients SHOULD treat associated reparse data as opaque data.
 */
 
 /*
@@ -93,7 +115,8 @@ static const UInt32 kReparseFlags_Microsoft   = ((UInt32)1 << 31);
 #define Get16(p) GetUi16(p)
 #define Get32(p) GetUi32(p)
 
-static const wchar_t * const k_LinkPrefix = L"\\??\\";
+static const char * const k_LinkPrefix = "\\??\\";
+static const char * const k_LinkPrefix_UNC = "\\??\\UNC\\";
 static const unsigned k_LinkPrefix_Size = 4;
 
 static bool IsLinkPrefix(const wchar_t *s)
@@ -102,7 +125,7 @@ static bool IsLinkPrefix(const wchar_t *s)
 }
 
 /*
-static const wchar_t * const k_VolumePrefix = L"Volume{";
+static const char * const k_VolumePrefix = "Volume{";
 static const bool IsVolumeName(const wchar_t *s)
 {
   return IsString1PrefixedByString2(s, k_VolumePrefix);
@@ -118,7 +141,7 @@ static void WriteString(Byte *dest, const wchar_t *path)
 {
   for (;;)
   {
-    wchar_t c = *path++;
+    const wchar_t c = *path++;
     if (c == 0)
       return;
     Set16(dest, (UInt16)c)
@@ -126,62 +149,103 @@ static void WriteString(Byte *dest, const wchar_t *path)
   }
 }
 
-bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool isWSL)
+#ifdef _WIN32
+void Convert_WinPath_to_WslLinuxPath(FString &s, bool convertDrivePath)
 {
-  bool isAbs = IsAbsolutePath(path);
-  if (!isAbs && !isSymLink)
-    return false;
-
-  if (isWSL)
+  if (convertDrivePath && IsDrivePath(s))
   {
-    // unsupported characters probably use Replacement Character UTF-16 0xFFFD
-    AString utf;
-    ConvertUnicodeToUTF8(path, utf);
-    const size_t size = 4 + utf.Len();
-    if (size != (UInt16)size)
-      return false;
-    dest.Alloc(8 + size);
-    Byte *p = dest;
-    Set32(p, Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK)
-    Set16(p + 4, (UInt16)(size))
-    Set16(p + 6, 0)
-    Set32(p + 8, Z7_WIN_LX_SYMLINK_FLAG)
-    memcpy(p + 12, utf.Ptr(), utf.Len());
-    return true;
+    FChar c = s[0];
+    c = MyCharLower_Ascii(c);
+    s.DeleteFrontal(2);
+    s.InsertAtFront(c);
+    s.Insert(0, FTEXT("/mnt/"));
   }
+  s.Replace(FCHAR_PATH_SEPARATOR, FTEXT('/'));
+}
+#endif
 
-  // usual symbolic LINK (NOT WSL)
 
-  bool needPrintName = true;
+static const unsigned k_Link_Size_Limit = 1u << 16; // 16-bit field is used for size.
+
+void FillLinkData_WslLink(CByteBuffer &dest, const wchar_t *path)
+{
+  // dest.Free(); // it's empty already
+  // WSL probably uses Replacement Character UTF-16 0xFFFD for unsupported characters?
+  AString utf;
+  ConvertUnicodeToUTF8(path, utf);
+  const unsigned size = 4 + utf.Len();
+  if (size >= k_Link_Size_Limit)
+    return;
+  dest.Alloc(8 + size);
+  Byte *p = dest;
+  Set32(p, Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK)
+  // Set32(p + 4, (UInt32)size)
+  Set16(p + 4, (UInt16)size)
+  Set16(p + 6, 0)
+  Set32(p + 8, Z7_WIN_LX_SYMLINK_VERSION_2)
+  memcpy(p + 12, utf.Ptr(), utf.Len());
+}
+
 
-  if (IsSuperPath(path))
+void FillLinkData_WinLink(CByteBuffer &dest, const wchar_t *path, bool isSymLink)
+{
+  // dest.Free(); // it's empty already
+  bool isAbs = false;
+  if (IS_PATH_SEPAR(path[0]))
   {
-    path += kSuperPathPrefixSize;
-    if (!IsDrivePath(path))
-      needPrintName = false;
+    // root paths "\dir1\path" are marked as relative
+    if (IS_PATH_SEPAR(path[1]))
+      isAbs = true;
+  }
+  else
+    isAbs = IsAbsolutePath(path);
+  if (!isAbs && !isSymLink)
+  {
+    // Win10 allows us to create relative MOUNT_POINT.
+    // But relative MOUNT_POINT will not work when accessing it.
+    // So we prevent useless creation of a relative MOUNT_POINT.
+    return;
   }
 
-  const unsigned add_Prefix_Len = isAbs ? k_LinkPrefix_Size : 0;
-    
+  bool needPrintName = true;
+  UString subs (path);
+  if (isAbs)
+  {
+    const bool isSuperPath = IsSuperPath(path);
+    if (!isSuperPath && NName::IsNetworkPath(us2fs(path)))
+    {
+      subs = k_LinkPrefix_UNC;
+      subs += (path + 2);
+    }
+    else
+    {
+      if (isSuperPath)
+      {
+        // we remove super prefix:
+        path += kSuperPathPrefixSize;
+        // we want to get correct abolute path in PrintName still.
+        if (!IsDrivePath(path))
+          needPrintName = false; // we need "\\server\path" for print name.
+      }
+      subs = k_LinkPrefix;
+      subs += path;
+    }
+  }
+  const size_t len1 = subs.Len() * 2;
   size_t len2 = (size_t)MyStringLen(path) * 2;
-  const size_t len1 = len2 + add_Prefix_Len * 2;
   if (!needPrintName)
     len2 = 0;
-
-  size_t totalNamesSize = (len1 + len2);
-
+  size_t totalNamesSize = len1 + len2;
   /* some WIM imagex software uses old scheme for symbolic links.
-     so we can old scheme for byte to byte compatibility */
-
-  bool newOrderScheme = isSymLink;
+     so we can use old scheme for byte to byte compatibility */
+  const bool newOrderScheme = isSymLink;
   // newOrderScheme = false;
-
   if (!newOrderScheme)
-    totalNamesSize += 2 * 2;
+    totalNamesSize += 2 * 2; // we use NULL terminators in old scheme.
 
   const size_t size = 8 + 8 + (isSymLink ? 4 : 0) + totalNamesSize;
-  if (size != (UInt16)size)
-    return false;
+  if (size >= k_Link_Size_Limit)
+    return;
   dest.Alloc(size);
   memset(dest, 0, size);
   const UInt32 tag = isSymLink ?
@@ -189,6 +253,7 @@ bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool i
       Z7_WIN_IO_REPARSE_TAG_MOUNT_POINT;
   Byte *p = dest;
   Set32(p, tag)
+  // Set32(p + 4, (UInt32)(size - 8))
   Set16(p + 4, (UInt16)(size - 8))
   Set16(p + 6, 0)
   p += 8;
@@ -204,21 +269,16 @@ bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool i
   Set16(p + 2, (UInt16)len1)
   Set16(p + 4, (UInt16)printOffs)
   Set16(p + 6, (UInt16)len2)
-
   p += 8;
   if (isSymLink)
   {
-    UInt32 flags = isAbs ? 0 : Z7_WIN_SYMLINK_FLAG_RELATIVE;
+    const UInt32 flags = isAbs ? 0 : Z7_WIN_SYMLINK_FLAG_RELATIVE;
     Set32(p, flags)
     p += 4;
   }
-
-  if (add_Prefix_Len != 0)
-    WriteString(p + subOffs, k_LinkPrefix);
-  WriteString(p + subOffs + add_Prefix_Len * 2, path);
+  WriteString(p + subOffs, subs);
   if (needPrintName)
     WriteString(p + printOffs, path);
-  return true;
 }
 
 #endif // defined(_WIN32) && !defined(UNDER_CE)
@@ -230,7 +290,7 @@ static void GetString(const Byte *p, unsigned len, UString &res)
   unsigned i;
   for (i = 0; i < len; i++)
   {
-    wchar_t c = Get16(p + i * 2);
+    const wchar_t c = Get16(p + (size_t)i * 2);
     if (c == 0)
       break;
     s[i] = c;
@@ -239,6 +299,7 @@ static void GetString(const Byte *p, unsigned len, UString &res)
   res.ReleaseBuf_SetLen(i);
 }
 
+
 bool CReparseAttr::Parse(const Byte *p, size_t size)
 {
   ErrorCode = (DWORD)ERROR_INVALID_REPARSE_DATA;
@@ -250,7 +311,12 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
     return false;
   Tag = Get32(p);
   if (Get16(p + 6) != 0) // padding
-    return false;
+  {
+    // DOCs: Reserved : the field SHOULD be set to 0
+    // and MUST be ignored (by parser).
+    // Win10 ignores it.
+    MinorError = true; // optional
+  }
   unsigned len = Get16(p + 4);
   p += 8;
   size -= 8;
@@ -262,8 +328,6 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
       (type & kReparseFlags_Microsoft) == 0 ||
       (type & 0xFFFF) != 3)
   */
-
-
   HeaderError = false;
 
   if (   Tag != Z7_WIN_IO_REPARSE_TAG_MOUNT_POINT
@@ -282,8 +346,7 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
   {
     if (len < 4)
       return false;
-    Flags = Get32(p); // maybe it's not Flags
-    if (Flags != Z7_WIN_LX_SYMLINK_FLAG)
+    if (Get32(p) != Z7_WIN_LX_SYMLINK_VERSION_2)
       return false;
     len -= 4;
     p += 4;
@@ -291,12 +354,13 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
     unsigned i;
     for (i = 0; i < len; i++)
     {
-      char c = (char)p[i];
+      const char c = (char)p[i];
       s[i] = c;
       if (c == 0)
         break;
     }
-    WslName.ReleaseBuf_SetEnd(i);
+    s[i] = 0;
+    WslName.ReleaseBuf_SetLen(i);
     MinorError = (i != len);
     ErrorCode = 0;
     return true;
@@ -304,10 +368,10 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
   
   if (len < 8)
     return false;
-  unsigned subOffs = Get16(p);
-  unsigned subLen = Get16(p + 2);
-  unsigned printOffs = Get16(p + 4);
-  unsigned printLen = Get16(p + 6);
+  const unsigned subOffs = Get16(p);
+  const unsigned subLen = Get16(p + 2);
+  const unsigned printOffs = Get16(p + 4);
+  const unsigned printLen = Get16(p + 6);
   len -= 8;
   p += 8;
 
@@ -335,15 +399,17 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
 
 bool CReparseShortInfo::Parse(const Byte *p, size_t size)
 {
-  const Byte *start = p;
-  Offset= 0;
+  const Byte * const start = p;
+  Offset = 0;
   Size = 0;
   if (size < 8)
     return false;
-  UInt32 Tag = Get32(p);
+  const UInt32 Tag = Get32(p);
   UInt32 len = Get16(p + 4);
+  /*
   if (len + 8 > size)
     return false;
+  */
   /*
   if ((type & kReparseFlags_Alias) == 0 ||
       (type & kReparseFlags_Microsoft) == 0 ||
@@ -353,16 +419,14 @@ bool CReparseShortInfo::Parse(const Byte *p, size_t size)
       Tag != Z7_WIN_IO_REPARSE_TAG_SYMLINK)
     // return true;
     return false;
-
+  /*
   if (Get16(p + 6) != 0) // padding
     return false;
-  
+  */
   p += 8;
   size -= 8;
-  
   if (len != size) // do we need that check?
     return false;
-  
   if (len < 8)
     return false;
   unsigned subOffs = Get16(p);
@@ -396,10 +460,14 @@ bool CReparseAttr::IsOkNamePair() const
 {
   if (IsLinkPrefix(SubsName))
   {
+    if (PrintName == GetPath())
+      return true;
+/*
     if (!IsDrivePath(SubsName.Ptr(k_LinkPrefix_Size)))
       return PrintName.IsEmpty();
     if (wcscmp(SubsName.Ptr(k_LinkPrefix_Size), PrintName) == 0)
       return true;
+*/
   }
   return wcscmp(SubsName, PrintName) == 0;
 }
@@ -415,21 +483,26 @@ bool CReparseAttr::IsVolume() const
 
 UString CReparseAttr::GetPath() const
 {
+  UString s (SubsName);
   if (IsSymLink_WSL())
   {
-    UString u;
     // if (CheckUTF8(attr.WslName)
-    if (!ConvertUTF8ToUnicode(WslName, u))
-      MultiByteToUnicodeString2(u, WslName);
-    return u;
+    if (!ConvertUTF8ToUnicode(WslName, s))
+      MultiByteToUnicodeString2(s, WslName);
   }
-
-  UString s (SubsName);
-  if (IsLinkPrefix(s))
+  else if (IsLinkPrefix(s))
   {
-    s.ReplaceOneCharAtPos(1, '\\'); // we normalize prefix from "\??\" to "\\?\"
-    if (IsDrivePath(s.Ptr(k_LinkPrefix_Size)))
-      s.DeleteFrontal(k_LinkPrefix_Size);
+    if (IsString1PrefixedByString2_NoCase_Ascii(s.Ptr(), k_LinkPrefix_UNC))
+    {
+      s.DeleteFrontal(6);
+      s.ReplaceOneCharAtPos(0, '\\');
+    }
+    else
+    {
+      s.ReplaceOneCharAtPos(1, '\\'); // we normalize prefix from "\??\" to "\\?\"
+      if (IsDrivePath(s.Ptr(k_LinkPrefix_Size)))
+        s.DeleteFrontal(k_LinkPrefix_Size);
+    }
   }
   return s;
 }
@@ -468,7 +541,7 @@ bool GetReparseData(CFSTR path, CByteBuffer &reparseData, BY_HANDLE_FILE_INFORMA
 static bool CreatePrefixDirOfFile(CFSTR path)
 {
   FString path2 (path);
-  int pos = path2.ReverseFind_PathSepar();
+  const int pos = path2.ReverseFind_PathSepar();
   if (pos < 0)
     return true;
   #ifdef _WIN32
@@ -494,6 +567,8 @@ static bool OutIoReparseData(DWORD controlCode, CFSTR path, void *data, DWORD si
 }
 
 
+// MOUNT_POINT (Junction Point) and LX_SYMLINK (WSL) can be written without administrator rights.
+// SYMLINK requires administrator rights.
 // If there is Reparse data already, it still writes new Reparse data
 bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size)
 {
@@ -540,10 +615,11 @@ bool DeleteReparseData(CFSTR path)
     SetLastError(ERROR_INVALID_REPARSE_DATA);
     return false;
   }
-  BYTE buf[my_REPARSE_DATA_BUFFER_HEADER_SIZE];
-  memset(buf, 0, sizeof(buf));
-  memcpy(buf, reparseData, 4); // tag
-  return OutIoReparseData(my_FSCTL_DELETE_REPARSE_POINT, path, buf, sizeof(buf));
+  // BYTE buf[my_REPARSE_DATA_BUFFER_HEADER_SIZE];
+  // memset(buf, 0, sizeof(buf));
+  // memcpy(buf, reparseData, 4); // tag
+  memset(reparseData + 4, 0, my_REPARSE_DATA_BUFFER_HEADER_SIZE - 4);
+  return OutIoReparseData(my_FSCTL_DELETE_REPARSE_POINT, path, reparseData, my_REPARSE_DATA_BUFFER_HEADER_SIZE);
 }
 
 }
diff --git a/CPP/Windows/FileName.cpp b/CPP/Windows/FileName.cpp
index c16b3d4..eb62567 100644
--- a/CPP/Windows/FileName.cpp
+++ b/CPP/Windows/FileName.cpp
@@ -65,8 +65,15 @@ void NormalizeDirPathPrefix(UString &dirPath)
     dirPath.Add_PathSepar();
 }
 
+
+#define IS_LETTER_CHAR(c) ((((unsigned)(int)(c) | 0x20) - (unsigned)'a' <= (unsigned)('z' - 'a')))
+bool IsDrivePath (const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]); }
+// bool IsDriveName2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && s[2] == 0; }
+
 #ifdef _WIN32
 
+bool IsDrivePath2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':'; }
+
 #ifndef USE_UNICODE_FSTRING
 #ifdef Z7_LONG_PATH
 static void NormalizeDirSeparators(UString &s)
@@ -87,13 +94,6 @@ void NormalizeDirSeparators(FString &s)
       s.ReplaceOneCharAtPos(i, FCHAR_PATH_SEPARATOR);
 }
 
-#endif
-
-
-#define IS_LETTER_CHAR(c) ((((unsigned)(int)(c) | 0x20) - (unsigned)'a' <= (unsigned)('z' - 'a')))
-
-bool IsDrivePath(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]); }
-
 bool IsAltPathPrefix(CFSTR s) throw()
 {
   unsigned len = MyStringLen(s);
@@ -117,16 +117,23 @@ bool IsAltPathPrefix(CFSTR s) throw()
   return true;
 }
 
-#if defined(_WIN32) && !defined(UNDER_CE)
+#endif // _WIN32
+
 
-const char * const kSuperPathPrefix = "\\\\?\\";
+const char * const kSuperPathPrefix =
+    STRING_PATH_SEPARATOR
+    STRING_PATH_SEPARATOR "?"
+    STRING_PATH_SEPARATOR;
 #ifdef Z7_LONG_PATH
-static const char * const kSuperUncPrefix = "\\\\?\\UNC\\";
+static const char * const kSuperUncPrefix =
+    STRING_PATH_SEPARATOR
+    STRING_PATH_SEPARATOR "?"
+    STRING_PATH_SEPARATOR "UNC"
+    STRING_PATH_SEPARATOR;
 #endif
 
 #define IS_DEVICE_PATH(s)          (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && (s)[2] == '.' && IS_SEPAR((s)[3]))
 #define IS_SUPER_PREFIX(s)         (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && (s)[2] == '?' && IS_SEPAR((s)[3]))
-#define IS_SUPER_OR_DEVICE_PATH(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && ((s)[2] == '?' || (s)[2] == '.') && IS_SEPAR((s)[3]))
 
 #define IS_UNC_WITH_SLASH(s) ( \
      ((s)[0] == 'U' || (s)[0] == 'u') \
@@ -134,6 +141,16 @@ static const char * const kSuperUncPrefix = "\\\\?\\UNC\\";
   && ((s)[2] == 'C' || (s)[2] == 'c') \
   && IS_SEPAR((s)[3]))
 
+static const unsigned kDrivePrefixSize = 3; /* c:\ */
+
+bool IsSuperPath(const wchar_t *s) throw();
+bool IsSuperPath(const wchar_t *s) throw() { return IS_SUPER_PREFIX(s); }
+// bool IsSuperUncPath(const wchar_t *s) throw() { return (IS_SUPER_PREFIX(s) && IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize)); }
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+#define IS_SUPER_OR_DEVICE_PATH(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && ((s)[2] == '?' || (s)[2] == '.') && IS_SEPAR((s)[3]))
+bool IsSuperOrDevicePath(const wchar_t *s) throw() { return IS_SUPER_OR_DEVICE_PATH(s); }
 bool IsDevicePath(CFSTR s) throw()
 {
   #ifdef UNDER_CE
@@ -154,7 +171,7 @@ bool IsDevicePath(CFSTR s) throw()
   
   if (!IS_DEVICE_PATH(s))
     return false;
-  unsigned len = MyStringLen(s);
+  const unsigned len = MyStringLen(s);
   if (len == 6 && s[5] == ':')
     return true;
   if (len < 18 || len > 22 || !IsString1PrefixedByString2(s + kDevicePathPrefixSize, "PhysicalDrive"))
@@ -174,7 +191,7 @@ bool IsNetworkPath(CFSTR s) throw()
     return false;
   if (IsSuperUncPath(s))
     return true;
-  FChar c = s[2];
+  const FChar c = s[2];
   return (c != '.' && c != '?');
 }
 
@@ -187,7 +204,7 @@ unsigned GetNetworkServerPrefixSize(CFSTR s) throw()
     prefixSize = kSuperUncPathPrefixSize;
   else
   {
-    FChar c = s[2];
+    const FChar c = s[2];
     if (c == '.' || c == '?')
       return 0;
   }
@@ -209,14 +226,6 @@ bool IsNetworkShareRootPath(CFSTR s) throw()
   return s[(unsigned)pos + 1] == 0;
 }
 
-static const unsigned kDrivePrefixSize = 3; /* c:\ */
-
-bool IsDrivePath2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':'; }
-// bool IsDriveName2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && s[2] == 0; }
-bool IsSuperPath(const wchar_t *s) throw() { return IS_SUPER_PREFIX(s); }
-bool IsSuperOrDevicePath(const wchar_t *s) throw() { return IS_SUPER_OR_DEVICE_PATH(s); }
-// bool IsSuperUncPath(const wchar_t *s) throw() { return (IS_SUPER_PREFIX(s) && IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize)); }
-
 bool IsAltStreamPrefixWithColon(const UString &s) throw()
 {
   if (s.IsEmpty())
@@ -278,12 +287,14 @@ bool IsAbsolutePath(const wchar_t *s) throw()
 int FindAltStreamColon(CFSTR path) throw()
 {
   unsigned i = 0;
-  if (IsDrivePath2(path))
-    i = 2;
+  if (IsSuperPath(path))
+    i = kSuperPathPrefixSize;
+  if (IsDrivePath2(path + i))
+    i += 2;
   int colonPos = -1;
   for (;; i++)
   {
-    FChar c = path[i];
+    const FChar c = path[i];
     if (c == 0)
       return colonPos;
     if (c == ':')
@@ -347,14 +358,16 @@ unsigned GetRootPrefixSize(CFSTR s) throw()
 }
 
 #endif // USE_UNICODE_FSTRING
+#endif // _WIN32
+
 
 static unsigned GetRootPrefixSize_Of_NetworkPath(const wchar_t *s) throw()
 {
   // Network path: we look "server\path\" as root prefix
-  int pos = FindSepar(s);
+  const int pos = FindSepar(s);
   if (pos < 0)
     return 0;
-  int pos2 = FindSepar(s + (unsigned)pos + 1);
+  const int pos2 = FindSepar(s + (unsigned)pos + 1);
   if (pos2 < 0)
     return 0;
   return (unsigned)(pos + pos2 + 2);
@@ -368,7 +381,7 @@ static unsigned GetRootPrefixSize_Of_SimplePath(const wchar_t *s) throw()
     return 0;
   if (s[1] == 0 || !IS_SEPAR(s[1]))
     return 1;
-  unsigned size = GetRootPrefixSize_Of_NetworkPath(s + 2);
+  const unsigned size = GetRootPrefixSize_Of_NetworkPath(s + 2);
   return (size == 0) ? 0 : 2 + size;
 }
 
@@ -376,17 +389,21 @@ static unsigned GetRootPrefixSize_Of_SuperPath(const wchar_t *s) throw()
 {
   if (IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize))
   {
-    unsigned size = GetRootPrefixSize_Of_NetworkPath(s + kSuperUncPathPrefixSize);
+    const unsigned size = GetRootPrefixSize_Of_NetworkPath(s + kSuperUncPathPrefixSize);
     return (size == 0) ? 0 : kSuperUncPathPrefixSize + size;
   }
   // we support \\?\c:\ paths and volume GUID paths \\?\Volume{GUID}\"
-  int pos = FindSepar(s + kSuperPathPrefixSize);
+  const int pos = FindSepar(s + kSuperPathPrefixSize);
   if (pos < 0)
     return 0;
   return kSuperPathPrefixSize + (unsigned)(pos + 1);
 }
 
+#ifdef _WIN32
 unsigned GetRootPrefixSize(const wchar_t *s) throw()
+#else
+unsigned GetRootPrefixSize_WINDOWS(const wchar_t *s) throw()
+#endif
 {
   if (IS_DEVICE_PATH(s))
     return kDevicePathPrefixSize;
@@ -395,7 +412,7 @@ unsigned GetRootPrefixSize(const wchar_t *s) throw()
   return GetRootPrefixSize_Of_SimplePath(s);
 }
 
-#else // _WIN32
+#ifndef _WIN32
 
 bool IsAbsolutePath(const wchar_t *s) throw() { return IS_SEPAR(s[0]); }
 
diff --git a/CPP/Windows/FileName.h b/CPP/Windows/FileName.h
index 219b656..ce26e78 100644
--- a/CPP/Windows/FileName.h
+++ b/CPP/Windows/FileName.h
@@ -25,13 +25,13 @@ bool IsDrivePath(const wchar_t *s) throw();  // first 3 chars are drive chars li
 
 bool IsAltPathPrefix(CFSTR s) throw(); /* name: */
 
-#if defined(_WIN32) && !defined(UNDER_CE)
-
 extern const char * const kSuperPathPrefix; /* \\?\ */
 const unsigned kDevicePathPrefixSize = 4;
 const unsigned kSuperPathPrefixSize = 4;
 const unsigned kSuperUncPathPrefixSize = kSuperPathPrefixSize + 4;
 
+#if defined(_WIN32) && !defined(UNDER_CE)
+
 bool IsDevicePath(CFSTR s) throw();   /* \\.\ */
 bool IsSuperUncPath(CFSTR s) throw(); /* \\?\UNC\ */
 bool IsNetworkPath(CFSTR s) throw();  /* \\?\UNC\ or \\SERVER */
@@ -86,6 +86,15 @@ int FindAltStreamColon(CFSTR path) throw();
 bool IsAbsolutePath(const wchar_t *s) throw();
 unsigned GetRootPrefixSize(const wchar_t *s) throw();
 
+#ifndef _WIN32
+/* GetRootPrefixSize_WINDOWS() is called in linux, but it parses path by windows rules.
+   It supports only paths system (linux) slash separators (STRING_PATH_SEPARATOR),
+   It doesn't parses paths with backslash (windows) separators.
+   "c:/dir/file" is supported.
+*/
+unsigned GetRootPrefixSize_WINDOWS(const wchar_t *s) throw();
+#endif
+
 #ifdef Z7_LONG_PATH
 
 const int kSuperPathType_UseOnlyMain = 0;
diff --git a/CPP/Windows/Registry.cpp b/CPP/Windows/Registry.cpp
index c8b1709..a94a50f 100644
--- a/CPP/Windows/Registry.cpp
+++ b/CPP/Windows/Registry.cpp
@@ -78,7 +78,7 @@ LONG CKey::Close() throw()
   return res;
 }
 
-// win95, win98: deletes sunkey and all its subkeys
+// win95, win98: deletes subkey and all its subkeys
 // winNT to be deleted must not have subkeys
 LONG CKey::DeleteSubKey(LPCTSTR subKeyName) throw()
 {
@@ -88,22 +88,36 @@ LONG CKey::DeleteSubKey(LPCTSTR subKeyName) throw()
 
 LONG CKey::RecurseDeleteKey(LPCTSTR subKeyName) throw()
 {
-  CKey key;
-  LONG res = key.Open(_object, subKeyName, KEY_READ | KEY_WRITE);
-  if (res != ERROR_SUCCESS)
-    return res;
-  FILETIME fileTime;
-  const UInt32 kBufSize = MAX_PATH + 1; // 256 in ATL
-  DWORD size = kBufSize;
-  TCHAR buffer[kBufSize];
-  while (RegEnumKeyEx(key._object, 0, buffer, &size, NULL, NULL, NULL, &fileTime) == ERROR_SUCCESS)
   {
-    res = key.RecurseDeleteKey(buffer);
+    CKey key;
+    LONG res = key.Open(_object, subKeyName, KEY_READ | KEY_WRITE);
     if (res != ERROR_SUCCESS)
       return res;
-    size = kBufSize;
+    FILETIME fileTime;
+    const UInt32 kBufSize = MAX_PATH + 1; // 256 in ATL
+    TCHAR buffer[kBufSize];
+    // we use loop limit here for some unexpected code failure
+    for (unsigned loop_cnt = 0; loop_cnt < (1u << 26); loop_cnt++)
+    {
+      DWORD size = kBufSize;
+      // we always request starting item (index==0) in each iteration,
+      // because we remove starting item (index==0) in each loop iteration.
+      res = RegEnumKeyEx(key._object, 0, buffer, &size, NULL, NULL, NULL, &fileTime);
+      if (res != ERROR_SUCCESS)
+      {
+        // possible return codes:
+        //   ERROR_NO_MORE_ITEMS : are no more subkeys available
+        //   ERROR_MORE_DATA     : name buffer is too small
+        // we can try to remove (subKeyName), even if there is non ERROR_NO_MORE_ITEMS error.
+        // if (res != ERROR_NO_MORE_ITEMS) return res;
+        break;
+      }
+      res = key.RecurseDeleteKey(buffer);
+      if (res != ERROR_SUCCESS)
+        return res;
+    }
+    // key.Close();
   }
-  key.Close();
   return DeleteSubKey(subKeyName);
 }
 
@@ -127,7 +141,7 @@ LONG CKey::DeleteValue(LPCWSTR name)
   MY_ASSUME(_object != NULL);
   if (g_IsNT)
     return ::RegDeleteValueW(_object, name);
-  return DeleteValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name));
+  return DeleteValue(name == NULL ? NULL : (LPCSTR)GetSystemString(name));
 }
 #endif
 
@@ -143,12 +157,15 @@ LONG CKey::SetValue(LPCTSTR name, bool value) throw()
   return SetValue(name, BoolToUINT32(value));
 }
 
+
+// value must be string that is NULL terminated
 LONG CKey::SetValue(LPCTSTR name, LPCTSTR value) throw()
 {
   MYASSERT(value != NULL);
   MY_ASSUME(_object != NULL);
+  // note: RegSetValueEx supports (value == NULL), if (cbData == 0)
   return RegSetValueEx(_object, name, 0, REG_SZ,
-      (const BYTE *)value, ((DWORD)lstrlen(value) + 1) * sizeof(TCHAR));
+      (const BYTE *)value, (DWORD)(((DWORD)lstrlen(value) + 1) * sizeof(TCHAR)));
 }
 
 /*
@@ -156,7 +173,7 @@ LONG CKey::SetValue(LPCTSTR name, const CSysString &value)
 {
   MYASSERT(value != NULL);
   MY_ASSUME(_object != NULL);
-  return RegSetValueEx(_object, name, NULL, REG_SZ,
+  return RegSetValueEx(_object, name, 0, REG_SZ,
       (const BYTE *)(const TCHAR *)value, (value.Len() + 1) * sizeof(TCHAR));
 }
 */
@@ -169,9 +186,10 @@ LONG CKey::SetValue(LPCWSTR name, LPCWSTR value)
   MY_ASSUME(_object != NULL);
   if (g_IsNT)
     return RegSetValueExW(_object, name, 0, REG_SZ,
-      (const BYTE * )value, (DWORD)((wcslen(value) + 1) * sizeof(wchar_t)));
-  return SetValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name),
-    value == 0 ? 0 : (LPCSTR)GetSystemString(value));
+        (const BYTE *)value, (DWORD)(((DWORD)wcslen(value) + 1) * sizeof(wchar_t)));
+  return SetValue(name == NULL ? NULL :
+        (LPCSTR)GetSystemString(name),
+        (LPCSTR)GetSystemString(value));
 }
 
 #endif
@@ -205,99 +223,137 @@ LONG CKey::SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw(
   return res;
 }
 
-LONG CKey::QueryValue(LPCTSTR name, UInt32 &value) throw()
-{
-  DWORD type = 0;
-  DWORD count = sizeof(DWORD);
-  LONG res = RegQueryValueEx(_object, name, NULL, &type,
-    (LPBYTE)&value, &count);
-  MYASSERT((res != ERROR_SUCCESS) || (type == REG_DWORD));
-  MYASSERT((res != ERROR_SUCCESS) || (count == sizeof(UInt32)));
-  return res;
-}
 
-LONG CKey::QueryValue(LPCTSTR name, bool &value) throw()
+LONG CKey::GetValue_UInt32_IfOk(LPCTSTR name, UInt32 &value) throw()
 {
-  UInt32 uintValue = BoolToUINT32(value);
-  LONG res = QueryValue(name, uintValue);
-  value = UINT32ToBool(uintValue);
+  DWORD type = 0;
+  DWORD count = sizeof(value);
+  UInt32 value2; // = value;
+  const LONG res = QueryValueEx(name, &type, (LPBYTE)&value2, &count);
+  if (res == ERROR_SUCCESS)
+  {
+    // ERROR_UNSUPPORTED_TYPE
+    if (count != sizeof(value) || type != REG_DWORD)
+      return ERROR_UNSUPPORTED_TYPE; // ERROR_INVALID_DATA;
+    value = value2;
+  }
   return res;
 }
 
-LONG CKey::GetValue_IfOk(LPCTSTR name, UInt32 &value) throw()
+LONG CKey::GetValue_UInt64_IfOk(LPCTSTR name, UInt64 &value) throw()
 {
-  UInt32 newVal;
-  LONG res = QueryValue(name, newVal);
+  DWORD type = 0;
+  DWORD count = sizeof(value);
+  UInt64 value2; // = value;
+  const LONG res = QueryValueEx(name, &type, (LPBYTE)&value2, &count);
   if (res == ERROR_SUCCESS)
-    value = newVal;
+  {
+    if (count != sizeof(value) || type != REG_QWORD)
+      return ERROR_UNSUPPORTED_TYPE;
+    value = value2;
+  }
   return res;
 }
 
-LONG CKey::GetValue_IfOk(LPCTSTR name, bool &value) throw()
+LONG CKey::GetValue_bool_IfOk(LPCTSTR name, bool &value) throw()
 {
-  bool newVal = false;
-  LONG res = QueryValue(name, newVal);
+  UInt32 uintValue;
+  const LONG res = GetValue_UInt32_IfOk(name, uintValue);
   if (res == ERROR_SUCCESS)
-    value = newVal;
+    value = UINT32ToBool(uintValue);
   return res;
 }
 
-LONG CKey::QueryValue(LPCTSTR name, LPTSTR value, UInt32 &count) throw()
-{
-  DWORD type = 0;
-  LONG res = RegQueryValueEx(_object, name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
-  MYASSERT((res != ERROR_SUCCESS) || (type == REG_SZ) || (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
-  return res;
-}
+
 
 LONG CKey::QueryValue(LPCTSTR name, CSysString &value)
 {
   value.Empty();
-  DWORD type = 0;
-  DWORD curSize = 0;
-  LONG res = RegQueryValueEx(_object, name, NULL, &type, NULL, &curSize);
-  if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
-    return res;
-  UInt32 curSize2 = curSize;
-  res = QueryValue(name, value.GetBuf(curSize), curSize2);
-  if (curSize > curSize2)
-    curSize = curSize2;
-  value.ReleaseBuf_CalcLen(curSize / sizeof(TCHAR));
+  LONG res = ERROR_SUCCESS;
+  {
+    // if we don't want multiple calls here,
+    // we can use big value (264) here.
+    // 3 is default available length in new string.
+    DWORD size_prev = 3 * sizeof(TCHAR);
+    // at least 2 attempts are required. But we use more attempts for cases,
+    // where string can be changed by anothner process
+    for (unsigned i = 0; i < 2 + 2; i++)
+    {
+      DWORD type = 0;
+      DWORD size = size_prev;
+      {
+        LPBYTE buf = (LPBYTE)value.GetBuf(size / sizeof(TCHAR));
+        res = QueryValueEx(name, &type, size == 0 ? NULL : buf, &size);
+        // if (size_prev == 0), then (res == ERROR_SUCCESS) is expected here, because we requested only size.
+      }
+      if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA)
+      {
+        if (type != REG_SZ && type != REG_EXPAND_SZ)
+        {
+          res = ERROR_UNSUPPORTED_TYPE;
+          size = 0;
+        }
+      }
+      else
+        size = 0;
+      if (size > size_prev)
+      {
+        size_prev = size;
+        size = 0;
+        res = ERROR_MORE_DATA;
+      }
+      value.ReleaseBuf_CalcLen(size / sizeof(TCHAR));
+      if (res != ERROR_MORE_DATA)
+        return res;
+    }
+  }
   return res;
 }
 
 
 #ifndef _UNICODE
 
-LONG CKey::QueryValue(LPCWSTR name, LPWSTR value, UInt32 &count)
-{
-  DWORD type = 0;
-  LONG res = RegQueryValueExW(_object, name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
-  MYASSERT((res != ERROR_SUCCESS) || (type == REG_SZ) || (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
-  return res;
-}
-
 LONG CKey::QueryValue(LPCWSTR name, UString &value)
 {
   value.Empty();
-  DWORD type = 0;
-  DWORD curSize = 0;
-  LONG res;
+  LONG res = ERROR_SUCCESS;
   if (g_IsNT)
   {
-    res = RegQueryValueExW(_object, name, NULL, &type, NULL, &curSize);
-    if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
-      return res;
-    UInt32 curSize2 = curSize;
-    res = QueryValue(name, value.GetBuf(curSize), curSize2);
-    if (curSize > curSize2)
-      curSize = curSize2;
-    value.ReleaseBuf_CalcLen(curSize / sizeof(wchar_t));
+    DWORD size_prev = 3 * sizeof(wchar_t);
+    for (unsigned i = 0; i < 2 + 2; i++)
+    {
+      DWORD type = 0;
+      DWORD size = size_prev;
+      {
+        LPBYTE buf = (LPBYTE)value.GetBuf(size / sizeof(wchar_t));
+        res = RegQueryValueExW(_object, name, NULL, &type,
+            size == 0 ? NULL : buf, &size);
+      }
+      if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA)
+      {
+        if (type != REG_SZ && type != REG_EXPAND_SZ)
+        {
+          res = ERROR_UNSUPPORTED_TYPE;
+          size = 0;
+        }
+      }
+      else
+        size = 0;
+      if (size > size_prev)
+      {
+        size_prev = size;
+        size = 0;
+        res = ERROR_MORE_DATA;
+      }
+      value.ReleaseBuf_CalcLen(size / sizeof(wchar_t));
+      if (res != ERROR_MORE_DATA)
+        return res;
+    }
   }
   else
   {
     AString vTemp;
-    res = QueryValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name), vTemp);
+    res = QueryValue(name == NULL ? NULL : (LPCSTR)GetSystemString(name), vTemp);
     value = GetUnicodeString(vTemp);
   }
   return res;
@@ -306,26 +362,43 @@ LONG CKey::QueryValue(LPCWSTR name, UString &value)
 #endif
 
 
-LONG CKey::QueryValue(LPCTSTR name, void *value, UInt32 &count) throw()
+LONG CKey::QueryValue_Binary(LPCTSTR name, CByteBuffer &value)
 {
-  DWORD type = 0;
-  LONG res = RegQueryValueEx(_object, name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
-  MYASSERT((res != ERROR_SUCCESS) || (type == REG_BINARY));
+  // value.Free();
+  DWORD size_prev = 0;
+  LONG res = ERROR_SUCCESS;
+  for (unsigned i = 0; i < 2 + 2; i++)
+  {
+    DWORD type = 0;
+    DWORD size = size_prev;
+    value.Alloc(size_prev);
+    res = QueryValueEx(name, &type, value.NonConstData(), &size);
+    // if (size_prev == 0), then (res == ERROR_SUCCESS) is expected here, because we requested only size.
+    if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA)
+    {
+      if (type != REG_BINARY)
+      {
+        res = ERROR_UNSUPPORTED_TYPE;
+        size = 0;
+      }
+    }
+    else
+      size = 0;
+    if (size > size_prev)
+    {
+      size_prev = size;
+      size = 0;
+      res = ERROR_MORE_DATA;
+    }
+    if (size < value.Size())
+      value.ChangeSize_KeepData(size, size);
+    if (res != ERROR_MORE_DATA)
+      return res;
+  }
   return res;
 }
 
 
-LONG CKey::QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize)
-{
-  DWORD type = 0;
-  dataSize = 0;
-  LONG res = RegQueryValueEx(_object, name, NULL, &type, NULL, (DWORD *)&dataSize);
-  if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
-    return res;
-  value.Alloc(dataSize);
-  return QueryValue(name, (BYTE *)value, dataSize);
-}
-
 LONG CKey::EnumKeys(CSysStringVector &keyNames)
 {
   keyNames.Clear();
@@ -334,23 +407,23 @@ LONG CKey::EnumKeys(CSysStringVector &keyNames)
   {
     const unsigned kBufSize = MAX_PATH + 1; // 256 in ATL
     FILETIME lastWriteTime;
-    UInt32 nameSize = kBufSize;
-    LONG result = ::RegEnumKeyEx(_object, index, keyName.GetBuf(kBufSize),
-        (DWORD *)&nameSize, NULL, NULL, NULL, &lastWriteTime);
+    DWORD nameSize = kBufSize;
+    const LONG res = ::RegEnumKeyEx(_object, index,
+        keyName.GetBuf(kBufSize), &nameSize,
+        NULL, NULL, NULL, &lastWriteTime);
     keyName.ReleaseBuf_CalcLen(kBufSize);
-    if (result == ERROR_NO_MORE_ITEMS)
-      break;
-    if (result != ERROR_SUCCESS)
-      return result;
+    if (res == ERROR_NO_MORE_ITEMS)
+      return ERROR_SUCCESS;
+    if (res != ERROR_SUCCESS)
+      return res;
     keyNames.Add(keyName);
   }
-  return ERROR_SUCCESS;
 }
 
+
 LONG CKey::SetValue_Strings(LPCTSTR valueName, const UStringVector &strings)
 {
   size_t numChars = 0;
-  
   unsigned i;
   
   for (i = 0; i < strings.Size(); i++)
@@ -362,10 +435,11 @@ LONG CKey::SetValue_Strings(LPCTSTR valueName, const UStringVector &strings)
   for (i = 0; i < strings.Size(); i++)
   {
     const UString &s = strings[i];
-    size_t size = s.Len() + 1;
+    const size_t size = s.Len() + 1;
     wmemcpy(buffer + pos, s, size);
     pos += size;
   }
+  // if (pos != numChars) return E_FAIL;
   return SetValue(valueName, buffer, (UInt32)numChars * sizeof(wchar_t));
 }
 
@@ -373,20 +447,18 @@ LONG CKey::GetValue_Strings(LPCTSTR valueName, UStringVector &strings)
 {
   strings.Clear();
   CByteBuffer buffer;
-  UInt32 dataSize = 0;
-  const LONG res = QueryValue(valueName, buffer, dataSize);
+  const LONG res = QueryValue_Binary(valueName, buffer);
   if (res != ERROR_SUCCESS)
     return res;
-  if (dataSize > buffer.Size())
-    return E_FAIL;
-  if (dataSize % sizeof(wchar_t) != 0)
-    return E_FAIL;
-
+  const size_t dataSize = buffer.Size();
+  if (dataSize % sizeof(wchar_t))
+    return ERROR_INVALID_DATA;
   const wchar_t *data = (const wchar_t *)(const void *)(const Byte  *)buffer;
   const size_t numChars = dataSize / sizeof(wchar_t);
+  // we can check that all names are finished
+  // if (numChars != 0 && data[numChars - 1] != 0) return ERROR_INVALID_DATA;
   size_t prev = 0;
   UString s;
-  
   for (size_t i = 0; i < numChars; i++)
   {
     if (data[i] == 0)
@@ -396,7 +468,6 @@ LONG CKey::GetValue_Strings(LPCTSTR valueName, UStringVector &strings)
       prev = i + 1;
     }
   }
-  
   return res;
 }
 
diff --git a/CPP/Windows/Registry.h b/CPP/Windows/Registry.h
index 0d3b4fc..74ee919 100644
--- a/CPP/Windows/Registry.h
+++ b/CPP/Windows/Registry.h
@@ -14,6 +14,13 @@ LONG SetValue(HKEY parentKey, LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value)
 class CKey
 {
   HKEY _object;
+
+  LONG QueryValueEx(LPCTSTR lpValueName, LPDWORD lpType,
+      LPBYTE lpData, LPDWORD lpcbData)
+  {
+    return RegQueryValueEx(_object, lpValueName, NULL, lpType, lpData, lpcbData);
+  }
+
 public:
   CKey(): _object(NULL) {}
   ~CKey() { Close(); }
@@ -22,13 +29,14 @@ public:
   void Attach(HKEY key) { _object = key; }
   HKEY Detach()
   {
-    HKEY key = _object;
+    const HKEY key = _object;
     _object = NULL;
     return key;
   }
 
   LONG Create(HKEY parentKey, LPCTSTR keyName,
-      LPTSTR keyClass = REG_NONE, DWORD options = REG_OPTION_NON_VOLATILE,
+      LPTSTR keyClass = REG_NONE,
+      DWORD options = REG_OPTION_NON_VOLATILE,
       REGSAM accessMask = KEY_ALL_ACCESS,
       LPSECURITY_ATTRIBUTES securityAttributes = NULL,
       LPDWORD disposition = NULL) throw();
@@ -40,18 +48,18 @@ public:
   LONG RecurseDeleteKey(LPCTSTR subKeyName) throw();
 
   LONG DeleteValue(LPCTSTR name) throw();
-  #ifndef _UNICODE
+#ifndef _UNICODE
   LONG DeleteValue(LPCWSTR name);
-  #endif
+#endif
 
   LONG SetValue(LPCTSTR valueName, UInt32 value) throw();
   LONG SetValue(LPCTSTR valueName, bool value) throw();
   LONG SetValue(LPCTSTR valueName, LPCTSTR value) throw();
   // LONG SetValue(LPCTSTR valueName, const CSysString &value);
-  #ifndef _UNICODE
+#ifndef _UNICODE
   LONG SetValue(LPCWSTR name, LPCWSTR value);
   // LONG SetValue(LPCWSTR name, const UString &value);
-  #endif
+#endif
 
   LONG SetValue(LPCTSTR name, const void *value, UInt32 size) throw();
 
@@ -60,21 +68,25 @@ public:
 
   LONG SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw();
 
-  LONG QueryValue(LPCTSTR name, UInt32 &value) throw();
-  LONG QueryValue(LPCTSTR name, bool &value) throw();
-  LONG QueryValue(LPCTSTR name, LPTSTR value, UInt32 &dataSize) throw();
-  LONG QueryValue(LPCTSTR name, CSysString &value);
-
-  LONG GetValue_IfOk(LPCTSTR name, UInt32 &value) throw();
-  LONG GetValue_IfOk(LPCTSTR name, bool &value) throw();
+  // GetValue_[type]_IfOk():
+  //   if (return_result == ERROR_SUCCESS), (value) variable was read from registry
+  //   if (return_result != ERROR_SUCCESS), (value) variable was not changed
+  LONG GetValue_UInt32_IfOk(LPCTSTR name, UInt32 &value) throw();
+  LONG GetValue_UInt64_IfOk(LPCTSTR name, UInt64 &value) throw();
+  LONG GetValue_bool_IfOk(LPCTSTR name, bool &value) throw();
 
-  #ifndef _UNICODE
-  LONG QueryValue(LPCWSTR name, LPWSTR value, UInt32 &dataSize);
+  // QueryValue():
+  //   if (return_result == ERROR_SUCCESS), (value) string was read from registry
+  //   if (return_result != ERROR_SUCCESS), (value) string was cleared
+  LONG QueryValue(LPCTSTR name, CSysString &value);
+#ifndef _UNICODE
   LONG QueryValue(LPCWSTR name, UString &value);
-  #endif
+#endif
 
-  LONG QueryValue(LPCTSTR name, void *value, UInt32 &dataSize) throw();
-  LONG QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize);
+  // QueryValue_Binary():
+  //   if (return_result == ERROR_SUCCESS), (value) buffer was read from registry (BINARY data)
+  //   if (return_result != ERROR_SUCCESS), (value) buffer was cleared
+  LONG QueryValue_Binary(LPCTSTR name, CByteBuffer &value);
 
   LONG EnumKeys(CSysStringVector &keyNames);
 };
diff --git a/CPP/Windows/System.cpp b/CPP/Windows/System.cpp
index 03c8988..4745785 100644
--- a/CPP/Windows/System.cpp
+++ b/CPP/Windows/System.cpp
@@ -25,6 +25,69 @@ namespace NSystem {
 
 #ifdef _WIN32
 
+/*
+note: returned value in 32-bit version can be limited by value 32.
+      while 64-bit version returns full value.
+GetMaximumProcessorCount(groupNumber) can return higher value than
+GetActiveProcessorCount(groupNumber) in some cases, because CPUs can be added.
+*/
+// typedef DWORD (WINAPI *Func_GetMaximumProcessorCount)(WORD GroupNumber);
+typedef DWORD (WINAPI *Func_GetActiveProcessorCount)(WORD GroupNumber);
+typedef WORD (WINAPI *Func_GetActiveProcessorGroupCount)(VOID);
+/*
+#if 0 && defined(ALL_PROCESSOR_GROUPS)
+#define MY_ALL_PROCESSOR_GROUPS   ALL_PROCESSOR_GROUPS
+#else
+#define MY_ALL_PROCESSOR_GROUPS   0xffff
+#endif
+*/
+
+Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
+
+bool CCpuGroups::Load()
+{
+  NumThreadsTotal = 0;
+  GroupSizes.Clear();
+  const HMODULE hmodule = ::GetModuleHandleA("kernel32.dll");
+  // Is_Win11_Groups = GetProcAddress(hmodule, "SetThreadSelectedCpuSetMasks") != NULL;
+  const
+      Func_GetActiveProcessorGroupCount
+        fn_GetActiveProcessorGroupCount = Z7_GET_PROC_ADDRESS(
+      Func_GetActiveProcessorGroupCount, hmodule,
+          "GetActiveProcessorGroupCount");
+  const
+      Func_GetActiveProcessorCount
+        fn_GetActiveProcessorCount = Z7_GET_PROC_ADDRESS(
+      Func_GetActiveProcessorCount, hmodule,
+          "GetActiveProcessorCount");
+  if (!fn_GetActiveProcessorGroupCount ||
+      !fn_GetActiveProcessorCount)
+    return false;
+
+  const unsigned numGroups = fn_GetActiveProcessorGroupCount();
+  if (numGroups == 0)
+    return false;
+  UInt32 sum = 0;
+  for (unsigned i = 0; i < numGroups; i++)
+  {
+    const UInt32 num = fn_GetActiveProcessorCount((WORD)i);
+    /*
+    if (num == 0)
+    {
+      // it means error
+      // but is it possible that some group is empty by some reason?
+      // GroupSizes.Clear();
+      // return false;
+    }
+    */
+    sum += num;
+    GroupSizes.Add(num);
+  }
+  NumThreadsTotal = sum;
+  // NumThreadsTotal = fn_GetActiveProcessorCount(MY_ALL_PROCESSOR_GROUPS);
+  return true;
+}
+
 UInt32 CountAffinity(DWORD_PTR mask)
 {
   UInt32 num = 0;
@@ -38,31 +101,62 @@ UInt32 CountAffinity(DWORD_PTR mask)
 
 BOOL CProcessAffinity::Get()
 {
-  #ifndef UNDER_CE
-  return GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask);
-  #else
-  return FALSE;
-  #endif
+  IsGroupMode = false;
+  Groups.Load();
+  // SetThreadAffinityMask(GetCurrentThread(), 1);
+  // SetProcessAffinityMask(GetCurrentProcess(), 1);
+  BOOL res = GetProcessAffinityMask(GetCurrentProcess(),
+      &processAffinityMask, &systemAffinityMask);
+  /* DOCs: On a system with more than 64 processors, if the threads
+     of the calling process  are in a single processor group, the
+     function sets the variables pointed to by lpProcessAffinityMask
+     and lpSystemAffinityMask to the process affinity mask and the
+     processor mask of active logical processors for that group.
+     If the calling process contains threads in multiple groups,
+     the function returns zero for both affinity masks
+
+     note: tested in Win10: GetProcessAffinityMask() doesn't return 0
+           in (processAffinityMask) and (systemAffinityMask) masks.
+     We need to test it in Win11: how to get mask==0 from GetProcessAffinityMask()?
+  */
+  if (!res)
+  {
+    processAffinityMask = 0;
+    systemAffinityMask = 0;
+  }
+  if (Groups.GroupSizes.Size() > 1 && Groups.NumThreadsTotal)
+    if (// !res ||
+        processAffinityMask == 0 || // to support case described in DOCs and for (!res) case
+        processAffinityMask == systemAffinityMask) // for default nonchanged affinity
+    {
+      // we set IsGroupMode only if processAffinity is default (not changed).
+      res = TRUE;
+      IsGroupMode = true;
+    }
+  return res;
 }
 
 
+UInt32 CProcessAffinity::Load_and_GetNumberOfThreads()
+{
+  if (Get())
+  {
+    const UInt32 numProcessors = GetNumProcessThreads();
+    if (numProcessors)
+      return numProcessors;
+  }
+  SYSTEM_INFO systemInfo;
+  GetSystemInfo(&systemInfo);
+  // the number of logical processors in the current group
+  return systemInfo.dwNumberOfProcessors;
+}
+
 UInt32 GetNumberOfProcessors()
 {
   // We need to know how many threads we can use.
   // By default the process is assigned to one group.
-  // So we get the number of logical processors (threads)
-  // assigned to current process in the current group.
-  // Group size can be smaller than total number logical processors, for exammple, 2x36
-
   CProcessAffinity pa;
-
-  if (pa.Get() && pa.processAffinityMask != 0)
-    return pa.GetNumProcessThreads();
-
-  SYSTEM_INFO systemInfo;
-  GetSystemInfo(&systemInfo);
-  // the number of logical processors in the current group
-  return (UInt32)systemInfo.dwNumberOfProcessors;
+  return pa.Load_and_GetNumberOfThreads();
 }
 
 #else
@@ -142,9 +236,9 @@ typedef BOOL (WINAPI *Func_GlobalMemoryStatusEx)(MY_LPMEMORYSTATUSEX lpBuffer);
 #endif // !UNDER_CE
 
   
-bool GetRamSize(UInt64 &size)
+bool GetRamSize(size_t &size)
 {
-  size = (UInt64)(sizeof(size_t)) << 29;
+  size = (size_t)sizeof(size_t) << 29;
 
   #ifndef UNDER_CE
     MY_MEMORYSTATUSEX stat;
@@ -167,11 +261,23 @@ bool GetRamSize(UInt64 &size)
           "GlobalMemoryStatusEx");
       if (fn && fn(&stat))
       {
-        size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
+        // (MY_MEMORYSTATUSEX::ullTotalVirtual) < 4 GiB in 32-bit mode
+        size_t size2 = (size_t)0 - 1;
+        if (size2 > stat.ullTotalPhys)
+            size2 = (size_t)stat.ullTotalPhys;
+        if (size2 > stat.ullTotalVirtual)
+            size2 = (size_t)stat.ullTotalVirtual;
+        size = size2;
         return true;
       }
     #endif
   
+    // On computers with more than 4 GB of memory:
+    //   new docs  : GlobalMemoryStatus can report (-1) value to indicate an overflow.
+    //   some old docs : GlobalMemoryStatus can report (modulo 4 GiB) value.
+    //                   (for example, if 5 GB total memory, it could report 1 GB).
+    // We don't want to get (modulo 4 GiB) value.
+    // So we use GlobalMemoryStatusEx() instead.
     {
       MEMORYSTATUS stat2;
       stat2.dwLength = sizeof(stat2);
@@ -187,9 +293,11 @@ bool GetRamSize(UInt64 &size)
 // POSIX
 // #include <stdio.h>
 
-bool GetRamSize(UInt64 &size)
+bool GetRamSize(size_t &size)
 {
-  size = (UInt64)(sizeof(size_t)) << 29;
+  UInt64 size64;
+  size = (size_t)sizeof(size_t) << 29;
+  size64 = size;
 
 #if defined(__APPLE__) || defined(__DragonFly__) || \
     defined(BSD) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
@@ -215,7 +323,7 @@ bool GetRamSize(UInt64 &size)
     // we use strict check (size_sys == sizeof(val)) for returned value
     // because big-endian encoding is possible:
     if (res == 0 && size_sys == sizeof(val) && val)
-      size = val;
+      size64 = val;
     else
     {
       uint32_t val32 = 0;
@@ -223,12 +331,12 @@ bool GetRamSize(UInt64 &size)
       res = sysctl(mib, 2, &val32, &size_sys, NULL, 0);
       // printf("\n sysctl res=%d val=%llx size_sys = %d, %d\n", res, (long long int)val32, (int)size_sys, errno);
       if (res == 0 && size_sys == sizeof(val32) && val32)
-        size = val32;
+        size64 = val32;
     }
 
   #elif defined(_AIX)
     #if defined(_SC_AIX_REALMEM) // AIX
-      size = (UInt64)sysconf(_SC_AIX_REALMEM) * 1024;
+      size64 = (UInt64)sysconf(_SC_AIX_REALMEM) * 1024;
     #endif
   #elif 0 || defined(__sun)
     #if defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
@@ -240,7 +348,7 @@ bool GetRamSize(UInt64 &size)
       // printf("\n_SC_PHYS_PAGES (hex) = %lx", (unsigned long)phys_pages);
       // printf("\n_SC_PAGESIZE = %lu\n", (unsigned long)page_size);
       if (phys_pages != -1 && page_size != -1)
-        size = (UInt64)(Int64)phys_pages * (UInt64)(Int64)page_size;
+        size64 = (UInt64)(Int64)phys_pages * (UInt64)(Int64)page_size;
     }
     #endif
   #elif defined(__gnu_hurd__)
@@ -253,7 +361,7 @@ bool GetRamSize(UInt64 &size)
   struct sysinfo info;
   if (::sysinfo(&info) != 0)
     return false;
-  size = (UInt64)info.mem_unit * info.totalram;
+  size64 = (UInt64)info.mem_unit * info.totalram;
   /*
   printf("\n mem_unit  = %lld", (UInt64)info.mem_unit);
   printf("\n totalram  = %lld", (UInt64)info.totalram);
@@ -262,10 +370,9 @@ bool GetRamSize(UInt64 &size)
 
   #endif
 
-  const UInt64 kLimit = (UInt64)1 << (sizeof(size_t) * 8 - 1);
-  if (size > kLimit)
-    size = kLimit;
-
+  size = (size_t)1 << (sizeof(size_t) * 8 - 1);
+  if (size > size64)
+      size = (size_t)size64;
   return true;
 }
 
diff --git a/CPP/Windows/System.h b/CPP/Windows/System.h
index b17111c..0c80373 100644
--- a/CPP/Windows/System.h
+++ b/CPP/Windows/System.h
@@ -9,6 +9,7 @@
 #endif
 
 #include "../Common/MyTypes.h"
+#include "../Common/MyVector.h"
 #include "../Common/MyWindows.h"
 
 namespace NWindows {
@@ -16,6 +17,34 @@ namespace NSystem {
 
 #ifdef _WIN32
 
+struct CCpuGroups
+{
+  CRecordVector<UInt32> GroupSizes;
+  UInt32 NumThreadsTotal; // sum of threads in all groups
+  // bool Is_Win11_Groups; // useless
+  
+  void Get_GroupSize_Min_Max(UInt32 &minSize, UInt32 &maxSize) const
+  {
+    unsigned num = GroupSizes.Size();
+    UInt32 minSize2 = 0, maxSize2 = 0;
+    if (num)
+    {
+      minSize2 = (UInt32)0 - 1;
+      do
+      {
+        const UInt32 v = GroupSizes[--num];
+        if (minSize2 > v) minSize2 = v;
+        if (maxSize2 < v) maxSize2 = v;
+      }
+      while (num);
+    }
+    minSize = minSize2;
+    maxSize = maxSize2;
+  }
+  bool Load();
+  CCpuGroups(): NumThreadsTotal(0) {}
+};
+
 UInt32 CountAffinity(DWORD_PTR mask);
 
 struct CProcessAffinity
@@ -25,14 +54,28 @@ struct CProcessAffinity
   DWORD_PTR processAffinityMask;
   DWORD_PTR systemAffinityMask;
 
+  CCpuGroups Groups;
+  bool IsGroupMode;
+    /*
+      IsGroupMode == true, if
+          Groups.GroupSizes.Size() > 1) && { dafalt affinity was not changed }
+      IsGroupMode == false, if single group or affinity was changed
+    */
+  
+  UInt32 Load_and_GetNumberOfThreads();
+
   void InitST()
   {
     // numProcessThreads = 1;
     // numSysThreads = 1;
     processAffinityMask = 1;
     systemAffinityMask = 1;
+    IsGroupMode = false;
+    // Groups.NumThreadsTotal = 0;
+    // Groups.Is_Win11_Groups = false;
   }
 
+/*
   void CpuZero()
   {
     processAffinityMask = 0;
@@ -42,9 +85,23 @@ struct CProcessAffinity
   {
     processAffinityMask |= ((DWORD_PTR)1 << cpuIndex);
   }
+*/
 
-  UInt32 GetNumProcessThreads() const { return CountAffinity(processAffinityMask); }
-  UInt32 GetNumSystemThreads() const { return CountAffinity(systemAffinityMask); }
+  UInt32 GetNumProcessThreads() const
+  {
+    if (IsGroupMode)
+      return Groups.NumThreadsTotal;
+    // IsGroupMode == false
+    // so we don't want to use groups
+    // we return number of threads in default primary group:
+    return CountAffinity(processAffinityMask);
+  }
+  UInt32 GetNumSystemThreads() const
+  {
+    if (Groups.GroupSizes.Size() > 1 && Groups.NumThreadsTotal)
+      return Groups.NumThreadsTotal;
+    return CountAffinity(systemAffinityMask);
+  }
 
   BOOL Get();
 
@@ -122,7 +179,7 @@ struct CProcessAffinity
 
 UInt32 GetNumberOfProcessors();
 
-bool GetRamSize(UInt64 &size); // returns false, if unknown ram size
+bool GetRamSize(size_t &size); // returns false, if unknown ram size
 
 unsigned long Get_File_OPEN_MAX();
 unsigned Get_File_OPEN_MAX_Reduced_for_3_tasks();
diff --git a/CPP/Windows/SystemInfo.cpp b/CPP/Windows/SystemInfo.cpp
index cfc6a90..35846e0 100644
--- a/CPP/Windows/SystemInfo.cpp
+++ b/CPP/Windows/SystemInfo.cpp
@@ -530,6 +530,28 @@ struct CCpuName
   AString Microcode;
   AString LargePages;
 
+#ifdef _WIN32
+  UInt32 MHz;
+
+#ifdef MY_CPU_ARM64
+#define Z7_SYS_INFO_SHOW_ARM64_REGS
+#endif
+#ifdef Z7_SYS_INFO_SHOW_ARM64_REGS
+  bool Arm64_ISAR0_EL1_Defined;
+  UInt64 Arm64_ISAR0_EL1;
+#endif
+#endif
+
+#ifdef _WIN32
+  CCpuName():
+      MHz(0)
+#ifdef Z7_SYS_INFO_SHOW_ARM64_REGS
+    , Arm64_ISAR0_EL1_Defined(false)
+    , Arm64_ISAR0_EL1(0)
+#endif
+    {}
+#endif
+
   void Fill();
 
   void Get_Revision_Microcode_LargePages(AString &s)
@@ -537,16 +559,46 @@ struct CCpuName
     s.Empty();
     AddBracedString(s, Revision);
     AddBracedString(s, Microcode);
-    s.Add_OptSpaced(LargePages);
+#ifdef _WIN32
+    if (MHz != 0)
+    {
+      s.Add_Space_if_NotEmpty();
+      s.Add_UInt32(MHz);
+      s += " MHz";
+    }
+#endif
+    if (!LargePages.IsEmpty())
+      s.Add_OptSpaced(LargePages);
+  }
+
+#ifdef Z7_SYS_INFO_SHOW_ARM64_REGS
+  void Get_Registers(AString &s)
+  {
+    if (Arm64_ISAR0_EL1_Defined)
+    {
+      // ID_AA64ISAR0_EL1
+      s.Add_OptSpaced("cp4030:");
+      PrintHex(s, Arm64_ISAR0_EL1);
+      {
+        const unsigned sha2 = ((unsigned)(Arm64_ISAR0_EL1 >> 12) & 0xf) - 1;
+        if (sha2 < 2)
+        {
+          s += ":SHA256";
+          if (sha2)
+            s += ":SHA512";
+        }
+      }
+    }
   }
+#endif
 };
 
 void CCpuName::Fill()
 {
-  CpuName.Empty();
-  Revision.Empty();
-  Microcode.Empty();
-  LargePages.Empty();
+  // CpuName.Empty();
+  // Revision.Empty();
+  // Microcode.Empty();
+  // LargePages.Empty();
 
   AString &s = CpuName;
 
@@ -600,21 +652,32 @@ void CCpuName::Fill()
           Revision += GetAnsiString(name);
         }
       }
+#ifdef _WIN32
+      key.GetValue_UInt32_IfOk(TEXT("~MHz"), MHz);
+#ifdef Z7_SYS_INFO_SHOW_ARM64_REGS
+/*
+mapping arm64 registers to Windows registry:
+CP 4000: MIDR_EL1
+CP 4020: ID_AA64PFR0_EL1
+CP 4021: ID_AA64PFR1_EL1
+CP 4028: ID_AA64DFR0_EL1
+CP 4029: ID_AA64DFR1_EL1
+CP 402C: ID_AA64AFR0_EL1
+CP 402D: ID_AA64AFR1_EL1
+CP 4030: ID_AA64ISAR0_EL1
+CP 4031: ID_AA64ISAR1_EL1
+CP 4038: ID_AA64MMFR0_EL1
+CP 4039: ID_AA64MMFR1_EL1
+CP 403A: ID_AA64MMFR2_EL1
+*/
+      if (key.GetValue_UInt64_IfOk(TEXT("CP 4030"), Arm64_ISAR0_EL1) == ERROR_SUCCESS)
+        Arm64_ISAR0_EL1_Defined = true;
+#endif
+#endif
       LONG res[2];
       CByteBuffer bufs[2];
-      {
-        for (unsigned i = 0; i < 2; i++)
-        {
-          UInt32 size = 0;
-          res[i] = key.QueryValue(i == 0 ?
-              TEXT("Previous Update Revision") :
-              TEXT("Update Revision"),
-              bufs[i], size);
-          if (res[i] == ERROR_SUCCESS)
-            if (size != bufs[i].Size())
-              res[i] = ERROR_SUCCESS + 1;
-        }
-      }
+      res[0] = key.QueryValue_Binary(TEXT("Previous Update Revision"), bufs[0]);
+      res[1] = key.QueryValue_Binary(TEXT("Update Revision"),          bufs[1]);
       if (res[0] == ERROR_SUCCESS || res[1] == ERROR_SUCCESS)
       {
         for (unsigned i = 0; i < 2; i++)
@@ -747,9 +810,18 @@ void AddCpuFeatures(AString &s)
     unsigned long h = MY_getauxval(AT_HWCAP);
     PrintHex(s, h);
     #ifdef MY_CPU_ARM64
+#ifndef HWCAP_SHA3
+#define HWCAP_SHA3    (1 << 17)
+#endif
+#ifndef HWCAP_SHA512
+#define HWCAP_SHA512  (1 << 21)
+// #pragma message("=== HWCAP_SHA512 define === ")
+#endif
     if (h & HWCAP_CRC32)  s += ":CRC32";
     if (h & HWCAP_SHA1)   s += ":SHA1";
     if (h & HWCAP_SHA2)   s += ":SHA2";
+    if (h & HWCAP_SHA3)   s += ":SHA3";
+    if (h & HWCAP_SHA512) s += ":SHA512";
     if (h & HWCAP_AES)    s += ":AES";
     if (h & HWCAP_ASIMD)  s += ":ASIMD";
     #elif defined(MY_CPU_ARM)
@@ -908,13 +980,18 @@ void GetSystemInfoText(AString &sRes)
       }
     }
     {
-      AString s;
-      GetCpuName_MultiLine(s);
+      AString s, registers;
+      GetCpuName_MultiLine(s, registers);
       if (!s.IsEmpty())
       {
         sRes += s;
         sRes.Add_LF();
       }
+      if (!registers.IsEmpty())
+      {
+        sRes += registers;
+        sRes.Add_LF();
+      }
     }
     /*
     #ifdef MY_CPU_X86_OR_AMD64
@@ -932,8 +1009,8 @@ void GetSystemInfoText(AString &sRes)
 }
 
 
-void GetCpuName_MultiLine(AString &s);
-void GetCpuName_MultiLine(AString &s)
+void GetCpuName_MultiLine(AString &s, AString &registers);
+void GetCpuName_MultiLine(AString &s, AString &registers)
 {
   CCpuName cpuName;
   cpuName.Fill();
@@ -945,6 +1022,10 @@ void GetCpuName_MultiLine(AString &s)
     s.Add_LF();
     s += s2;
   }
+  registers.Empty();
+#ifdef Z7_SYS_INFO_SHOW_ARM64_REGS
+  cpuName.Get_Registers(registers);
+#endif
 }
 
 
diff --git a/CPP/Windows/SystemInfo.h b/CPP/Windows/SystemInfo.h
index c2e2e3b..4601685 100644
--- a/CPP/Windows/SystemInfo.h
+++ b/CPP/Windows/SystemInfo.h
@@ -6,7 +6,7 @@
 #include "../Common/MyString.h"
 
 
-void GetCpuName_MultiLine(AString &s);
+void GetCpuName_MultiLine(AString &s, AString &registers);
 
 void GetOsInfoText(AString &sRes);
 void GetSystemInfoText(AString &s);
diff --git a/CPP/Windows/Thread.h b/CPP/Windows/Thread.h
index d72f64c..75c1616 100644
--- a/CPP/Windows/Thread.h
+++ b/CPP/Windows/Thread.h
@@ -26,8 +26,10 @@ public:
     { return Thread_Create_With_Affinity(&thread, startAddress, param, affinity); }
   WRes Create_With_CpuSet(THREAD_FUNC_TYPE startAddress, LPVOID param, const CCpuSet *cpuSet)
     { return Thread_Create_With_CpuSet(&thread, startAddress, param, cpuSet); }
-  
-  #ifdef _WIN32
+ 
+#ifdef _WIN32
+  WRes Create_With_Group(THREAD_FUNC_TYPE startAddress, LPVOID param, unsigned group, CAffinityMask affinity = 0)
+    { return Thread_Create_With_Group(&thread, startAddress, param, group, affinity); }
   operator HANDLE() { return thread; }
   void Attach(HANDLE handle) { thread = handle; }
   HANDLE Detach() { HANDLE h = thread; thread = NULL; return h; }
@@ -36,7 +38,7 @@ public:
   bool Terminate(DWORD exitCode) { return BOOLToBool(::TerminateThread(thread, exitCode)); }
   int GetPriority() { return ::GetThreadPriority(thread); }
   bool SetPriority(int priority) { return BOOLToBool(::SetThreadPriority(thread, priority)); }
-  #endif
+#endif
 };
 
 }
diff --git a/CPP/Windows/TimeUtils.cpp b/CPP/Windows/TimeUtils.cpp
index bbd79ba..4e3bc59 100644
--- a/CPP/Windows/TimeUtils.cpp
+++ b/CPP/Windows/TimeUtils.cpp
@@ -258,8 +258,9 @@ bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
       FreeBSD 11.0, NetBSD 7.1, OpenBSD 6.0,
       Minix 3.1.8, AIX 7.1, HP-UX 11.31, IRIX 6.5, Solaris 11.3,
       Cygwin 2.9, mingw, MSVC 14, Android 9.0.
+  Android NDK defines TIME_UTC but doesn't have the timespec_get().
 */
-#if defined(TIME_UTC)
+#if defined(TIME_UTC) && !defined(__ANDROID__)
 #define ZIP7_USE_timespec_get
 // #pragma message("ZIP7_USE_timespec_get")
 #elif defined(CLOCK_REALTIME)
diff --git a/DOC/7zip.wxs b/DOC/7zip.wxs
index f41b393..703e22e 100644
--- a/DOC/7zip.wxs
+++ b/DOC/7zip.wxs
@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 
-<?define VerMajor = "24" ?>
-<?define VerMinor = "08" ?>
+<?define VerMajor = "25" ?>
+<?define VerMinor = "01" ?>
 <?define VerBuild = "00" ?>
 <?define MmVer = "$(var.VerMajor).$(var.VerMinor)" ?>
 <?define MmHex = "$(var.VerMajor)$(var.VerMinor)" ?>
diff --git a/DOC/License.txt b/DOC/License.txt
index 8917dfc..bbb56a3 100644
--- a/DOC/License.txt
+++ b/DOC/License.txt
@@ -3,7 +3,7 @@
   License for use and distribution
   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-  7-Zip Copyright (C) 1999-2024 Igor Pavlov.
+  7-Zip Copyright (C) 1999-2025 Igor Pavlov.
 
   The licenses for files are:
 
@@ -58,7 +58,7 @@ BSD 3-clause License in 7-Zip code
 
   Copyright (c) 2015-2016, Apple Inc. All rights reserved.
   Copyright (c) Facebook, Inc. All rights reserved.
-  Copyright (c) 2023-2024 Igor Pavlov.
+  Copyright (c) 2023-2025 Igor Pavlov.
 
 Text of the "BSD 3-clause License"
 ----------------------------------
@@ -102,7 +102,7 @@ BSD 2-clause License in 7-Zip code
   XXH64 code in 7-Zip was derived from the original XXH64 code developed by Yann Collet.
 
   Copyright (c) 2012-2021 Yann Collet.
-  Copyright (c) 2023-2024 Igor Pavlov.
+  Copyright (c) 2023-2025 Igor Pavlov.
 
 Text of the "BSD 2-clause License"
 ----------------------------------
diff --git a/DOC/readme.txt b/DOC/readme.txt
index 6d04c5a..cc89a39 100644
--- a/DOC/readme.txt
+++ b/DOC/readme.txt
@@ -1,9 +1,9 @@
-7-Zip 24.07 Sources
+7-Zip 25.01 Sources
 -------------------
 
 7-Zip is a file archiver for Windows. 
 
-7-Zip Copyright (C) 1999-2024 Igor Pavlov.
+7-Zip Copyright (C) 1999-2025 Igor Pavlov.
 
 
 License Info
@@ -73,8 +73,8 @@ All final 7-Zip binaries are compiled via makefiles, that provide best
 optimization options.
 
 
-How to compile with makefile
-----------------------------
+How to compile with makefile in Windows
+---------------------------------------
 
 Some macronames can be defined for compiling with makefile:
 
@@ -88,6 +88,23 @@ MY_DYNAMIC_LINK
   for dynamic linking to the run-time library (msvcrt.dll). 
   The default makefile option is static linking to the run-time library.
 
+To compile all 7-Zip files for x64 with Visual Studio 2022,
+use the following command sequence:
+
+  cd SRC\CPP\7zip
+  %comspec% /k "C:\Program Files\VS2022\VC\Auxiliary\Build\vcvars64.bat"
+  nmake
+
+You can use another "vcvars*.bat" files from "VS2022\VC\Auxiliary\Build" directory
+to compile for other platforms:
+  vcvars64.bat
+  vcvarsamd64_arm64.bat
+  vcvarsamd64_x86.bat
+
+Also you can compile single binary from directory with related project.
+For example, to compile 7za.exe, use the following command sequence:
+  cd SRC\CPP\7zip\Bundles\Alone\
+  nmake
 
 
 Compiling 7-Zip for Unix/Linux
@@ -100,12 +117,14 @@ So if you compile the version with Assembeler code, you will get faster 7-Zip bi
 7-Zip's assembler code uses the following syntax for different platforms:
 
 1) x86 and x86-64 (AMD64): MASM syntax. 
-   There are 2 programs that supports MASM syntax in Linux.
-'    'Asmc Macro Assembler and JWasm. But JWasm now doesn't support some 
+   Now there are 3 programs that supports MASM syntax in Linux.
+'    'Asmc Macro Assembler, JWasm, and UASM. Note that JWasm now doesn't support some 
       cpu instructions used in 7-Zip.
-   So you must install Asmc Macro Assembler in Linux, if you want to compile fastest version
-   of 7-Zip  x86 and x86-64:
+   So you must install Asmc Macro Assembler in Linux or UASM, if you want to compile 
+   fastest version of 7-Zip  x86 and x86-64:
      https://github.com/nidud/asmc
+     https://github.com/Terraspace/UASM
+
 
 2) arm64: GNU assembler for ARM64 with preprocessor. 
    That systax is supported by GCC and CLANG for ARM64.
@@ -155,6 +174,13 @@ USE_JWASM=1
   Note that JWasm doesn't support AES instructions. So AES code from C version AesOpt.c 
   will be used instead of assembler code from AesOpt.asm.
 
+If you want to use UASM for x86-64 compiling, you can change 7zip_gcc.mak, 
+or send IS_X64=1 USE_ASM=1 MY_ASM="$UASM" to make command calling:
+  UASM="$PWD/GccUnixR/uasm"
+  cd "7zip-src/CPP/7zip/Bundles/Alone2"
+  make -f makefile.gcc -j IS_X64=1 USE_ASM=1 MY_ASM="$UASM"
+
+
 DISABLE_RAR=1
   removes whole RAR related code from compilation.
 
diff --git a/DOC/src-history.txt b/DOC/src-history.txt
index 1653c07..48c9647 100644
--- a/DOC/src-history.txt
+++ b/DOC/src-history.txt
@@ -1,6 +1,51 @@
 HISTORY of the 7-Zip source code
 --------------------------------
 
+25.01          2025-08-03
+-------------------------
+- The code for handling symbolic links has been changed 
+  to provide greater security when extracting files from archives.
+  Command line switch -snld20 can be used to bypass default security 
+  checks when creating symbolic links.
+
+
+25.00          2025-07-05
+-------------------------
+- 7-Zip for Windows can now use more than 64 CPU threads for compression
+  to zip/7z/xz archives and for the 7-Zip benchmark.
+  If there are more than one processor group in Windows (on systems with more than
+  64 cpu threads), 7-Zip distributes running CPU threads across different processor groups.
+- bzip2 compression speed was increased by 15-40%.
+- deflate (zip/gz) compression speed was increased by 1-3%.
+- improved support for zip, cpio and fat archives.
+- fixed some bugs and vulnerabilities.
+- the bug was fixed : CVE-2025-53816 : 7-Zip could work incorrectly for some incorrect RAR archives. 
+- the bug was fixed : CVE-2025-53817 : 7-Zip could crash for some incorrect COM (Compound File) archives. 
+
+
+24.09          2024-11-29
+-------------------------
+- The default dictionary size values for LZMA/LZMA2 compression methods were increased:
+         dictionary size   compression level
+  v24.08  v24.09  v24.09   
+          32-bit  64-bit    
+    8 MB   16 MB   16 MB   -mx4
+   16 MB   32 MB   32 MB   -mx5 : Normal
+   32 MB   64 MB   64 MB   -mx6
+   32 MB   64 MB  128 MB   -mx7 : Maximum
+   64 MB   64 MB  256 MB   -mx8
+   64 MB   64 MB  256 MB   -mx9 : Ultra
+  The default dictionary size values for 32-bit versions of LZMA/LZMA2 don't exceed 64 MB.
+- 7-Zip now can calculate the following hash checksums: SHA-512, SHA-384, SHA3-256 and MD5.
+- APM and HFS support was improved.
+- If an archive update operation uses a temporary archive folder and 
+  the archive is moved to the destination folder, 7-Zip shows the progress of moving 
+  the archive file, as this operation can take a long time if the archive is large.
+- The bug was fixed: 7-Zip File Manager didn't propagate Zone.Identifier stream
+  for extacted files from nested archives (if there is open archive inside another open archive).
+- Some bugs were fixed.
+
+
 24.08          2024-08-11
 -------------------------
 - The bug in 7-Zip 24.00-24.07 was fixed: