diff --git a/C/fast-lzma2/fast-lzma2.h b/C/fast-lzma2/fast-lzma2.h
index c58807f6..1ad31fe2 100644
--- a/C/fast-lzma2/fast-lzma2.h
+++ b/C/fast-lzma2/fast-lzma2.h
@@ -55,7 +55,7 @@ Introduction
 /*------   Version   ------*/
 #define FL2_VERSION_MAJOR    1
 #define FL2_VERSION_MINOR    0
-#define FL2_VERSION_RELEASE  0
+#define FL2_VERSION_RELEASE  1
 
 #define FL2_VERSION_NUMBER  (FL2_VERSION_MAJOR *100*100 + FL2_VERSION_MINOR *100 + FL2_VERSION_RELEASE)
 FL2LIB_API unsigned FL2LIB_CALL FL2_versionNumber(void);   /**< useful to check dll version */
diff --git a/C/fast-lzma2/fl2_compress.c b/C/fast-lzma2/fl2_compress.c
index dde6adca..0ffeab03 100644
--- a/C/fast-lzma2/fl2_compress.c
+++ b/C/fast-lzma2/fl2_compress.c
@@ -294,7 +294,7 @@ static size_t FL2_compressCurBlock_blocking(FL2_CCtx* const cctx, int const stre
     cctx->jobs[nbThreads - 1].block.end = cctx->curBlock.end;
 
     /* initialize to length 2 */
-    cctx->matchTable->progress = RMF_initTable(cctx->matchTable, cctx->curBlock.data, cctx->curBlock.end);
+    RMF_initTable(cctx->matchTable, cctx->curBlock.data, cctx->curBlock.end);
 
     if (cctx->canceled) {
         RMF_resetIncompleteBuild(cctx->matchTable);
@@ -666,7 +666,7 @@ FL2LIB_API size_t FL2LIB_CALL FL2_CCtx_setParameter(FL2_CCtx* cctx, FL2_cParamet
     case FL2_p_dictionarySize:
         CLAMPCHECK(value, FL2_DICTSIZE_MIN, FL2_DICTSIZE_MAX);
         cctx->params.rParams.dictionary_size = value;
-		break;
+        break;
 
     case FL2_p_overlapFraction:
         MAXCHECK(value, FL2_BLOCK_OVERLAP_MAX);
@@ -960,7 +960,7 @@ FL2LIB_API size_t FL2LIB_CALL FL2_copyCStreamOutput(FL2_CStream* fcs, FL2_outBuf
 
         fcs->outPos = 0;
     }
-	return 0;
+    return 0;
 }
 
 static size_t FL2_compressStream_input(FL2_CStream* fcs, FL2_inBuffer* input)
@@ -1066,7 +1066,7 @@ FL2LIB_API size_t FL2LIB_CALL FL2_getNextCompressedBuffer(FL2_CStream* fcs, FL2_
     cbuf->size = 0;
 
 #ifndef FL2_SINGLETHREAD
-	CHECK_F(FL2_waitCStream(fcs));
+    CHECK_F(FL2_waitCStream(fcs));
 #endif
 
     if (fcs->outThread < fcs->threadCount) {
diff --git a/C/fast-lzma2/lzma2_enc.c b/C/fast-lzma2/lzma2_enc.c
index 250ec2e0..da2e09b1 100644
--- a/C/fast-lzma2/lzma2_enc.c
+++ b/C/fast-lzma2/lzma2_enc.c
@@ -133,10 +133,10 @@ typedef struct
 {
     size_t table_size;
     unsigned prices[kNumPositionStatesMax][kLenNumSymbolsTotal];
-    Probability choice; /* low[0] is choice_2. Must be consecutive for speed */
-    Probability low[kNumPositionStatesMax << (kLenNumLowBits + 1)];
-    Probability high[kLenNumHighSymbols];
-} LengthStates;
+    LZMA2_prob choice; /* low[0] is choice_2. Must be consecutive for speed */
+    LZMA2_prob low[kNumPositionStatesMax << (kLenNumLowBits + 1)];
+    LZMA2_prob high[kLenNumHighSymbols];
+} LZMA2_lenStates;
 
 /* All probabilities for the encoder. This is a separate from the encoder object
  * so the state can be saved and restored in case a chunk is not compressible.
@@ -144,26 +144,26 @@ typedef struct
 typedef struct
 {
     /* Fields are ordered for speed */
-    LengthStates rep_len_states;
-    Probability is_rep0_long[kNumStates][kNumPositionStatesMax];
+    LZMA2_lenStates rep_len_states;
+    LZMA2_prob is_rep0_long[kNumStates][kNumPositionStatesMax];
 
     size_t state;
     U32 reps[kNumReps];
 
-    Probability is_match[kNumStates][kNumPositionStatesMax];
-    Probability is_rep[kNumStates];
-    Probability is_rep_G0[kNumStates];
-    Probability is_rep_G1[kNumStates];
-    Probability is_rep_G2[kNumStates];
+    LZMA2_prob is_match[kNumStates][kNumPositionStatesMax];
+    LZMA2_prob is_rep[kNumStates];
+    LZMA2_prob is_rep_G0[kNumStates];
+    LZMA2_prob is_rep_G1[kNumStates];
+    LZMA2_prob is_rep_G2[kNumStates];
 
-    LengthStates len_states;
+    LZMA2_lenStates len_states;
 
-    Probability dist_slot_encoders[kNumLenToPosStates][1 << kNumPosSlotBits];
-    Probability dist_align_encoders[1 << kNumAlignBits];
-    Probability dist_encoders[kNumFullDistances - kEndPosModelIndex];
+    LZMA2_prob dist_slot_encoders[kNumLenToPosStates][1 << kNumPosSlotBits];
+    LZMA2_prob dist_align_encoders[1 << kNumAlignBits];
+    LZMA2_prob dist_encoders[kNumFullDistances - kEndPosModelIndex];
 
-    Probability literal_probs[(kNumLiterals * kNumLitTables) << kLcLpMax];
-} EncoderStates;
+    LZMA2_prob literal_probs[(kNumLiterals * kNumLitTables) << kLcLpMax];
+} LZMA2_encStates;
 
 /* 
  * Linked list item for optimal parsing
@@ -178,7 +178,7 @@ typedef struct
     unsigned len;
     U32 dist;
     U32 reps[kNumReps];
-} OptimalNode;
+} LZMA2_node;
 
 #define MARK_LITERAL(node) (node).dist = kNullDist; (node).extra = 0;
 #define MARK_SHORT_REP(node) (node).dist = 0; (node).extra = 0;
@@ -189,7 +189,7 @@ typedef struct
 typedef struct {
     S32 table_3[1 << kHash3Bits];
     S32 hash_chain_3[1];
-} HashChains;
+} LZMA2_hc3;
 
 /*
  * LZMA2 encoder.
@@ -206,13 +206,13 @@ struct LZMA2_ECtx_s
     unsigned match_cycles;
     FL2_strategy strategy;
 
-    RangeEncoder rc;
+    RC_encoder rc;
     /* Finish writing the chunk at this size */
     size_t chunk_size;
     /* Don't encode a symbol beyond this limit (used by fast mode) */
     size_t chunk_limit;
 
-    EncoderStates states;
+    LZMA2_encStates states;
 
     unsigned match_price_count;
     unsigned rep_len_price_count;
@@ -225,9 +225,9 @@ struct LZMA2_ECtx_s
     RMF_match matches[kMatchesMax];
     size_t match_count;
 
-    OptimalNode opt_buf[kOptimizerBufferSize];
+    LZMA2_node opt_buf[kOptimizerBufferSize];
 
-    HashChains* hash_buf;
+    LZMA2_hc3* hash_buf;
     ptrdiff_t chain_mask_2;
     ptrdiff_t chain_mask_3;
     ptrdiff_t hash_dict_3;
@@ -319,7 +319,7 @@ static unsigned LZMA_getRepMatch0Price(LZMA2_ECtx *const enc, size_t const len,
         + GET_PRICE_1(rep0_long_prob);
 }
 
-static unsigned LZMA_getLiteralPriceMatched(const Probability *const prob_table, U32 symbol, unsigned match_byte)
+static unsigned LZMA_getLiteralPriceMatched(const LZMA2_prob *const prob_table, U32 symbol, unsigned match_byte)
 {
     unsigned price = 0;
     unsigned offs = 0x100;
@@ -334,12 +334,12 @@ static unsigned LZMA_getLiteralPriceMatched(const Probability *const prob_table,
 }
 
 HINT_INLINE
-void LZMA_encodeLiteral(LZMA2_ECtx *const enc, size_t const index, U32 symbol, unsigned const prev_symbol)
+void LZMA_encodeLiteral(LZMA2_ECtx *const enc, size_t const pos, U32 symbol, unsigned const prev_symbol)
 {
-    RC_encodeBit0(&enc->rc, &enc->states.is_match[enc->states.state][index & enc->pos_mask]);
+    RC_encodeBit0(&enc->rc, &enc->states.is_match[enc->states.state][pos & enc->pos_mask]);
     enc->states.state = LIT_NEXT_STATE(enc->states.state);
 
-    Probability* const prob_table = LITERAL_PROBS(enc, index, prev_symbol);
+    LZMA2_prob* const prob_table = LITERAL_PROBS(enc, pos, prev_symbol);
     symbol |= 0x100;
     do {
         RC_encodeBit(&enc->rc, prob_table + (symbol >> 8), symbol & (1 << 7));
@@ -348,13 +348,13 @@ void LZMA_encodeLiteral(LZMA2_ECtx *const enc, size_t const index, U32 symbol, u
 }
 
 HINT_INLINE
-void LZMA_encodeLiteralMatched(LZMA2_ECtx *const enc, const BYTE* const data_block, size_t const index, U32 symbol)
+void LZMA_encodeLiteralMatched(LZMA2_ECtx *const enc, const BYTE* const data_block, size_t const pos, U32 symbol)
 {
-    RC_encodeBit0(&enc->rc, &enc->states.is_match[enc->states.state][index & enc->pos_mask]);
+    RC_encodeBit0(&enc->rc, &enc->states.is_match[enc->states.state][pos & enc->pos_mask]);
     enc->states.state = LIT_NEXT_STATE(enc->states.state);
 
-    unsigned match_symbol = data_block[index - enc->states.reps[0] - 1];
-    Probability* const prob_table = LITERAL_PROBS(enc, index, data_block[index - 1]);
+    unsigned match_symbol = data_block[pos - enc->states.reps[0] - 1];
+    LZMA2_prob* const prob_table = LITERAL_PROBS(enc, pos, data_block[pos - 1]);
     unsigned offset = 0x100;
     symbol |= 0x100;
     do {
@@ -367,19 +367,19 @@ void LZMA_encodeLiteralMatched(LZMA2_ECtx *const enc, const BYTE* const data_blo
 }
 
 HINT_INLINE
-void LZMA_encodeLiteralBuf(LZMA2_ECtx *const enc, const BYTE* const data_block, size_t const index)
+void LZMA_encodeLiteralBuf(LZMA2_ECtx *const enc, const BYTE* const data_block, size_t const pos)
 {
-    U32 const symbol = data_block[index];
+    U32 const symbol = data_block[pos];
     if (IS_LIT_STATE(enc->states.state)) {
-        unsigned const prev_symbol = data_block[index - 1];
-        LZMA_encodeLiteral(enc, index, symbol, prev_symbol);
+        unsigned const prev_symbol = data_block[pos - 1];
+        LZMA_encodeLiteral(enc, pos, symbol, prev_symbol);
     }
     else {
-        LZMA_encodeLiteralMatched(enc, data_block, index, symbol);
+        LZMA_encodeLiteralMatched(enc, data_block, pos, symbol);
     }
 }
 
-static void LZMA_lengthStates_SetPrices(const Probability *probs, U32 start_price, unsigned *prices)
+static void LZMA_lengthStates_SetPrices(const LZMA2_prob *probs, U32 start_price, unsigned *prices)
 {
     for (size_t i = 0; i < 8; i += 2) {
         U32 prob = probs[4 + (i >> 1)];
@@ -391,7 +391,7 @@ static void LZMA_lengthStates_SetPrices(const Probability *probs, U32 start_pric
 }
 
 FORCE_NOINLINE
-static void LZMA_lengthStates_updatePrices(LZMA2_ECtx *const enc, LengthStates* const ls)
+static void LZMA_lengthStates_updatePrices(LZMA2_ECtx *const enc, LZMA2_lenStates* const ls)
 {
     U32 b;
 
@@ -403,7 +403,7 @@ static void LZMA_lengthStates_updatePrices(LZMA2_ECtx *const enc, LengthStates*
         c = b + GET_PRICE_0(ls->low[0]);
         for (size_t pos_state = 0; pos_state <= enc->pos_mask; pos_state++) {
             unsigned *const prices = ls->prices[pos_state];
-            const Probability *const probs = ls->low + (pos_state << (1 + kLenNumLowBits));
+            const LZMA2_prob *const probs = ls->low + (pos_state << (1 + kLenNumLowBits));
             LZMA_lengthStates_SetPrices(probs, a, prices);
             LZMA_lengthStates_SetPrices(probs + kLenNumLowSymbols, c, prices + kLenNumLowSymbols);
         }
@@ -412,7 +412,7 @@ static void LZMA_lengthStates_updatePrices(LZMA2_ECtx *const enc, LengthStates*
     size_t i = ls->table_size;
 
     if (i > kLenNumLowSymbols * 2) {
-        const Probability *const probs = ls->high;
+        const LZMA2_prob *const probs = ls->high;
         unsigned *const prices = ls->prices[0] + kLenNumLowSymbols * 2;
         i = (i - (kLenNumLowSymbols * 2 - 1)) >> 1;
         b += GET_PRICE_1(ls->low[0]);
@@ -439,7 +439,7 @@ static void LZMA_lengthStates_updatePrices(LZMA2_ECtx *const enc, LengthStates*
 
 /* Rare enough that not inlining is faster overall */
 FORCE_NOINLINE
-static void LZMA_encodeLength_MidHigh(LZMA2_ECtx *const enc, LengthStates* const len_prob_table, unsigned const len, size_t const pos_state)
+static void LZMA_encodeLength_MidHigh(LZMA2_ECtx *const enc, LZMA2_lenStates* const len_prob_table, unsigned const len, size_t const pos_state)
 {
     RC_encodeBit1(&enc->rc, &len_prob_table->choice);
     if (len < kLenNumLowSymbols * 2) {
@@ -453,7 +453,7 @@ static void LZMA_encodeLength_MidHigh(LZMA2_ECtx *const enc, LengthStates* const
 }
 
 HINT_INLINE
-void LZMA_encodeLength(LZMA2_ECtx *const enc, LengthStates* const len_prob_table, unsigned len, size_t const pos_state)
+void LZMA_encodeLength(LZMA2_ECtx *const enc, LZMA2_lenStates* const len_prob_table, unsigned len, size_t const pos_state)
 {
     len -= kMatchLenMin;
     if (len < kLenNumLowSymbols) {
@@ -580,22 +580,22 @@ size_t LZMA_encodeChunkFast(LZMA2_ECtx *const enc,
     FL2_dataBlock const block,
     FL2_matchTable* const tbl,
     int const struct_tbl,
-    size_t index,
+    size_t pos,
     size_t const uncompressed_end)
 {
     size_t const pos_mask = enc->pos_mask;
-    size_t prev = index;
+    size_t prev = pos;
     unsigned const search_depth = tbl->params.depth;
 
-    while (index < uncompressed_end && enc->rc.out_index < enc->chunk_size) {
+    while (pos < uncompressed_end && enc->rc.out_index < enc->chunk_size) {
         size_t max_len;
         const BYTE* data;
         /* Table of distance restrictions for short matches */
         static const U32 max_dist_table[] = { 0, 0, 0, 1 << 6, 1 << 14 };
         /* Get a match from the table, extended to its full length */
-        RMF_match best_match = RMF_getMatch(block, tbl, search_depth, struct_tbl, index);
+        RMF_match best_match = RMF_getMatch(block, tbl, search_depth, struct_tbl, pos);
         if (best_match.length < kMatchLenMin) {
-            ++index;
+            ++pos;
             continue;
         }
         /* Use if near enough */
@@ -604,8 +604,8 @@ size_t LZMA_encodeChunkFast(LZMA2_ECtx *const enc,
         else
             best_match.length = 0;
 
-        max_len = MIN(kMatchLenMax, block.end - index);
-        data = block.data + index;
+        max_len = MIN(kMatchLenMax, block.end - pos);
+        data = block.data + pos;
 
         RMF_match best_rep = { 0, 0 };
         RMF_match rep_match;
@@ -643,11 +643,11 @@ size_t LZMA_encodeChunkFast(LZMA2_ECtx *const enc,
         }
 
         if (best_match.length < kMatchLenMin) {
-            ++index;
+            ++pos;
             continue;
         }
 
-        for (size_t next = index + 1; best_match.length < kMatchLenMax && next < uncompressed_end; ++next) {
+        for (size_t next = pos + 1; best_match.length < kMatchLenMax && next < uncompressed_end; ++next) {
             /* lazy matching scheme from ZSTD */
             RMF_match next_match = RMF_getNextMatch(block, tbl, search_depth, struct_tbl, next);
             if (next_match.length >= kMatchLenMin) {
@@ -669,7 +669,7 @@ size_t LZMA_encodeChunkFast(LZMA2_ECtx *const enc,
                     if (gain2 > gain1) {
                         DEBUGLOG(7, "Replace match (%u, %u) with rep (%u, %u)", best_match.length, best_match.dist, best_rep.length, best_rep.dist);
                         best_match = best_rep;
-                        index = next;
+                        pos = next;
                     }
                 }
                 if (next_match.length >= 3 && next_match.dist != best_match.dist) {
@@ -679,7 +679,7 @@ size_t LZMA_encodeChunkFast(LZMA2_ECtx *const enc,
                         DEBUGLOG(7, "Replace match (%u, %u) with match (%u, %u)", best_match.length, best_match.dist, next_match.length, next_match.dist + kNumReps);
                         best_match = next_match;
                         best_match.dist += kNumReps;
-                        index = next;
+                        pos = next;
                         continue;
                     }
                 }
@@ -712,7 +712,7 @@ size_t LZMA_encodeChunkFast(LZMA2_ECtx *const enc,
                 if (gain2 > gain1) {
                     DEBUGLOG(7, "Replace match (%u, %u) with rep (%u, %u)", best_match.length, best_match.dist, best_rep.length, best_rep.dist);
                     best_match = best_rep;
-                    index = next;
+                    pos = next;
                 }
             }
             if (next_match.dist != best_match.dist) {
@@ -722,7 +722,7 @@ size_t LZMA_encodeChunkFast(LZMA2_ECtx *const enc,
                     DEBUGLOG(7, "Replace match (%u, %u) with match (%u, %u)", best_match.length, best_match.dist, next_match.length, next_match.dist + kNumReps);
                     best_match = next_match;
                     best_match.dist += kNumReps;
-                    index = next;
+                    pos = next;
                     continue;
                 }
             }
@@ -730,9 +730,9 @@ size_t LZMA_encodeChunkFast(LZMA2_ECtx *const enc,
             break;
         }
 _encode:
-        assert(index + best_match.length <= block.end);
+        assert(pos + best_match.length <= block.end);
 
-        while (prev < index) {
+        while (prev < pos) {
             if (enc->rc.out_index >= enc->chunk_limit)
                 return prev;
 
@@ -748,18 +748,18 @@ _encode:
 
         if(best_match.length >= kMatchLenMin) {
             if (best_match.dist >= kNumReps) {
-                LZMA_encodeNormalMatch(enc, best_match.length, best_match.dist - kNumReps, index & pos_mask);
-                index += best_match.length;
-                prev = index;
+                LZMA_encodeNormalMatch(enc, best_match.length, best_match.dist - kNumReps, pos & pos_mask);
+                pos += best_match.length;
+                prev = pos;
             }
             else {
-                LZMA_encodeRepMatchLong(enc, best_match.length, best_match.dist, index & pos_mask);
-                index += best_match.length;
-                prev = index;
+                LZMA_encodeRepMatchLong(enc, best_match.length, best_match.dist, pos & pos_mask);
+                pos += best_match.length;
+                prev = pos;
             }
         }
     }
-    while (prev < index && enc->rc.out_index < enc->chunk_limit) {
+    while (prev < pos && enc->rc.out_index < enc->chunk_limit) {
         if (block.data[prev] != block.data[prev - enc->states.reps[0] - 1])
             LZMA_encodeLiteralBuf(enc, block.data, prev);
         else
@@ -773,7 +773,7 @@ _encode:
  * Reverse the direction of the linked list generated by the optimal parser
  */
 FORCE_NOINLINE
-static void LZMA_reverseOptimalChain(OptimalNode* const opt_buf, size_t cur)
+static void LZMA_reverseOptimalChain(LZMA2_node* const opt_buf, size_t cur)
 {
     unsigned len = (unsigned)opt_buf[cur].len;
     U32 dist = opt_buf[cur].dist;
@@ -814,9 +814,9 @@ static void LZMA_reverseOptimalChain(OptimalNode* const opt_buf, size_t cur)
     }
 }
 
-static unsigned LZMA_getLiteralPrice(LZMA2_ECtx *const enc, size_t const index, size_t const state, unsigned const prev_symbol, U32 symbol, unsigned const match_byte)
+static unsigned LZMA_getLiteralPrice(LZMA2_ECtx *const enc, size_t const pos, size_t const state, unsigned const prev_symbol, U32 symbol, unsigned const match_byte)
 {
-    const Probability* const prob_table = LITERAL_PROBS(enc, index, prev_symbol);
+    const LZMA2_prob* const prob_table = LITERAL_PROBS(enc, pos, prev_symbol);
     if (IS_LIT_STATE(state)) {
         unsigned price = 0;
         symbol |= 0x100;
@@ -850,7 +850,7 @@ static int LZMA_hashCreate(LZMA2_ECtx *const enc, unsigned const dictionary_bits
         free(enc->hash_buf);
 
     enc->hash_alloc_3 = (ptrdiff_t)1 << dictionary_bits_3;
-    enc->hash_buf = malloc(sizeof(HashChains) + (enc->hash_alloc_3 - 1) * sizeof(S32));
+    enc->hash_buf = malloc(sizeof(LZMA2_hc3) + (enc->hash_alloc_3 - 1) * sizeof(S32));
 
     if (enc->hash_buf == NULL)
         return 1;
@@ -879,34 +879,34 @@ int LZMA2_hashAlloc(LZMA2_ECtx *const enc, const FL2_lzma2Parameters* const opti
  */
 HINT_INLINE
 size_t LZMA_hashGetMatches(LZMA2_ECtx *const enc, FL2_dataBlock const block,
-    ptrdiff_t const index,
+    ptrdiff_t const pos,
     size_t const length_limit,
     RMF_match const match)
 {
     ptrdiff_t const hash_dict_3 = enc->hash_dict_3;
     const BYTE* data = block.data;
-    HashChains* const tbl = enc->hash_buf;
+    LZMA2_hc3* const tbl = enc->hash_buf;
     ptrdiff_t const chain_mask_3 = enc->chain_mask_3;
 
     enc->match_count = 0;
-    enc->hash_prev_index = MAX(enc->hash_prev_index, index - hash_dict_3);
+    enc->hash_prev_index = MAX(enc->hash_prev_index, pos - hash_dict_3);
     /* Update hash tables and chains for any positions that were skipped */
-    while (++enc->hash_prev_index < index) {
+    while (++enc->hash_prev_index < pos) {
         size_t hash = GET_HASH_3(data + enc->hash_prev_index);
         tbl->hash_chain_3[enc->hash_prev_index & chain_mask_3] = tbl->table_3[hash];
         tbl->table_3[hash] = (S32)enc->hash_prev_index;
     }
-    data += index;
+    data += pos;
 
     size_t const hash = GET_HASH_3(data);
     ptrdiff_t const first_3 = tbl->table_3[hash];
-    tbl->table_3[hash] = (S32)index;
+    tbl->table_3[hash] = (S32)pos;
 
     size_t max_len = 2;
 
     if (first_3 >= 0) {
         int cycles = enc->match_cycles;
-        ptrdiff_t const end_index = index - (((ptrdiff_t)match.dist < hash_dict_3) ? match.dist : hash_dict_3);
+        ptrdiff_t const end_index = pos - (((ptrdiff_t)match.dist < hash_dict_3) ? match.dist : hash_dict_3);
         ptrdiff_t match_3 = first_3;
         if (match_3 >= end_index) {
             do {
@@ -915,7 +915,7 @@ size_t LZMA_hashGetMatches(LZMA2_ECtx *const enc, FL2_dataBlock const block,
                 size_t len_test = ZSTD_count(data + 1, data_2 + 1, data + length_limit) + 1;
                 if (len_test > max_len) {
                     enc->matches[enc->match_count].length = (U32)len_test;
-                    enc->matches[enc->match_count].dist = (U32)(index - match_3 - 1);
+                    enc->matches[enc->match_count].dist = (U32)(pos - match_3 - 1);
                     ++enc->match_count;
                     max_len = len_test;
                     if (len_test >= length_limit)
@@ -927,7 +927,7 @@ size_t LZMA_hashGetMatches(LZMA2_ECtx *const enc, FL2_dataBlock const block,
             } while (match_3 >= end_index);
         }
     }
-    tbl->hash_chain_3[index & chain_mask_3] = (S32)first_3;
+    tbl->hash_chain_3[pos & chain_mask_3] = (S32)first_3;
     if ((unsigned)max_len < match.length) {
         /* Insert the match from the RMF */
         enc->matches[enc->match_count] = match;
@@ -948,16 +948,16 @@ size_t LZMA_hashGetMatches(LZMA2_ECtx *const enc, FL2_dataBlock const block,
 FORCE_INLINE_TEMPLATE
 size_t LZMA_optimalParse(LZMA2_ECtx* const enc, FL2_dataBlock const block,
     RMF_match match,
-    size_t const index,
+    size_t const pos,
     size_t const cur,
     size_t len_end,
     int const is_hybrid,
     U32* const reps)
 {
-    OptimalNode* const cur_opt = &enc->opt_buf[cur];
+    LZMA2_node* const cur_opt = &enc->opt_buf[cur];
     size_t const pos_mask = enc->pos_mask;
-    size_t const pos_state = (index & pos_mask);
-    const BYTE* const data = block.data + index;
+    size_t const pos_state = (pos & pos_mask);
+    const BYTE* const data = block.data + pos;
     size_t const fast_length = enc->fast_length;
     size_t prev_index = cur - cur_opt->len;
     size_t state;
@@ -983,7 +983,7 @@ size_t LZMA_optimalParse(LZMA2_ECtx* const enc, FL2_dataBlock const block,
             state = enc->opt_buf[prev_index].state;
             state = MATCH_NEXT_STATE(state) + (dist < kNumReps);
         }
-        const OptimalNode *const prev_opt = &enc->opt_buf[prev_index];
+        const LZMA2_node *const prev_opt = &enc->opt_buf[prev_index];
         if (dist < kNumReps) {
             /* Move the chosen rep to the front.
              * The table is hideous but faster than branching :D */
@@ -1008,12 +1008,12 @@ size_t LZMA_optimalParse(LZMA2_ECtx* const enc, FL2_dataBlock const block,
     }
     cur_opt->state = state;
     memcpy(cur_opt->reps, reps, sizeof(cur_opt->reps));
-    Probability const is_rep_prob = enc->states.is_rep[state];
+    LZMA2_prob const is_rep_prob = enc->states.is_rep[state];
 
-    {   OptimalNode *const next_opt = &enc->opt_buf[cur + 1];
+    {   LZMA2_node *const next_opt = &enc->opt_buf[cur + 1];
         U32 const cur_price = cur_opt->price;
         U32 const next_price = next_opt->price;
-        Probability const is_match_prob = enc->states.is_match[state][pos_state];
+        LZMA2_prob const is_match_prob = enc->states.is_match[state][pos_state];
         unsigned const cur_byte = *data;
         unsigned const match_byte = *(data - reps[0] - 1);
        
@@ -1022,7 +1022,7 @@ size_t LZMA_optimalParse(LZMA2_ECtx* const enc, FL2_dataBlock const block,
         BYTE try_lit = cur_and_lit_price + kMinLitPrice / 2U <= next_price;
         if (try_lit) {
             /* cur_and_lit_price is used later for the literal + rep0 test */
-            cur_and_lit_price += LZMA_getLiteralPrice(enc, index, state, data[-1], cur_byte, match_byte);
+            cur_and_lit_price += LZMA_getLiteralPrice(enc, pos, state, data[-1], cur_byte, match_byte);
             /* Try literal */
             if (cur_and_lit_price < next_price) {
                 next_opt->price = cur_and_lit_price;
@@ -1043,7 +1043,7 @@ size_t LZMA_optimalParse(LZMA2_ECtx* const enc, FL2_dataBlock const block,
                 MARK_SHORT_REP(*next_opt);
             }
         }
-        bytes_avail = MIN(block.end - index, kOptimizerBufferSize - 1 - cur);
+        bytes_avail = MIN(block.end - pos, kOptimizerBufferSize - 1 - cur);
         if (bytes_avail < 2)
             return len_end;
 
@@ -1055,7 +1055,7 @@ size_t LZMA_optimalParse(LZMA2_ECtx* const enc, FL2_dataBlock const block,
             size_t len_test_2 = ZSTD_count(data + 1, data_2, data + 1 + limit);
             if (len_test_2 >= 2) {
                 size_t const state_2 = LIT_NEXT_STATE(state);
-                size_t const pos_state_next = (index + 1) & pos_mask;
+                size_t const pos_state_next = (pos + 1) & pos_mask;
                 U32 const next_rep_match_price = cur_and_lit_price +
                     GET_PRICE_1(enc->states.is_match[state_2][pos_state_next]) +
                     GET_PRICE_1(enc->states.is_rep[state_2]);
@@ -1092,7 +1092,7 @@ size_t LZMA_optimalParse(LZMA2_ECtx* const enc, FL2_dataBlock const block,
             /* Try rep match */
             do {
                 U32 const cur_and_len_price = cur_rep_price + enc->states.rep_len_states.prices[pos_state][len - kMatchLenMin];
-                OptimalNode *const opt = &enc->opt_buf[cur + len];
+                LZMA2_node *const opt = &enc->opt_buf[cur + len];
                 if (cur_and_len_price < opt->price) {
                     opt->price = cur_and_len_price;
                     opt->len = (unsigned)len;
@@ -1114,15 +1114,15 @@ size_t LZMA_optimalParse(LZMA2_ECtx* const enc, FL2_dataBlock const block,
                     data_2 + len_test + 3,
                     data + MIN(len_test + 1 + fast_length, bytes_avail)) + 2;
                 size_t state_2 = REP_NEXT_STATE(state);
-                size_t pos_state_next = (index + len_test) & pos_mask;
+                size_t pos_state_next = (pos + len_test) & pos_mask;
                 U32 rep_lit_rep_total_price =
                     cur_rep_price + enc->states.rep_len_states.prices[pos_state][len_test - kMatchLenMin]
                     + GET_PRICE_0(enc->states.is_match[state_2][pos_state_next])
-                    + LZMA_getLiteralPriceMatched(LITERAL_PROBS(enc, index + len_test, data[len_test - 1]),
+                    + LZMA_getLiteralPriceMatched(LITERAL_PROBS(enc, pos + len_test, data[len_test - 1]),
                         data[len_test], data_2[len_test]);
 
                 state_2 = kState_LitAfterRep;
-                pos_state_next = (index + len_test + 1) & pos_mask;
+                pos_state_next = (pos + len_test + 1) & pos_mask;
                 rep_lit_rep_total_price +=
                     GET_PRICE_1(enc->states.is_match[state_2][pos_state_next]) +
                     GET_PRICE_1(enc->states.is_rep[state_2]);
@@ -1157,7 +1157,7 @@ size_t LZMA_optimalParse(LZMA2_ECtx* const enc, FL2_dataBlock const block,
                 else 
                     cur_and_len_price += enc->dist_slot_prices[len_to_dist_state][dist_slot] + enc->align_prices[cur_dist & kAlignMask];
 
-                OptimalNode *const opt = &enc->opt_buf[cur + len_test];
+                LZMA2_node *const opt = &enc->opt_buf[cur + len_test];
                 if (cur_and_len_price < opt->price) {
                     opt->price = cur_and_len_price;
                     opt->len = (unsigned)len_test;
@@ -1179,7 +1179,7 @@ size_t LZMA_optimalParse(LZMA2_ECtx* const enc, FL2_dataBlock const block,
                 main_len = match.length;
             }
             else {
-                main_len = LZMA_hashGetMatches(enc, block, index, max_length, match);
+                main_len = LZMA_hashGetMatches(enc, block, pos, max_length, match);
             }
             ptrdiff_t match_index = enc->match_count - 1;
             len_end = MAX(len_end, cur + main_len);
@@ -1210,7 +1210,7 @@ size_t LZMA_optimalParse(LZMA2_ECtx* const enc, FL2_dataBlock const block,
 
                     BYTE const sub_len = len_test < enc->matches[match_index].length;
 
-                    OptimalNode *const opt = &enc->opt_buf[cur + len_test];
+                    LZMA2_node *const opt = &enc->opt_buf[cur + len_test];
                     if (cur_and_len_price < opt->price) {
                         opt->price = cur_and_len_price;
                         opt->len = (unsigned)len_test;
@@ -1225,10 +1225,10 @@ size_t LZMA_optimalParse(LZMA2_ECtx* const enc, FL2_dataBlock const block,
                         size_t const limit = MIN(rep_0_pos + fast_length, bytes_avail);
                         size_t const len_test_2 = ZSTD_count(data + rep_0_pos + 2, data_2 + rep_0_pos + 2, data + limit) + 2;
                         size_t state_2 = MATCH_NEXT_STATE(state);
-                        size_t pos_state_next = (index + len_test) & pos_mask;
+                        size_t pos_state_next = (pos + len_test) & pos_mask;
                         U32 match_lit_rep_total_price = cur_and_len_price +
                             GET_PRICE_0(enc->states.is_match[state_2][pos_state_next]) +
-                            LZMA_getLiteralPriceMatched(LITERAL_PROBS(enc, index + len_test, data[len_test - 1]),
+                            LZMA_getLiteralPriceMatched(LITERAL_PROBS(enc, pos + len_test, data[len_test - 1]),
                                 data[len_test], data_2[len_test]);
 
                         state_2 = kState_LitAfterMatch;
@@ -1287,19 +1287,19 @@ static void LZMA_initMatchesPos0(LZMA2_ECtx *const enc,
 FORCE_NOINLINE
 static size_t LZMA_initMatchesPos0Best(LZMA2_ECtx *const enc, FL2_dataBlock const block,
     RMF_match const match,
-    size_t const index,
+    size_t const pos,
     size_t start_len,
     unsigned const normal_match_price)
 {
     if (start_len <= match.length) {
         size_t main_len;
-        if (match.length < 3 || block.end - index < 4) {
+        if (match.length < 3 || block.end - pos < 4) {
             enc->matches[0] = match;
             enc->match_count = 1;
             main_len = match.length;
         }
         else {
-            main_len = LZMA_hashGetMatches(enc, block, index, MIN(block.end - index, enc->fast_length), match);
+            main_len = LZMA_hashGetMatches(enc, block, pos, MIN(block.end - pos, enc->fast_length), match);
         }
 
         ptrdiff_t start_match = 0;
@@ -1308,7 +1308,7 @@ static size_t LZMA_initMatchesPos0Best(LZMA2_ECtx *const enc, FL2_dataBlock cons
 
         enc->matches[start_match - 1].length = (U32)start_len - 1; /* Avoids an if..else branch in the loop. [-1] is ok */
 
-        size_t pos_state = index & enc->pos_mask;
+        size_t pos_state = pos & enc->pos_mask;
 
         for (ptrdiff_t match_index = enc->match_count - 1; match_index >= start_match; --match_index) {
             size_t len_test = enc->matches[match_index].length;
@@ -1348,12 +1348,12 @@ static size_t LZMA_initMatchesPos0Best(LZMA2_ECtx *const enc, FL2_dataBlock cons
 FORCE_INLINE_TEMPLATE
 size_t LZMA_initOptimizerPos0(LZMA2_ECtx *const enc, FL2_dataBlock const block,
     RMF_match const match,
-    size_t const index,
+    size_t const pos,
     int const is_hybrid,
     U32* const reps)
 {
-    size_t const max_length = MIN(block.end - index, kMatchLenMax);
-    const BYTE *const data = block.data + index;
+    size_t const max_length = MIN(block.end - pos, kMatchLenMax);
+    const BYTE *const data = block.data + pos;
     const BYTE *data_2;
     size_t rep_max_index = 0;
     size_t rep_lens[kNumReps];
@@ -1384,14 +1384,14 @@ size_t LZMA_initOptimizerPos0(LZMA2_ECtx *const enc, FL2_dataBlock const block,
     unsigned const cur_byte = *data;
     unsigned const match_byte = *(data - reps[0] - 1);
     size_t const state = enc->states.state;
-    size_t const pos_state = index & enc->pos_mask;
-    Probability const is_match_prob = enc->states.is_match[state][pos_state];
-    Probability const is_rep_prob = enc->states.is_rep[state];
+    size_t const pos_state = pos & enc->pos_mask;
+    LZMA2_prob const is_match_prob = enc->states.is_match[state][pos_state];
+    LZMA2_prob const is_rep_prob = enc->states.is_rep[state];
 
     enc->opt_buf[0].state = state;
     /* Set the price for literal */
     enc->opt_buf[1].price = GET_PRICE_0(is_match_prob) +
-        LZMA_getLiteralPrice(enc, index, state, data[-1], cur_byte, match_byte);
+        LZMA_getLiteralPrice(enc, pos, state, data[-1], cur_byte, match_byte);
     MARK_LITERAL(enc->opt_buf[1]);
 
     unsigned const match_price = GET_PRICE_1(is_match_prob);
@@ -1434,7 +1434,7 @@ size_t LZMA_initOptimizerPos0(LZMA2_ECtx *const enc, FL2_dataBlock const block,
     }
     else {
         /* Hybrid mode */
-        size_t main_len = LZMA_initMatchesPos0Best(enc, block, match, index, len, normal_match_price);
+        size_t main_len = LZMA_initMatchesPos0Best(enc, block, match, pos, len, normal_match_price);
         return MAX(main_len, rep_lens[rep_max_index]);
     }
 }
@@ -1464,16 +1464,16 @@ size_t LZMA_encodeOptimumSequence(LZMA2_ECtx *const enc, FL2_dataBlock const blo
         }
 
         /* Set everything up at position 0 */
-        size_t index = start_index;
+        size_t pos = start_index;
         U32 reps[kNumReps];
-        len_end = LZMA_initOptimizerPos0(enc, block, match, index, is_hybrid, reps);
+        len_end = LZMA_initOptimizerPos0(enc, block, match, pos, is_hybrid, reps);
         match.length = 0;
         size_t cur = 1;
 
         /* len_end == 0 if a match of fast_length was found */
         if (len_end > 0) {
-            ++index;
-            for (; cur < len_end; ++cur, ++index) {
+            ++pos;
+            for (; cur < len_end; ++cur, ++pos) {
                 /* Terminate if the farthest calculated price is too near the buffer end */
                 if (len_end >= kOptimizerBufferSize - kOptimizerEndSize) {
                     U32 price = enc->opt_buf[cur].price;
@@ -1498,18 +1498,18 @@ size_t LZMA_encodeOptimumSequence(LZMA2_ECtx *const enc, FL2_dataBlock const blo
                     U32 const price2 = enc->opt_buf[j].price;
                     if (price >= price2) {
                         price = price2;
-                        index += j - cur;
+                        pos += j - cur;
                         cur = j;
                         if (cur == len_end)
                             goto reverse;
                     }
                 }
 
-                match = RMF_getMatch(block, tbl, search_depth, struct_tbl, index);
+                match = RMF_getMatch(block, tbl, search_depth, struct_tbl, pos);
                 if (match.length >= enc->fast_length)
                     break;
 
-                len_end = LZMA_optimalParse(enc, block, match, index, cur, len_end, is_hybrid, reps);
+                len_end = LZMA_optimalParse(enc, block, match, pos, cur, len_end, is_hybrid, reps);
             }
 reverse:
             DEBUGLOG(6, "End optimal parse at %u", (U32)cur);
@@ -1555,7 +1555,7 @@ reverse:
 static void FORCE_NOINLINE LZMA_fillAlignPrices(LZMA2_ECtx *const enc)
 {
     unsigned i;
-    const Probability *const probs = enc->states.dist_align_encoders;
+    const LZMA2_prob *const probs = enc->states.dist_align_encoders;
     for (i = 0; i < kAlignTableSize / 2; i++) {
         U32 price = 0;
         unsigned sym = i;
@@ -1580,7 +1580,7 @@ static void FORCE_NOINLINE LZMA_fillDistancesPrices(LZMA2_ECtx *const enc)
         unsigned const dist_slot = distance_table[i];
         unsigned footer_bits = (dist_slot >> 1) - 1;
         size_t base = ((2 | (dist_slot & 1)) << footer_bits);
-        const Probability *probs = enc->states.dist_encoders + base * 2U;
+        const LZMA2_prob *probs = enc->states.dist_encoders + base * 2U;
         base += i;
         probs = probs - distance_table[base] - 1;
         U32 price = 0;
@@ -1604,7 +1604,7 @@ static void FORCE_NOINLINE LZMA_fillDistancesPrices(LZMA2_ECtx *const enc)
         size_t slot;
         size_t const dist_table_size2 = (enc->dist_price_table_size + 1) >> 1;
         U32 *const dist_slot_prices = enc->dist_slot_prices[lps];
-        const Probability *const probs = enc->states.dist_slot_encoders[lps];
+        const LZMA2_prob *const probs = enc->states.dist_slot_encoders[lps];
 
         for (slot = 0; slot < dist_table_size2; slot++) {
             /* dist_slot_prices[slot] = RcTree_GetPrice(encoder, kNumPosSlotBits, slot, p->ProbPrices); */
@@ -1652,7 +1652,7 @@ size_t LZMA_encodeChunkBest(LZMA2_ECtx *const enc,
     FL2_dataBlock const block,
     FL2_matchTable* const tbl,
     int const struct_tbl,
-    size_t index,
+    size_t pos,
     size_t const uncompressed_end)
 {
     unsigned const search_depth = tbl->params.depth;
@@ -1661,16 +1661,16 @@ size_t LZMA_encodeChunkBest(LZMA2_ECtx *const enc,
     LZMA_lengthStates_updatePrices(enc, &enc->states.len_states);
     LZMA_lengthStates_updatePrices(enc, &enc->states.rep_len_states);
 
-    while (index < uncompressed_end && enc->rc.out_index < enc->chunk_size)
+    while (pos < uncompressed_end && enc->rc.out_index < enc->chunk_size)
     {
-        RMF_match const match = RMF_getMatch(block, tbl, search_depth, struct_tbl, index);
+        RMF_match const match = RMF_getMatch(block, tbl, search_depth, struct_tbl, pos);
         if (match.length > 1) {
             /* Template-like inline function */
             if (enc->strategy == FL2_ultra) {
-                index = LZMA_encodeOptimumSequence(enc, block, tbl, struct_tbl, 1, index, uncompressed_end, match);
+                pos = LZMA_encodeOptimumSequence(enc, block, tbl, struct_tbl, 1, pos, uncompressed_end, match);
             }
             else {
-                index = LZMA_encodeOptimumSequence(enc, block, tbl, struct_tbl, 0, index, uncompressed_end, match);
+                pos = LZMA_encodeOptimumSequence(enc, block, tbl, struct_tbl, 0, pos, uncompressed_end, match);
             }
             if (enc->match_price_count >= kMatchRepriceFrequency) {
                 LZMA_fillAlignPrices(enc);
@@ -1683,20 +1683,20 @@ size_t LZMA_encodeChunkBest(LZMA2_ECtx *const enc,
             }
         }
         else {
-            if (block.data[index] != block.data[index - enc->states.reps[0] - 1]) {
-                LZMA_encodeLiteralBuf(enc, block.data, index);
-                ++index;
+            if (block.data[pos] != block.data[pos - enc->states.reps[0] - 1]) {
+                LZMA_encodeLiteralBuf(enc, block.data, pos);
+                ++pos;
             }
             else {
-                LZMA_encodeRepMatchShort(enc, index & enc->pos_mask);
-                ++index;
+                LZMA_encodeRepMatchShort(enc, pos & enc->pos_mask);
+                ++pos;
             }
         }
     }
-    return index;
+    return pos;
 }
 
-static void LZMA_lengthStates_Reset(LengthStates* const ls, unsigned const fast_length)
+static void LZMA_lengthStates_Reset(LZMA2_lenStates* const ls, unsigned const fast_length)
 {
     ls->choice = kProbInitValue;
 
@@ -1709,7 +1709,7 @@ static void LZMA_lengthStates_Reset(LengthStates* const ls, unsigned const fast_
     ls->table_size = fast_length + 1 - kMatchLenMin;
 }
 
-static void LZMA_encoderStates_Reset(EncoderStates* const es, unsigned const lc, unsigned const lp, unsigned fast_length)
+static void LZMA_encoderStates_Reset(LZMA2_encStates* const es, unsigned const lc, unsigned const lp, unsigned fast_length)
 {
     es->state = 0;
 
@@ -1731,7 +1731,7 @@ static void LZMA_encoderStates_Reset(EncoderStates* const es, unsigned const lc,
         es->literal_probs[i] = kProbInitValue;
 
     for (size_t i = 0; i < kNumLenToPosStates; ++i) {
-        Probability *probs = es->dist_slot_encoders[i];
+        LZMA2_prob *probs = es->dist_slot_encoders[i];
         for (size_t j = 0; j < (1 << kNumPosSlotBits); ++j)
             probs[j] = kProbInitValue;
     }
@@ -1775,7 +1775,7 @@ size_t LZMA2_encMemoryUsage(unsigned const chain_log, FL2_strategy const strateg
 {
     size_t size = sizeof(LZMA2_ECtx);
     if(strategy == FL2_ultra)
-        size += sizeof(HashChains) + (sizeof(U32) << chain_log) - sizeof(U32);
+        size += sizeof(LZMA2_hc3) + (sizeof(U32) << chain_log) - sizeof(U32);
     return size * thread_count;
 }
 
@@ -1837,16 +1837,16 @@ static BYTE LZMA2_isChunkIncompressible(const FL2_matchTable* const tbl,
 
 		if (tbl->is_struct) {
 			size_t prev_dist = 0;
-			for (size_t index = start; index < end; ) {
-				U32 const link = GetMatchLink(tbl->table, index);
+			for (size_t pos = start; pos < end; ) {
+				U32 const link = GetMatchLink(tbl->table, pos);
 				if (link == RADIX_NULL_LINK) {
-					++index;
+					++pos;
 					++count;
 					prev_dist = 0;
 				}
 				else {
-					size_t const length = GetMatchLength(tbl->table, index);
-					size_t const dist = index - GetMatchLink(tbl->table, index);
+					size_t const length = GetMatchLength(tbl->table, pos);
+					size_t const dist = pos - GetMatchLink(tbl->table, pos);
                     if (length > 4) {
                         /* Increase the cost if it's not the same match */
                         count += dist != prev_dist;
@@ -1855,33 +1855,33 @@ static BYTE LZMA2_isChunkIncompressible(const FL2_matchTable* const tbl,
                         /* Increment the cost for a short match. The cost is the entire length if it's too far */
                         count += (dist < max_dist_table[strategy][length]) ? 1 : length;
                     }
-					index += length;
+					pos += length;
 					prev_dist = dist;
 				}
-				if (count + terminator <= index)
+				if (count + terminator <= pos)
 					return 0;
 			}
 		}
 		else {
 			size_t prev_dist = 0;
-			for (size_t index = start; index < end; ) {
-				U32 const link = tbl->table[index];
+			for (size_t pos = start; pos < end; ) {
+				U32 const link = tbl->table[pos];
 				if (link == RADIX_NULL_LINK) {
-					++index;
+					++pos;
 					++count;
 					prev_dist = 0;
 				}
 				else {
 					size_t const length = link >> RADIX_LINK_BITS;
-					size_t const dist = index - (link & RADIX_LINK_MASK);
+					size_t const dist = pos - (link & RADIX_LINK_MASK);
 					if (length > 4)
 						count += dist != prev_dist;
 					else
 						count += (dist < max_dist_table[strategy][length]) ? 1 : length;
-					index += length;
+					pos += length;
 					prev_dist = dist;
 				}
-				if (count + terminator <= index)
+				if (count + terminator <= pos)
 					return 0;
 			}
 		}
@@ -1892,8 +1892,8 @@ static BYTE LZMA2_isChunkIncompressible(const FL2_matchTable* const tbl,
         U32 const avg = (U32)(chunk_size / 64U);
 
         memset(char_count, 0, sizeof(char_count));
-        for (size_t index = start; index < end; ++index)
-            char_count[block.data[index]] += 4;
+        for (size_t pos = start; pos < end; ++pos)
+            char_count[block.data[pos]] += 4;
         /* Sum the deviations */
         for (size_t i = 0; i < 256; ++i) {
             S32 delta = char_count[i] - avg;
@@ -1909,27 +1909,27 @@ static BYTE LZMA2_isChunkIncompressible(const FL2_matchTable* const tbl,
 static size_t LZMA2_encodeChunk(LZMA2_ECtx *const enc,
     FL2_matchTable* const tbl,
     FL2_dataBlock const block,
-    size_t const index, size_t const uncompressed_end)
+    size_t const pos, size_t const uncompressed_end)
 {
     /* Template-like inline functions */
     if (enc->strategy == FL2_fast) {
         if (tbl->is_struct) {
             return LZMA_encodeChunkFast(enc, block, tbl, 1,
-                index, uncompressed_end);
+                pos, uncompressed_end);
         }
         else {
             return LZMA_encodeChunkFast(enc, block, tbl, 0,
-                index, uncompressed_end);
+                pos, uncompressed_end);
         }
     }
     else {
         if (tbl->is_struct) {
             return LZMA_encodeChunkBest(enc, block, tbl, 1,
-                index, uncompressed_end);
+                pos, uncompressed_end);
         }
         else {
             return LZMA_encodeChunkBest(enc, block, tbl, 0,
-                index, uncompressed_end);
+                pos, uncompressed_end);
         }
     }
 }
@@ -1987,28 +1987,28 @@ size_t LZMA2_encode(LZMA2_ECtx *const enc,
     /* Limit the matches near the end of this slice to not exceed block.end */
     RMF_limitLengths(tbl, block.end);
 
-    for (size_t index = start; index < block.end;) {
+    for (size_t pos = start; pos < block.end;) {
         size_t header_size = (stream_prop >= 0) + (encode_properties ? kChunkHeaderSize + 1 : kChunkHeaderSize);
-        EncoderStates saved_states;
+        LZMA2_encStates saved_states;
         size_t next_index;
 
         RC_reset(&enc->rc);
         RC_setOutputBuffer(&enc->rc, out_dest + header_size);
 
         if (!incompressible) {
-            size_t cur = index;
-            size_t const end = (enc->strategy == FL2_fast) ? MIN(block.end, index + kMaxChunkUncompressedSize - kMatchLenMax + 1)
-                : MIN(block.end, index + kMaxChunkUncompressedSize - kOptimizerBufferSize + 2); /* last byte of opt_buf unused */
+            size_t cur = pos;
+            size_t const end = (enc->strategy == FL2_fast) ? MIN(block.end, pos + kMaxChunkUncompressedSize - kMatchLenMax + 1)
+                : MIN(block.end, pos + kMaxChunkUncompressedSize - kOptimizerBufferSize + 2); /* last byte of opt_buf unused */
 
             /* Copy states in case chunk is incompressible */
             saved_states = enc->states;
 
-            if (index == 0) {
+            if (pos == 0) {
                 /* First byte of the dictionary */
                 LZMA_encodeLiteral(enc, 0, block.data[0], 0);
                 ++cur;
             }
-            if (index == start) {
+            if (pos == start) {
                 /* After kTempMinOutput bytes we can write data to the match table because the */
                 /* compressed data will never catch up with the table position being read. */
                 cur = LZMA2_encodeChunk(enc, tbl, block, cur, end);
@@ -2029,10 +2029,10 @@ size_t LZMA2_encode(LZMA2_ECtx *const enc,
             RC_flush(&enc->rc);
         }
         else {
-            next_index = MIN(index + kChunkSize, block.end);
+            next_index = MIN(pos + kChunkSize, block.end);
         }
         size_t compressed_size = enc->rc.out_index;
-        size_t uncompressed_size = next_index - index;
+        size_t uncompressed_size = next_index - pos;
 
         if (compressed_size > kMaxChunkCompressedSize || uncompressed_size > kMaxChunkUncompressedSize)
             return FL2_ERROR(internal);
@@ -2050,10 +2050,10 @@ size_t LZMA2_encode(LZMA2_ECtx *const enc,
         if (incompressible || uncompressed_size + 3 <= compressed_size + header_size) {
             DEBUGLOG(6, "Storing chunk : was %u => %u", (unsigned)uncompressed_size, (unsigned)compressed_size);
 
-            header[0] = (index == 0) ? kChunkUncompressedDictReset : kChunkUncompressed;
+            header[0] = (pos == 0) ? kChunkUncompressedDictReset : kChunkUncompressed;
 
             /* Copy uncompressed data into the output */
-            memcpy(header + 3, block.data + index, uncompressed_size);
+            memcpy(header + 3, block.data + pos, uncompressed_size);
 
             compressed_size = uncompressed_size;
             header_size = 3 + (header - out_dest);
@@ -2065,7 +2065,7 @@ size_t LZMA2_encode(LZMA2_ECtx *const enc,
         else {
             DEBUGLOG(6, "Compressed chunk : %u => %u", (unsigned)uncompressed_size, (unsigned)compressed_size);
 
-            if (index == 0)
+            if (pos == 0)
                 header[0] = kChunkCompressedFlag | kChunkAllReset;
             else if (encode_properties)
                 header[0] = kChunkCompressedFlag | kChunkStatePropertiesReset;
@@ -2087,10 +2087,10 @@ size_t LZMA2_encode(LZMA2_ECtx *const enc,
         out_dest += compressed_size + header_size;
 
         /* Update progress concurrently with other encoder threads */
-        FL2_atomic_add(*progress_in, (long)(next_index - index));
+        FL2_atomic_add(*progress_in, (long)(next_index - pos));
         FL2_atomic_add(*progress_out, (long)(compressed_size + header_size));
 
-        index = next_index;
+        pos = next_index;
 
         if (*canceled)
             return FL2_ERROR(canceled);
diff --git a/C/fast-lzma2/radix_bitpack.c b/C/fast-lzma2/radix_bitpack.c
index c7e5484c..258dc190 100644
--- a/C/fast-lzma2/radix_bitpack.c
+++ b/C/fast-lzma2/radix_bitpack.c
@@ -13,8 +13,6 @@
 #include "fl2_internal.h"
 #include "radix_internal.h"
 
-typedef struct FL2_matchTable_s FL2_matchTable;
-
 #undef MIN
 #define MIN(a,b) ((a) < (b) ? (a) : (b))
 
@@ -22,38 +20,38 @@ typedef struct FL2_matchTable_s FL2_matchTable;
 
 #define RADIX_MAX_LENGTH BITPACK_MAX_LENGTH
 
-#define InitMatchLink(index, link) tbl->table[index] = link
+#define InitMatchLink(pos, link) tbl->table[pos] = link
 
 #define GetMatchLink(link) (tbl->table[link] & RADIX_LINK_MASK)
 
-#define GetInitialMatchLink(index) tbl->table[index]
+#define GetInitialMatchLink(pos) tbl->table[pos]
 
-#define GetMatchLength(index) (tbl->table[index] >> RADIX_LINK_BITS)
+#define GetMatchLength(pos) (tbl->table[pos] >> RADIX_LINK_BITS)
 
-#define SetMatchLink(index, link, length) tbl->table[index] = (link) | ((U32)(length) << RADIX_LINK_BITS)
+#define SetMatchLink(pos, link, length) tbl->table[pos] = (link) | ((U32)(length) << RADIX_LINK_BITS)
 
-#define SetMatchLength(index, link, length) tbl->table[index] = (link) | ((U32)(length) << RADIX_LINK_BITS)
+#define SetMatchLength(pos, link, length) tbl->table[pos] = (link) | ((U32)(length) << RADIX_LINK_BITS)
 
-#define SetMatchLinkAndLength(index, link, length) tbl->table[index] = (link) | ((U32)(length) << RADIX_LINK_BITS)
+#define SetMatchLinkAndLength(pos, link, length) tbl->table[pos] = (link) | ((U32)(length) << RADIX_LINK_BITS)
 
-#define SetNull(index) tbl->table[index] = RADIX_NULL_LINK
+#define SetNull(pos) tbl->table[pos] = RADIX_NULL_LINK
 
-#define IsNull(index) (tbl->table[index] == RADIX_NULL_LINK)
+#define IsNull(pos) (tbl->table[pos] == RADIX_NULL_LINK)
 
-BYTE* RMF_bitpackAsOutputBuffer(FL2_matchTable* const tbl, size_t const index)
+BYTE* RMF_bitpackAsOutputBuffer(FL2_matchTable* const tbl, size_t const pos)
 {
-    return (BYTE*)(tbl->table + index);
+    return (BYTE*)(tbl->table + pos);
 }
 
-/* Restrict the match lengths so that they don't reach beyond index */
-void RMF_bitpackLimitLengths(FL2_matchTable* const tbl, size_t const index)
+/* Restrict the match lengths so that they don't reach beyond pos */
+void RMF_bitpackLimitLengths(FL2_matchTable* const tbl, size_t const pos)
 {
-    DEBUGLOG(5, "RMF_limitLengths : end %u, max length %u", (U32)index, RADIX_MAX_LENGTH);
-    SetNull(index - 1);
-    for (U32 length = 2; length < RADIX_MAX_LENGTH && length <= index; ++length) {
-        U32 const link = tbl->table[index - length];
+    DEBUGLOG(5, "RMF_limitLengths : end %u, max length %u", (U32)pos, RADIX_MAX_LENGTH);
+    SetNull(pos - 1);
+    for (U32 length = 2; length < RADIX_MAX_LENGTH && length <= pos; ++length) {
+        U32 const link = tbl->table[pos - length];
         if (link != RADIX_NULL_LINK)
-            tbl->table[index - length] = (MIN(length, link >> RADIX_LINK_BITS) << RADIX_LINK_BITS) | (link & RADIX_LINK_MASK);
+            tbl->table[pos - length] = (MIN(length, link >> RADIX_LINK_BITS) << RADIX_LINK_BITS) | (link & RADIX_LINK_MASK);
     }
 }
 
diff --git a/C/fast-lzma2/radix_engine.h b/C/fast-lzma2/radix_engine.h
index 0886d87d..7bccaab3 100644
--- a/C/fast-lzma2/radix_engine.h
+++ b/C/fast-lzma2/radix_engine.h
@@ -103,7 +103,7 @@ static void RMF_initReference(FL2_matchTable* const tbl, const void* const data,
 }
 #endif
 
-size_t
+void
 #ifdef RMF_BITPACK
 RMF_bitpackInit
 #else
@@ -115,12 +115,12 @@ RMF_structuredInit
         for (size_t i = 0; i < end; ++i)
             SetNull(i);
         tbl->end_index = 0;
-        return 0;
+        return;
     }
 #ifdef RMF_REFERENCE
     if (tbl->params.use_ref_mf) {
         RMF_initReference(tbl, data, end);
-        return 0;
+        return;
     }
 #endif
 
@@ -136,7 +136,6 @@ RMF_structuredInit
 
     radix_16 = ((size_t)((BYTE)radix_16) << 8) | data_block[2];
 
-    ptrdiff_t rpt_total = 0;
     ptrdiff_t i = 1;
     ptrdiff_t const block_size = end - 2;
     for (; i < block_size; ++i) {
@@ -170,8 +169,6 @@ RMF_structuredInit
     SetNull(end - 1);
 
     tbl->end_index = (U32)st_index;
-
-    return rpt_total;
 }
 
 /* Copy the list into a buffer and recurse it there. This decreases cache misses and allows */
@@ -264,23 +261,23 @@ static void RMF_recurseListsBuffered(RMF_builder* const tbl,
         /* Copy everything back, except the last link which never changes, and any extra overlap */
         count -= overlap + (overlap == 0);
 #ifdef RMF_BITPACK
-        if (max_depth > RADIX_MAX_LENGTH) for (size_t index = 0; index < count; ++index) {
-            size_t const from = tbl->match_buffer[index].from;
+        if (max_depth > RADIX_MAX_LENGTH) for (size_t pos = 0; pos < count; ++pos) {
+            size_t const from = tbl->match_buffer[pos].from;
             if (from < block_start)
                 return;
-            U32 length = tbl->match_buffer[index].next >> 24;
+            U32 length = tbl->match_buffer[pos].next >> 24;
             length = (length > RADIX_MAX_LENGTH) ? RADIX_MAX_LENGTH : length;
-            size_t const next = tbl->match_buffer[index].next & BUFFER_LINK_MASK;
+            size_t const next = tbl->match_buffer[pos].next & BUFFER_LINK_MASK;
             SetMatchLinkAndLength(from, tbl->match_buffer[next].from, length);
         }
         else
 #endif
-            for (size_t index = 0; index < count; ++index) {
-            size_t const from = tbl->match_buffer[index].from;
+            for (size_t pos = 0; pos < count; ++pos) {
+            size_t const from = tbl->match_buffer[pos].from;
             if (from < block_start)
                 return;
-            U32 const length = tbl->match_buffer[index].next >> 24;
-            size_t const next = tbl->match_buffer[index].next & BUFFER_LINK_MASK;
+            U32 const length = tbl->match_buffer[pos].next >> 24;
+            size_t const next = tbl->match_buffer[pos].next & BUFFER_LINK_MASK;
             SetMatchLinkAndLength(from, tbl->match_buffer[next].from, length);
         }
         start = 0;
@@ -338,32 +335,32 @@ static void RMF_recurseListsBound(RMF_builder* const tbl,
     /* Create an offset data buffer pointer for reading the next bytes */
     const BYTE* data_src = data_block + 2;
     U32 depth = 3;
-    size_t index = 0;
+    size_t pos = 0;
     size_t st_index = 0;
     RMF_listTail* const tails_8 = tbl->tails_8;
     do {
-        link = tbl->match_buffer[index].from;
+        link = tbl->match_buffer[pos].from;
         if (link < limit) {
             size_t const radix_8 = data_src[link];
             /* Seen this char before? */
             U32 const prev = tails_8[radix_8].prev_index;
-            tails_8[radix_8].prev_index = (U32)index;
+            tails_8[radix_8].prev_index = (U32)pos;
             if (prev != RADIX_NULL_LINK) {
                 ++tails_8[radix_8].list_count;
                 /* Link the previous occurrence to this one and record the new length */
-                tbl->match_buffer[prev].next = (U32)index | (depth << 24);
+                tbl->match_buffer[prev].next = (U32)pos | (depth << 24);
             }
             else {
                 tails_8[radix_8].list_count = 1;
                 /* Add the new sub list to the stack */
-                tbl->stack[st_index].head = (U32)index;
+                tbl->stack[st_index].head = (U32)pos;
                 /* This will be converted to a count at the end */
                 tbl->stack[st_index].count = (U32)radix_8;
                 ++st_index;
             }
         }
-        ++index;
-    } while (index < list_count);
+        ++pos;
+    } while (pos < list_count);
     /* Convert radix values on the stack to counts and reset any used tail slots */
     for (size_t j = 0; j < st_index; ++j) {
         tails_8[tbl->stack[j].count].prev_index = RADIX_NULL_LINK;
@@ -378,11 +375,11 @@ static void RMF_recurseListsBound(RMF_builder* const tbl,
         if (list_count < 2) /* Nothing to match with */
             continue;
 
-        index = tbl->stack[st_index].head;
-        depth = (tbl->match_buffer[index].next >> 24);
+        pos = tbl->stack[st_index].head;
+        depth = (tbl->match_buffer[pos].next >> 24);
         if (depth >= max_depth)
             continue;
-        link = tbl->match_buffer[index].from;
+        link = tbl->match_buffer[pos].from;
         if (link < bounded_start) {
             /* Chain starts before the bounded region */
             continue;
@@ -392,23 +389,23 @@ static void RMF_recurseListsBound(RMF_builder* const tbl,
         ++depth;
         prev_st_index = st_index;
         do {
-            link = tbl->match_buffer[index].from;
+            link = tbl->match_buffer[pos].from;
             if (link < limit) {
                 size_t const radix_8 = data_src[link];
                 U32 const prev = tails_8[radix_8].prev_index;
-                tails_8[radix_8].prev_index = (U32)index;
+                tails_8[radix_8].prev_index = (U32)pos;
                 if (prev != RADIX_NULL_LINK) {
                     ++tails_8[radix_8].list_count;
-                    tbl->match_buffer[prev].next = (U32)index | (depth << 24);
+                    tbl->match_buffer[prev].next = (U32)pos | (depth << 24);
                 }
                 else {
                     tails_8[radix_8].list_count = 1;
-                    tbl->stack[st_index].head = (U32)index;
+                    tbl->stack[st_index].head = (U32)pos;
                     tbl->stack[st_index].count = (U32)radix_8;
                     ++st_index;
                 }
             }
-            index = tbl->match_buffer[index].next & BUFFER_LINK_MASK;
+            pos = tbl->match_buffer[pos].next & BUFFER_LINK_MASK;
         } while (--list_count != 0);
         for (size_t j = prev_st_index; j < st_index; ++j) {
             tails_8[tbl->stack[j].count].prev_index = RADIX_NULL_LINK;
@@ -417,16 +414,16 @@ static void RMF_recurseListsBound(RMF_builder* const tbl,
     }
     /* Copy everything back above the bound */
     --count;
-    for (index = 0; index < count; ++index) {
-        ptrdiff_t const from = tbl->match_buffer[index].from;
+    for (pos = 0; pos < count; ++pos) {
+        ptrdiff_t const from = tbl->match_buffer[pos].from;
         if (from < bounded_start)
             break;
 
-        U32 length = tbl->match_buffer[index].next >> 24;
+        U32 length = tbl->match_buffer[pos].next >> 24;
         length = MIN(length, (U32)(block_size - from));
         length = MIN(length, RADIX_MAX_LENGTH);
 
-        size_t const next = tbl->match_buffer[index].next & BUFFER_LINK_MASK;
+        size_t const next = tbl->match_buffer[pos].next & BUFFER_LINK_MASK;
         SetMatchLinkAndLength(from, tbl->match_buffer[next].from, length);
     }
 }
@@ -901,9 +898,9 @@ static void RMF_recurseListsReference(RMF_builder* const tbl,
 static ptrdiff_t RMF_getNextList_mt(FL2_matchTable* const tbl)
 {
     if (tbl->st_index < tbl->end_index) {
-        long index = FL2_atomic_increment(tbl->st_index);
-        if (index < tbl->end_index)
-            return index;
+        long pos = FL2_atomic_increment(tbl->st_index);
+        if (pos < tbl->end_index)
+            return pos;
     }
     return -1;
 }
@@ -912,9 +909,9 @@ static ptrdiff_t RMF_getNextList_mt(FL2_matchTable* const tbl)
 static ptrdiff_t RMF_getNextList_st(FL2_matchTable* const tbl)
 {
     if (tbl->st_index < tbl->end_index) {
-        long index = FL2_nonAtomic_increment(tbl->st_index);
-        if (index < tbl->end_index)
-            return index;
+        long pos = FL2_nonAtomic_increment(tbl->st_index);
+        if (pos < tbl->end_index)
+            return pos;
     }
     return -1;
 }
@@ -927,7 +924,7 @@ RMF_bitpackBuildTable
 RMF_structuredBuildTable
 #endif
 (FL2_matchTable* const tbl,
-	size_t const job,
+    size_t const job,
     unsigned const multi_thread,
     FL2_dataBlock const block)
 {
@@ -945,19 +942,19 @@ RMF_structuredBuildTable
     for (;;)
     {
         /* Get the next to process */
-        ptrdiff_t index = getNextList(tbl);
+        ptrdiff_t pos = getNextList(tbl);
 
-        if (index < 0)
+        if (pos < 0)
             break;
 
-        while (next_progress < index) {
+        while (next_progress < pos) {
             /* initial value of next_progress ensures only thread 0 executes this */
             tbl->progress += tbl->list_heads[tbl->stack[next_progress]].count;
             ++next_progress;
         }
-        index = tbl->stack[index];
-        RMF_tableHead list_head = tbl->list_heads[index];
-        tbl->list_heads[index].head = RADIX_NULL_LINK;
+        pos = tbl->stack[pos];
+        RMF_tableHead list_head = tbl->list_heads[pos];
+        tbl->list_heads[pos].head = RADIX_NULL_LINK;
         if (list_head.count < 2 || list_head.head < block.start)
             continue;
 
@@ -989,33 +986,33 @@ RMF_bitpackIntegrityCheck
 #else
 RMF_structuredIntegrityCheck
 #endif
-(const FL2_matchTable* const tbl, const BYTE* const data, size_t index, size_t const end, unsigned max_depth)
+(const FL2_matchTable* const tbl, const BYTE* const data, size_t pos, size_t const end, unsigned max_depth)
 {
     max_depth &= ~1;
     int err = 0;
-    for (index += !index; index < end; ++index) {
-        if (IsNull(index))
+    for (pos += !pos; pos < end; ++pos) {
+        if (IsNull(pos))
             continue;
-        U32 const link = GetMatchLink(index);
-        if (link >= index) {
-            printf("Forward link at %X to %u\r\n", (U32)index, link);
+        U32 const link = GetMatchLink(pos);
+        if (link >= pos) {
+            printf("Forward link at %X to %u\r\n", (U32)pos, link);
             err = 1;
             continue;
         }
-        U32 const length = GetMatchLength(index);
-        if (index && length < RADIX_MAX_LENGTH && link - 1 == GetMatchLink(index - 1) && length + 1 == GetMatchLength(index - 1))
+        U32 const length = GetMatchLength(pos);
+        if (pos && length < RADIX_MAX_LENGTH && link - 1 == GetMatchLink(pos - 1) && length + 1 == GetMatchLength(pos - 1))
             continue;
         U32 len_test = 0;
-        U32 const limit = MIN((U32)(end - index), RADIX_MAX_LENGTH);
-        for (; len_test < limit && data[link + len_test] == data[index + len_test]; ++len_test) {
+        U32 const limit = MIN((U32)(end - pos), RADIX_MAX_LENGTH);
+        for (; len_test < limit && data[link + len_test] == data[pos + len_test]; ++len_test) {
         }
         if (len_test < length) {
-            printf("Failed integrity check: pos %X, length %u, actual %u\r\n", (U32)index, length, len_test);
+            printf("Failed integrity check: pos %X, length %u, actual %u\r\n", (U32)pos, length, len_test);
             err = 1;
         }
         if (length < max_depth && len_test > length)
             /* These occur occasionally due to splitting of chains in the buffer when long repeats are present */
-            printf("Shortened match at %X: %u of %u\r\n", (U32)index, length, len_test);
+            printf("Shortened match at %X: %u of %u\r\n", (U32)pos, length, len_test);
     }
     return err;
 }
diff --git a/C/fast-lzma2/radix_get.h b/C/fast-lzma2/radix_get.h
index e499e9b6..3a6cfa57 100644
--- a/C/fast-lzma2/radix_get.h
+++ b/C/fast-lzma2/radix_get.h
@@ -49,9 +49,9 @@ static size_t RMF_bitpackExtendMatch(const BYTE* const data,
     return end_index - start_index;
 }
 
-#define GetMatchLink(table, index) ((const RMF_unit*)(table))[(index) >> UNIT_BITS].links[(index) & UNIT_MASK]
+#define GetMatchLink(table, pos) ((const RMF_unit*)(table))[(pos) >> UNIT_BITS].links[(pos) & UNIT_MASK]
 
-#define GetMatchLength(table, index) ((const RMF_unit*)(table))[(index) >> UNIT_BITS].lengths[(index) & UNIT_MASK]
+#define GetMatchLength(table, pos) ((const RMF_unit*)(table))[(pos) >> UNIT_BITS].lengths[(pos) & UNIT_MASK]
 
 static size_t RMF_structuredExtendMatch(const BYTE* const data,
     const U32* const table,
@@ -86,11 +86,11 @@ RMF_match RMF_getMatch(FL2_dataBlock block,
     FL2_matchTable* tbl,
     unsigned max_depth,
     int structTbl,
-    size_t index)
+    size_t pos)
 {
     if (structTbl)
     {
-        U32 const link = GetMatchLink(tbl->table, index);
+        U32 const link = GetMatchLink(tbl->table, pos);
 
         RMF_match match;
         match.length = 0;
@@ -98,11 +98,11 @@ RMF_match RMF_getMatch(FL2_dataBlock block,
         if (link == RADIX_NULL_LINK)
             return match;
 
-        size_t const length = GetMatchLength(tbl->table, index);
-        size_t const dist = index - link - 1;
+        size_t const length = GetMatchLength(tbl->table, pos);
+        size_t const dist = pos - link - 1;
 
         if (length == max_depth || length == STRUCTURED_MAX_LENGTH /* from HandleRepeat */)
-            match.length = (U32)RMF_structuredExtendMatch(block.data, tbl->table, index, block.end, link, length);
+            match.length = (U32)RMF_structuredExtendMatch(block.data, tbl->table, pos, block.end, link, length);
         else
             match.length = (U32)length;
 
@@ -111,7 +111,7 @@ RMF_match RMF_getMatch(FL2_dataBlock block,
         return match;
     }
     else {
-        U32 link = tbl->table[index];
+        U32 link = tbl->table[pos];
 
         RMF_match match;
         match.length = 0;
@@ -121,10 +121,10 @@ RMF_match RMF_getMatch(FL2_dataBlock block,
 
         size_t const length = link >> RADIX_LINK_BITS;
         link &= RADIX_LINK_MASK;
-        size_t const dist = index - link - 1;
+        size_t const dist = pos - link - 1;
 
         if (length == max_depth || length == BITPACK_MAX_LENGTH /* from HandleRepeat */)
-            match.length = (U32)RMF_bitpackExtendMatch(block.data, tbl->table, index, block.end, link, length);
+            match.length = (U32)RMF_bitpackExtendMatch(block.data, tbl->table, pos, block.end, link, length);
         else
             match.length = (U32)length;
 
@@ -139,11 +139,11 @@ RMF_match RMF_getNextMatch(FL2_dataBlock block,
     FL2_matchTable* tbl,
     unsigned max_depth,
     int structTbl,
-    size_t index)
+    size_t pos)
 {
     if (structTbl)
     {
-        U32 const link = GetMatchLink(tbl->table, index);
+        U32 const link = GetMatchLink(tbl->table, pos);
 
         RMF_match match;
         match.length = 0;
@@ -151,15 +151,15 @@ RMF_match RMF_getNextMatch(FL2_dataBlock block,
         if (link == RADIX_NULL_LINK)
             return match;
 
-        size_t const length = GetMatchLength(tbl->table, index);
-        size_t const dist = index - link - 1;
+        size_t const length = GetMatchLength(tbl->table, pos);
+        size_t const dist = pos - link - 1;
 
         /* same distance, one byte shorter */
-        if (link - 1 == GetMatchLink(tbl->table, index - 1))
+        if (link - 1 == GetMatchLink(tbl->table, pos - 1))
             return match;
 
         if (length == max_depth || length == STRUCTURED_MAX_LENGTH /* from HandleRepeat */)
-            match.length = (U32)RMF_structuredExtendMatch(block.data, tbl->table, index, block.end, link, length);
+            match.length = (U32)RMF_structuredExtendMatch(block.data, tbl->table, pos, block.end, link, length);
         else
             match.length = (U32)length;
 
@@ -168,7 +168,7 @@ RMF_match RMF_getNextMatch(FL2_dataBlock block,
         return match;
     }
     else {
-        U32 link = tbl->table[index];
+        U32 link = tbl->table[pos];
 
         RMF_match match;
         match.length = 0;
@@ -178,14 +178,14 @@ RMF_match RMF_getNextMatch(FL2_dataBlock block,
 
         size_t const length = link >> RADIX_LINK_BITS;
         link &= RADIX_LINK_MASK;
-        size_t const dist = index - link - 1;
+        size_t const dist = pos - link - 1;
 
         /* same distance, one byte shorter */
-        if (link - 1 == (tbl->table[index - 1] & RADIX_LINK_MASK))
+        if (link - 1 == (tbl->table[pos - 1] & RADIX_LINK_MASK))
             return match;
 
         if (length == max_depth || length == BITPACK_MAX_LENGTH /* from HandleRepeat */)
-            match.length = (U32)RMF_bitpackExtendMatch(block.data, tbl->table, index, block.end, link, length);
+            match.length = (U32)RMF_bitpackExtendMatch(block.data, tbl->table, pos, block.end, link, length);
         else
             match.length = (U32)length;
 
diff --git a/C/fast-lzma2/radix_internal.h b/C/fast-lzma2/radix_internal.h
index 90f56690..9bede0ca 100644
--- a/C/fast-lzma2/radix_internal.h
+++ b/C/fast-lzma2/radix_internal.h
@@ -54,14 +54,14 @@ typedef struct
 } RMF_tableHead;
 
 union src_data_u {
-	BYTE chars[4];
-	U32 u32;
+    BYTE chars[4];
+    U32 u32;
 };
 
 typedef struct
 {
     U32 from;
-	union src_data_u src;
+    union src_data_u src;
     U32 next;
 } RMF_buildMatch;
 
@@ -105,14 +105,14 @@ struct FL2_matchTable_s
     U32 table[1];
 };
 
-size_t RMF_bitpackInit(struct FL2_matchTable_s* const tbl, const void* data, size_t const end);
-size_t RMF_structuredInit(struct FL2_matchTable_s* const tbl, const void* data, size_t const end);
+void RMF_bitpackInit(struct FL2_matchTable_s* const tbl, const void* data, size_t const end);
+void RMF_structuredInit(struct FL2_matchTable_s* const tbl, const void* data, size_t const end);
 void RMF_bitpackBuildTable(struct FL2_matchTable_s* const tbl,
-	size_t const job,
+    size_t const job,
     unsigned const multi_thread,
     FL2_dataBlock const block);
 void RMF_structuredBuildTable(struct FL2_matchTable_s* const tbl,
-	size_t const job,
+    size_t const job,
     unsigned const multi_thread,
     FL2_dataBlock const block);
 void RMF_recurseListChunk(RMF_builder* const tbl,
@@ -122,21 +122,21 @@ void RMF_recurseListChunk(RMF_builder* const tbl,
     U32 const max_depth,
     U32 const list_count,
     size_t const stack_base);
-int RMF_bitpackIntegrityCheck(const struct FL2_matchTable_s* const tbl, const BYTE* const data, size_t index, size_t const end, unsigned max_depth);
-int RMF_structuredIntegrityCheck(const struct FL2_matchTable_s* const tbl, const BYTE* const data, size_t index, size_t const end, unsigned max_depth);
-void RMF_bitpackLimitLengths(struct FL2_matchTable_s* const tbl, size_t const index);
-void RMF_structuredLimitLengths(struct FL2_matchTable_s* const tbl, size_t const index);
-BYTE* RMF_bitpackAsOutputBuffer(struct FL2_matchTable_s* const tbl, size_t const index);
-BYTE* RMF_structuredAsOutputBuffer(struct FL2_matchTable_s* const tbl, size_t const index);
+int RMF_bitpackIntegrityCheck(const struct FL2_matchTable_s* const tbl, const BYTE* const data, size_t pos, size_t const end, unsigned max_depth);
+int RMF_structuredIntegrityCheck(const struct FL2_matchTable_s* const tbl, const BYTE* const data, size_t pos, size_t const end, unsigned max_depth);
+void RMF_bitpackLimitLengths(struct FL2_matchTable_s* const tbl, size_t const pos);
+void RMF_structuredLimitLengths(struct FL2_matchTable_s* const tbl, size_t const pos);
+BYTE* RMF_bitpackAsOutputBuffer(struct FL2_matchTable_s* const tbl, size_t const pos);
+BYTE* RMF_structuredAsOutputBuffer(struct FL2_matchTable_s* const tbl, size_t const pos);
 size_t RMF_bitpackGetMatch(const struct FL2_matchTable_s* const tbl,
     const BYTE* const data,
-    size_t const index,
+    size_t const pos,
     size_t const limit,
     unsigned const max_depth,
     size_t* const offset_ptr);
 size_t RMF_structuredGetMatch(const struct FL2_matchTable_s* const tbl,
     const BYTE* const data,
-    size_t const index,
+    size_t const pos,
     size_t const limit,
     unsigned const max_depth,
     size_t* const offset_ptr);
diff --git a/C/fast-lzma2/radix_mf.c b/C/fast-lzma2/radix_mf.c
index 8fc64537..346f8945 100644
--- a/C/fast-lzma2/radix_mf.c
+++ b/C/fast-lzma2/radix_mf.c
@@ -16,7 +16,7 @@
 #include "fl2_internal.h"
 #include "radix_internal.h"
 
-#ifdef __GNUC__
+#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 407)
 #  pragma GCC diagnostic ignored "-Wmaybe-uninitialized" /* warning: 'rpt_head_next' may be used uninitialized in this function */
 #elif defined(_MSC_VER)
 #  pragma warning(disable : 4701) /* warning: 'rpt_head_next' may be used uninitialized in this function */
@@ -274,16 +274,16 @@ void RMF_initProgress(FL2_matchTable * const tbl)
         tbl->progress = 0;
 }
 
-size_t RMF_initTable(FL2_matchTable* const tbl, const void* const data, size_t const end)
+void RMF_initTable(FL2_matchTable* const tbl, const void* const data, size_t const end)
 {
     DEBUGLOG(5, "RMF_initTable : size %u", (U32)end);
 
     tbl->st_index = ATOMIC_INITIAL_VALUE;
 
     if (tbl->is_struct)
-        return RMF_structuredInit(tbl, data, end);
+        RMF_structuredInit(tbl, data, end);
     else
-        return RMF_bitpackInit(tbl, data, end);
+        RMF_bitpackInit(tbl, data, end);
 }
 
 static void RMF_handleRepeat(RMF_buildMatch* const match_buffer,
@@ -294,31 +294,31 @@ static void RMF_handleRepeat(RMF_buildMatch* const match_buffer,
     U32 const depth,
     U32 const max_len)
 {
-    size_t index = next;
+    size_t pos = next;
     U32 length = depth + rpt_len;
 
-    const BYTE* const data = data_block + match_buffer[index].from;
+    const BYTE* const data = data_block + match_buffer[pos].from;
     const BYTE* const data_2 = data - rpt_len;
 
     while (data[length] == data_2[length] && length < max_len)
         ++length;
 
     for (; length <= max_len && count; --count) {
-        size_t next_i = match_buffer[index].next & 0xFFFFFF;
-        match_buffer[index].next = (U32)next_i | (length << 24);
+        size_t next_i = match_buffer[pos].next & 0xFFFFFF;
+        match_buffer[pos].next = (U32)next_i | (length << 24);
         length += rpt_len;
-        index = next_i;
+        pos = next_i;
     }
     for (; count; --count) {
-        size_t next_i = match_buffer[index].next & 0xFFFFFF;
-        match_buffer[index].next = (U32)next_i | (max_len << 24);
-        index = next_i;
+        size_t next_i = match_buffer[pos].next & 0xFFFFFF;
+        match_buffer[pos].next = (U32)next_i | (max_len << 24);
+        pos = next_i;
     }
 }
 
 typedef struct
 {
-    size_t index;
+    size_t pos;
     const BYTE* data_src;
     union src_data_u src;
 } BruteForceMatch;
@@ -326,7 +326,7 @@ typedef struct
 static void RMF_bruteForceBuffered(RMF_builder* const tbl,
     const BYTE* const data_block,
     size_t const block_start,
-    size_t index,
+    size_t pos,
     size_t const list_count,
     size_t const slot,
     size_t const depth,
@@ -339,14 +339,14 @@ static void RMF_bruteForceBuffered(RMF_builder* const tbl,
     size_t i = 0;
     for (;;) {
         /* Load all locations from the match buffer */
-        buffer[i].index = index;
-        buffer[i].data_src = data_src + tbl->match_buffer[index].from;
-        buffer[i].src.u32 = tbl->match_buffer[index].src.u32;
+        buffer[i].pos = pos;
+        buffer[i].data_src = data_src + tbl->match_buffer[pos].from;
+        buffer[i].src.u32 = tbl->match_buffer[pos].src.u32;
 
         if (++i >= list_count)
             break;
 
-        index = tbl->match_buffer[index].next & 0xFFFFFF;
+        pos = tbl->match_buffer[pos].next & 0xFFFFFF;
     }
     i = 0;
     do {
@@ -376,8 +376,8 @@ static void RMF_bruteForceBuffered(RMF_builder* const tbl,
         } while (++j < list_count);
         if (longest > 0) {
             /* If the existing match was extended, store the new link and length info in the match buffer */
-            index = buffer[i].index;
-            tbl->match_buffer[index].next = (U32)(buffer[longest_index].index | ((depth + longest) << 24));
+            pos = buffer[i].pos;
+            tbl->match_buffer[pos].next = (U32)(buffer[longest_index].pos | ((depth + longest) << 24));
         }
         ++i;
     } while (i < list_count - 1 && buffer[i].data_src >= start);
@@ -397,38 +397,38 @@ void RMF_recurseListChunk_generic(RMF_builder* const tbl,
 {
     U32 const base_depth = depth;
     size_t st_index = stack_base;
-    size_t index = 0;
+    size_t pos = 0;
     ++depth;
     /* The last element is done separately and won't be copied back at the end */
     --list_count;
     do {
-        size_t const radix_8 = tbl->match_buffer[index].src.chars[0];
+        size_t const radix_8 = tbl->match_buffer[pos].src.chars[0];
         /* Seen this char before? */
         U32 const prev = tbl->tails_8[radix_8].prev_index;
-        tbl->tails_8[radix_8].prev_index = (U32)index;
+        tbl->tails_8[radix_8].prev_index = (U32)pos;
         if (prev != RADIX_NULL_LINK) {
             ++tbl->tails_8[radix_8].list_count;
             /* Link the previous occurrence to this one and record the new length */
-            tbl->match_buffer[prev].next = (U32)index | (depth << 24);
+            tbl->match_buffer[prev].next = (U32)pos | (depth << 24);
         }
         else {
             tbl->tails_8[radix_8].list_count = 1;
             /* Add the new sub list to the stack */
-            tbl->stack[st_index].head = (U32)index;
+            tbl->stack[st_index].head = (U32)pos;
             /* This will be converted to a count at the end */
             tbl->stack[st_index].count = (U32)radix_8;
             ++st_index;
         }
-        ++index;
-    } while (index < list_count);
+        ++pos;
+    } while (pos < list_count);
 
     {   /* Do the last element */
-        size_t const radix_8 = tbl->match_buffer[index].src.chars[0];
+        size_t const radix_8 = tbl->match_buffer[pos].src.chars[0];
         /* Nothing to do if there was no previous */
         U32 const prev = tbl->tails_8[radix_8].prev_index;
         if (prev != RADIX_NULL_LINK) {
             ++tbl->tails_8[radix_8].list_count;
-            tbl->match_buffer[prev].next = (U32)index | (depth << 24);
+            tbl->match_buffer[prev].next = (U32)pos | (depth << 24);
         }
     }
     /* Convert radix values on the stack to counts and reset any used tail slots */
@@ -444,8 +444,8 @@ void RMF_recurseListChunk_generic(RMF_builder* const tbl,
             /* Nothing to match with */
             continue;
         }
-        index = tbl->stack[st_index].head;
-        size_t link = tbl->match_buffer[index].from;
+        pos = tbl->stack[st_index].head;
+        size_t link = tbl->match_buffer[pos].from;
         if (link < block_start) {
             /* Chain starts in the overlap region which is already encoded */
             continue;
@@ -457,7 +457,7 @@ void RMF_recurseListChunk_generic(RMF_builder* const tbl,
             /* Stack may not be able to fit all possible new items. This is very rare. */
             continue;
         }
-        depth = tbl->match_buffer[index].next >> 24;
+        depth = tbl->match_buffer[pos].next >> 24;
         /* Index into the 4-byte pre-loaded input char cache */
         size_t slot = (depth - base_depth) & 3;
         if (list_count <= MAX_BRUTE_FORCE_LIST_SIZE) {
@@ -465,7 +465,7 @@ void RMF_recurseListChunk_generic(RMF_builder* const tbl,
             RMF_bruteForceBuffered(tbl,
                 data_block,
                 block_start,
-                index,
+                pos,
                 list_count,
                 slot,
                 depth,
@@ -486,59 +486,59 @@ void RMF_recurseListChunk_generic(RMF_builder* const tbl,
             --list_count;
             /* If slot is 3 then chars need to be loaded. */
             if (slot == 3 && max_depth != 6) do {
-                size_t const radix_8 = tbl->match_buffer[index].src.chars[3];
-                size_t const next_index = tbl->match_buffer[index].next & BUFFER_LINK_MASK;
+                size_t const radix_8 = tbl->match_buffer[pos].src.chars[3];
+                size_t const next_index = tbl->match_buffer[pos].next & BUFFER_LINK_MASK;
                 /* Pre-load the next link and data bytes. On some hardware execution can continue
                  * ahead while the data is retrieved if no operations except move are done on the data. */
-                tbl->match_buffer[index].src.u32 = MEM_read32(data_src + link);
+                tbl->match_buffer[pos].src.u32 = MEM_read32(data_src + link);
                 size_t const next_link = tbl->match_buffer[next_index].from;
                 U32 const prev = tbl->tails_8[radix_8].prev_index;
-                tbl->tails_8[radix_8].prev_index = (U32)index;
+                tbl->tails_8[radix_8].prev_index = (U32)pos;
                 if (prev != RADIX_NULL_LINK) {
-                    /* This char has occurred before in the chain. Link the previous (> index) occurance with this */
+                    /* This char has occurred before in the chain. Link the previous (> pos) occurance with this */
                     ++tbl->tails_8[radix_8].list_count;
-                    tbl->match_buffer[prev].next = (U32)index | (depth << 24);
+                    tbl->match_buffer[prev].next = (U32)pos | (depth << 24);
                 }
                 else {
                     /* First occurrence in the chain */
                     tbl->tails_8[radix_8].list_count = 1;
-                    tbl->stack[st_index].head = (U32)index;
+                    tbl->stack[st_index].head = (U32)pos;
                     /* Save the char as a reference to load the count at the end */
                     tbl->stack[st_index].count = (U32)radix_8;
                     ++st_index;
                 }
-                index = next_index;
+                pos = next_index;
                 link = next_link;
             } while (--list_count != 0);
             else do {
-                size_t const radix_8 = tbl->match_buffer[index].src.chars[slot];
-                size_t const next_index = tbl->match_buffer[index].next & BUFFER_LINK_MASK;
+                size_t const radix_8 = tbl->match_buffer[pos].src.chars[slot];
+                size_t const next_index = tbl->match_buffer[pos].next & BUFFER_LINK_MASK;
                 /* Pre-load the next link to avoid waiting for RAM access */
                 size_t const next_link = tbl->match_buffer[next_index].from;
                 U32 const prev = tbl->tails_8[radix_8].prev_index;
-                tbl->tails_8[radix_8].prev_index = (U32)index;
+                tbl->tails_8[radix_8].prev_index = (U32)pos;
                 if (prev != RADIX_NULL_LINK) {
                     ++tbl->tails_8[radix_8].list_count;
-                    tbl->match_buffer[prev].next = (U32)index | (depth << 24);
+                    tbl->match_buffer[prev].next = (U32)pos | (depth << 24);
                 }
                 else {
                     tbl->tails_8[radix_8].list_count = 1;
-                    tbl->stack[st_index].head = (U32)index;
+                    tbl->stack[st_index].head = (U32)pos;
                     tbl->stack[st_index].count = (U32)radix_8;
                     ++st_index;
                 }
-                index = next_index;
+                pos = next_index;
                 link = next_link;
             } while (--list_count != 0);
 
-            size_t const radix_8 = tbl->match_buffer[index].src.chars[slot];
+            size_t const radix_8 = tbl->match_buffer[pos].src.chars[slot];
             U32 const prev = tbl->tails_8[radix_8].prev_index;
             if (prev != RADIX_NULL_LINK) {
                 if (slot == 3)
-                    tbl->match_buffer[index].src.u32 = MEM_read32(data_src + link);
+                    tbl->match_buffer[pos].src.u32 = MEM_read32(data_src + link);
 
                 ++tbl->tails_8[radix_8].list_count;
-                tbl->match_buffer[prev].next = (U32)index | (depth << 24);
+                tbl->match_buffer[prev].next = (U32)pos | (depth << 24);
             }
             for (size_t j = prev_st_index; j < st_index; ++j) {
                 tbl->tails_8[tbl->stack[j].count].prev_index = RADIX_NULL_LINK;
@@ -554,8 +554,8 @@ void RMF_recurseListChunk_generic(RMF_builder* const tbl,
             /* Last element done separately */
             --list_count;
             do {
-                size_t const radix_8 = tbl->match_buffer[index].src.chars[slot];
-                size_t const next_index = tbl->match_buffer[index].next & BUFFER_LINK_MASK;
+                size_t const radix_8 = tbl->match_buffer[pos].src.chars[slot];
+                size_t const next_index = tbl->match_buffer[pos].next & BUFFER_LINK_MASK;
                 size_t const next_link = tbl->match_buffer[next_index].from;
                 if ((link - next_link) > rpt_depth) {
                     if (rpt > 0)
@@ -563,18 +563,18 @@ void RMF_recurseListChunk_generic(RMF_builder* const tbl,
 
                     rpt = -1;
                     U32 const prev = tbl->tails_8[radix_8].prev_index;
-                    tbl->tails_8[radix_8].prev_index = (U32)index;
+                    tbl->tails_8[radix_8].prev_index = (U32)pos;
                     if (prev != RADIX_NULL_LINK) {
                         ++tbl->tails_8[radix_8].list_count;
-                        tbl->match_buffer[prev].next = (U32)index | (depth << 24);
+                        tbl->match_buffer[prev].next = (U32)pos | (depth << 24);
                     }
                     else {
                         tbl->tails_8[radix_8].list_count = 1;
-                        tbl->stack[st_index].head = (U32)index;
+                        tbl->stack[st_index].head = (U32)pos;
                         tbl->stack[st_index].count = (U32)radix_8;
                         ++st_index;
                     }
-                    index = next_index;
+                    pos = next_index;
                     link = next_link;
                 }
                 else {
@@ -587,14 +587,14 @@ void RMF_recurseListChunk_generic(RMF_builder* const tbl,
                         rpt_head_next = next_index;
                         rpt_dist = dist;
                         U32 const prev = tbl->tails_8[radix_8].prev_index;
-                        tbl->tails_8[radix_8].prev_index = (U32)index;
+                        tbl->tails_8[radix_8].prev_index = (U32)pos;
                         if (prev != RADIX_NULL_LINK) {
                             ++tbl->tails_8[radix_8].list_count;
-                            tbl->match_buffer[prev].next = (U32)index | (depth << 24);
+                            tbl->match_buffer[prev].next = (U32)pos | (depth << 24);
                         }
                         else {
                             tbl->tails_8[radix_8].list_count = 1;
-                            tbl->stack[st_index].head = (U32)index;
+                            tbl->stack[st_index].head = (U32)pos;
                             tbl->stack[st_index].count = (U32)radix_8;
                             ++st_index;
                         }
@@ -602,7 +602,7 @@ void RMF_recurseListChunk_generic(RMF_builder* const tbl,
                     else {
                         ++rpt;
                     }
-                    index = next_index;
+                    pos = next_index;
                     link = next_link;
                 }
             } while (--list_count != 0);
@@ -610,14 +610,14 @@ void RMF_recurseListChunk_generic(RMF_builder* const tbl,
             if (rpt > 0)
                 RMF_handleRepeat(tbl->match_buffer, data_block, rpt_head_next, rpt, rpt_dist, rpt_depth, tbl->max_len);
 
-            size_t const radix_8 = tbl->match_buffer[index].src.chars[slot];
+            size_t const radix_8 = tbl->match_buffer[pos].src.chars[slot];
             U32 const prev = tbl->tails_8[radix_8].prev_index;
             if (prev != RADIX_NULL_LINK) {
                 if (slot == 3) {
-                    tbl->match_buffer[index].src.u32 = MEM_read32(data_src + link);
+                    tbl->match_buffer[pos].src.u32 = MEM_read32(data_src + link);
                 }
                 ++tbl->tails_8[radix_8].list_count;
-                tbl->match_buffer[prev].next = (U32)index | (depth << 24);
+                tbl->match_buffer[prev].next = (U32)pos | (depth << 24);
             }
             for (size_t j = prev_st_index; j < st_index; ++j) {
                 tbl->tails_8[tbl->stack[j].count].prev_index = RADIX_NULL_LINK;
@@ -628,21 +628,21 @@ void RMF_recurseListChunk_generic(RMF_builder* const tbl,
             size_t const prev_st_index = st_index;
             /* The last pass at max_depth */
             do {
-                size_t const radix_8 = tbl->match_buffer[index].src.chars[slot];
-                size_t const next_index = tbl->match_buffer[index].next & BUFFER_LINK_MASK;
+                size_t const radix_8 = tbl->match_buffer[pos].src.chars[slot];
+                size_t const next_index = tbl->match_buffer[pos].next & BUFFER_LINK_MASK;
                 /* Pre-load the next link. */
                 /* The last element in tbl->match_buffer is circular so this is never an access violation. */
                 size_t const next_link = tbl->match_buffer[next_index].from;
                 U32 const prev = tbl->tails_8[radix_8].prev_index;
-                tbl->tails_8[radix_8].prev_index = (U32)index;
+                tbl->tails_8[radix_8].prev_index = (U32)pos;
                 if (prev != RADIX_NULL_LINK) {
-                    tbl->match_buffer[prev].next = (U32)index | (depth << 24);
+                    tbl->match_buffer[prev].next = (U32)pos | (depth << 24);
                 }
                 else {
                     tbl->stack[st_index].count = (U32)radix_8;
                     ++st_index;
                 }
-                index = next_index;
+                pos = next_index;
                 link = next_link;
             } while (--list_count != 0);
             for (size_t j = prev_st_index; j < st_index; ++j) {
@@ -703,28 +703,28 @@ void RMF_resetIncompleteBuild(FL2_matchTable * const tbl)
     RMF_initListHeads(tbl);
 }
 
-int RMF_integrityCheck(const FL2_matchTable* const tbl, const BYTE* const data, size_t const index, size_t const end, unsigned const max_depth)
+int RMF_integrityCheck(const FL2_matchTable* const tbl, const BYTE* const data, size_t const pos, size_t const end, unsigned const max_depth)
 {
     if (tbl->is_struct)
-        return RMF_structuredIntegrityCheck(tbl, data, index, end, max_depth);
+        return RMF_structuredIntegrityCheck(tbl, data, pos, end, max_depth);
     else
-        return RMF_bitpackIntegrityCheck(tbl, data, index, end, max_depth);
+        return RMF_bitpackIntegrityCheck(tbl, data, pos, end, max_depth);
 }
 
-void RMF_limitLengths(FL2_matchTable* const tbl, size_t const index)
+void RMF_limitLengths(FL2_matchTable* const tbl, size_t const pos)
 {
     if (tbl->is_struct)
-        RMF_structuredLimitLengths(tbl, index);
+        RMF_structuredLimitLengths(tbl, pos);
     else
-        RMF_bitpackLimitLengths(tbl, index);
+        RMF_bitpackLimitLengths(tbl, pos);
 }
 
-BYTE* RMF_getTableAsOutputBuffer(FL2_matchTable* const tbl, size_t const index)
+BYTE* RMF_getTableAsOutputBuffer(FL2_matchTable* const tbl, size_t const pos)
 {
     if (tbl->is_struct)
-        return RMF_structuredAsOutputBuffer(tbl, index);
+        return RMF_structuredAsOutputBuffer(tbl, pos);
     else
-        return RMF_bitpackAsOutputBuffer(tbl, index);
+        return RMF_bitpackAsOutputBuffer(tbl, pos);
 }
 
 size_t RMF_memoryUsage(size_t const dict_size, unsigned const buffer_resize, unsigned const thread_count)
diff --git a/C/fast-lzma2/radix_mf.h b/C/fast-lzma2/radix_mf.h
index e8faa47b..f6ec88c1 100644
--- a/C/fast-lzma2/radix_mf.h
+++ b/C/fast-lzma2/radix_mf.h
@@ -42,16 +42,16 @@ BYTE RMF_compatibleParameters(const FL2_matchTable* const tbl, const RMF_paramet
 size_t RMF_applyParameters(FL2_matchTable* const tbl, const RMF_parameters* const params, size_t const dict_reduce);
 size_t RMF_threadCount(const FL2_matchTable * const tbl);
 void RMF_initProgress(FL2_matchTable * const tbl);
-size_t RMF_initTable(FL2_matchTable* const tbl, const void* const data, size_t const end);
+void RMF_initTable(FL2_matchTable* const tbl, const void* const data, size_t const end);
 int RMF_buildTable(FL2_matchTable* const tbl,
-	size_t const job,
+    size_t const job,
     unsigned const multi_thread,
     FL2_dataBlock const block);
 void RMF_cancelBuild(FL2_matchTable* const tbl);
 void RMF_resetIncompleteBuild(FL2_matchTable* const tbl);
-int RMF_integrityCheck(const FL2_matchTable* const tbl, const BYTE* const data, size_t const index, size_t const end, unsigned const max_depth);
-void RMF_limitLengths(FL2_matchTable* const tbl, size_t const index);
-BYTE* RMF_getTableAsOutputBuffer(FL2_matchTable* const tbl, size_t const index);
+int RMF_integrityCheck(const FL2_matchTable* const tbl, const BYTE* const data, size_t const pos, size_t const end, unsigned const max_depth);
+void RMF_limitLengths(FL2_matchTable* const tbl, size_t const pos);
+BYTE* RMF_getTableAsOutputBuffer(FL2_matchTable* const tbl, size_t const pos);
 size_t RMF_memoryUsage(size_t const dict_size, unsigned const buffer_resize, unsigned const thread_count);
 
 #if defined (__cplusplus)
diff --git a/C/fast-lzma2/radix_struct.c b/C/fast-lzma2/radix_struct.c
index ce8b6ee1..2117fa0c 100644
--- a/C/fast-lzma2/radix_struct.c
+++ b/C/fast-lzma2/radix_struct.c
@@ -13,8 +13,6 @@
 #include "fl2_internal.h"
 #include "radix_internal.h"
 
-typedef struct FL2_matchTable_s FL2_matchTable;
-
 #undef MIN
 #define MIN(a,b) ((a) < (b) ? (a) : (b))
 
@@ -22,37 +20,37 @@ typedef struct FL2_matchTable_s FL2_matchTable;
 
 #define RADIX_MAX_LENGTH STRUCTURED_MAX_LENGTH
 
-#define InitMatchLink(index, link) ((RMF_unit*)tbl->table)[(index) >> UNIT_BITS].links[(index) & UNIT_MASK] = (U32)(link)
+#define InitMatchLink(pos, link) ((RMF_unit*)tbl->table)[(pos) >> UNIT_BITS].links[(pos) & UNIT_MASK] = (U32)(link)
 
-#define GetMatchLink(index) ((RMF_unit*)tbl->table)[(index) >> UNIT_BITS].links[(index) & UNIT_MASK]
+#define GetMatchLink(pos) ((RMF_unit*)tbl->table)[(pos) >> UNIT_BITS].links[(pos) & UNIT_MASK]
 
-#define GetInitialMatchLink(index) ((RMF_unit*)tbl->table)[(index) >> UNIT_BITS].links[(index) & UNIT_MASK]
+#define GetInitialMatchLink(pos) ((RMF_unit*)tbl->table)[(pos) >> UNIT_BITS].links[(pos) & UNIT_MASK]
 
-#define GetMatchLength(index) ((RMF_unit*)tbl->table)[(index) >> UNIT_BITS].lengths[(index) & UNIT_MASK]
+#define GetMatchLength(pos) ((RMF_unit*)tbl->table)[(pos) >> UNIT_BITS].lengths[(pos) & UNIT_MASK]
 
-#define SetMatchLink(index, link, length) ((RMF_unit*)tbl->table)[(index) >> UNIT_BITS].links[(index) & UNIT_MASK] = (U32)(link)
+#define SetMatchLink(pos, link, length) ((RMF_unit*)tbl->table)[(pos) >> UNIT_BITS].links[(pos) & UNIT_MASK] = (U32)(link)
 
-#define SetMatchLength(index, link, length) ((RMF_unit*)tbl->table)[(index) >> UNIT_BITS].lengths[(index) & UNIT_MASK] = (BYTE)(length)
+#define SetMatchLength(pos, link, length) ((RMF_unit*)tbl->table)[(pos) >> UNIT_BITS].lengths[(pos) & UNIT_MASK] = (BYTE)(length)
 
-#define SetMatchLinkAndLength(index, link, length) do { size_t i_ = (index) >> UNIT_BITS, u_ = (index) & UNIT_MASK; ((RMF_unit*)tbl->table)[i_].links[u_] = (U32)(link); ((RMF_unit*)tbl->table)[i_].lengths[u_] = (BYTE)(length); } while(0)
+#define SetMatchLinkAndLength(pos, link, length) do { size_t i_ = (pos) >> UNIT_BITS, u_ = (pos) & UNIT_MASK; ((RMF_unit*)tbl->table)[i_].links[u_] = (U32)(link); ((RMF_unit*)tbl->table)[i_].lengths[u_] = (BYTE)(length); } while(0)
 
-#define SetNull(index) ((RMF_unit*)tbl->table)[(index) >> UNIT_BITS].links[(index) & UNIT_MASK] = RADIX_NULL_LINK
+#define SetNull(pos) ((RMF_unit*)tbl->table)[(pos) >> UNIT_BITS].links[(pos) & UNIT_MASK] = RADIX_NULL_LINK
 
-#define IsNull(index) (((RMF_unit*)tbl->table)[(index) >> UNIT_BITS].links[(index) & UNIT_MASK] == RADIX_NULL_LINK)
+#define IsNull(pos) (((RMF_unit*)tbl->table)[(pos) >> UNIT_BITS].links[(pos) & UNIT_MASK] == RADIX_NULL_LINK)
 
-BYTE* RMF_structuredAsOutputBuffer(FL2_matchTable* const tbl, size_t const index)
+BYTE* RMF_structuredAsOutputBuffer(FL2_matchTable* const tbl, size_t const pos)
 {
-    return (BYTE*)((RMF_unit*)tbl->table + (index >> UNIT_BITS) + ((index & UNIT_MASK) != 0));
+    return (BYTE*)((RMF_unit*)tbl->table + (pos >> UNIT_BITS) + ((pos & UNIT_MASK) != 0));
 }
 
-/* Restrict the match lengths so that they don't reach beyond index */
-void RMF_structuredLimitLengths(FL2_matchTable* const tbl, size_t const index)
+/* Restrict the match lengths so that they don't reach beyond pos */
+void RMF_structuredLimitLengths(FL2_matchTable* const tbl, size_t const pos)
 {
-    DEBUGLOG(5, "RMF_limitLengths : end %u, max length %u", (U32)index, RADIX_MAX_LENGTH);
-    SetNull(index - 1);
-    for (size_t length = 2; length < RADIX_MAX_LENGTH && length <= index; ++length) {
-        size_t const i = (index - length) >> UNIT_BITS;
-        size_t const u = (index - length) & UNIT_MASK;
+    DEBUGLOG(5, "RMF_limitLengths : end %u, max length %u", (U32)pos, RADIX_MAX_LENGTH);
+    SetNull(pos - 1);
+    for (size_t length = 2; length < RADIX_MAX_LENGTH && length <= pos; ++length) {
+        size_t const i = (pos - length) >> UNIT_BITS;
+        size_t const u = (pos - length) & UNIT_MASK;
         if (((RMF_unit*)tbl->table)[i].links[u] != RADIX_NULL_LINK) {
             ((RMF_unit*)tbl->table)[i].lengths[u] = MIN((BYTE)length, ((RMF_unit*)tbl->table)[i].lengths[u]);
         }
diff --git a/C/fast-lzma2/range_enc.c b/C/fast-lzma2/range_enc.c
index b7ad9614..31397703 100644
--- a/C/fast-lzma2/range_enc.c
+++ b/C/fast-lzma2/range_enc.c
@@ -63,12 +63,12 @@ void RC_printPriceTable()
     memset(table0, 0, sizeof(table0));
     memset(table1, 0, sizeof(table1));
     memset(count, 0, sizeof(count));
-    for (Probability i = 31; i <= kBitModelTotal - 31; ++i) {
-        RangeEncoder rc;
+    for (LZMA2_prob i = 31; i <= kBitModelTotal - 31; ++i) {
+        RC_encoder rc;
         RC_reset(&rc);
         RC_setOutputBuffer(&rc, buf);
         for (unsigned j = 0; j < test_size; ++j) {
-            Probability prob = i;
+            LZMA2_prob prob = i;
             RC_encodeBit0(&rc, &prob);
         }
         RC_flush(&rc);
@@ -76,7 +76,7 @@ void RC_printPriceTable()
         RC_reset(&rc);
         RC_setOutputBuffer(&rc, buf);
         for (unsigned j = 0; j < test_size; ++j) {
-            Probability prob = i;
+            LZMA2_prob prob = i;
             RC_encodeBit1(&rc, &prob);
         }
         RC_flush(&rc);
@@ -104,13 +104,13 @@ void RC_printPriceTable()
 
 #endif
 
-void RC_setOutputBuffer(RangeEncoder* const rc, BYTE *const out_buffer)
+void RC_setOutputBuffer(RC_encoder* const rc, BYTE *const out_buffer)
 {
     rc->out_buffer = out_buffer;
     rc->out_index = 0;
 }
 
-void RC_reset(RangeEncoder* const rc)
+void RC_reset(RC_encoder* const rc)
 {
     rc->low = 0;
     rc->range = (U32)-1;
@@ -120,7 +120,7 @@ void RC_reset(RangeEncoder* const rc)
 
 #ifdef __64BIT__
 
-void FORCE_NOINLINE RC_shiftLow(RangeEncoder* const rc)
+void FORCE_NOINLINE RC_shiftLow(RC_encoder* const rc)
 {
     U64 low = rc->low;
     rc->low = (U32)(low << 8);
@@ -143,7 +143,7 @@ void FORCE_NOINLINE RC_shiftLow(RangeEncoder* const rc)
 
 #else
 
-void FORCE_NOINLINE RC_shiftLow(RangeEncoder* const rc)
+void FORCE_NOINLINE RC_shiftLow(RC_encoder* const rc)
 {
     U32 low = (U32)rc->low;
     unsigned high = (unsigned)(rc->low >> 32);
@@ -165,7 +165,7 @@ void FORCE_NOINLINE RC_shiftLow(RangeEncoder* const rc)
 
 #endif
 
-void RC_encodeBitTree(RangeEncoder* const rc, Probability *const probs, unsigned bit_count, unsigned symbol)
+void RC_encodeBitTree(RC_encoder* const rc, LZMA2_prob *const probs, unsigned bit_count, unsigned symbol)
 {
     assert(bit_count > 1);
     --bit_count;
@@ -180,7 +180,7 @@ void RC_encodeBitTree(RangeEncoder* const rc, Probability *const probs, unsigned
     } while (bit_count != 0);
 }
 
-void RC_encodeBitTreeReverse(RangeEncoder* const rc, Probability *const probs, unsigned bit_count, unsigned symbol)
+void RC_encodeBitTreeReverse(RC_encoder* const rc, LZMA2_prob *const probs, unsigned bit_count, unsigned symbol)
 {
     assert(bit_count != 0);
     unsigned bit = symbol & 1;
@@ -194,7 +194,7 @@ void RC_encodeBitTreeReverse(RangeEncoder* const rc, Probability *const probs, u
 	}
 }
 
-void FORCE_NOINLINE RC_encodeDirect(RangeEncoder* const rc, unsigned value, unsigned bit_count)
+void FORCE_NOINLINE RC_encodeDirect(RC_encoder* const rc, unsigned value, unsigned bit_count)
 {
 	assert(bit_count > 0);
 	do {
diff --git a/C/fast-lzma2/range_enc.h b/C/fast-lzma2/range_enc.h
index 81a7a6e8..1d9a50d9 100644
--- a/C/fast-lzma2/range_enc.h
+++ b/C/fast-lzma2/range_enc.h
@@ -16,9 +16,9 @@ extern "C" {
 #endif
 
 #ifdef LZMA_ENC_PROB32
-typedef U32 Probability;
+typedef U32 LZMA2_prob;
 #else
-typedef U16 Probability;
+typedef U16 LZMA2_prob;
 #endif
 
 #define kNumTopBits 24U
@@ -44,27 +44,27 @@ typedef struct
 	U64 low;
 	U32 range;
 	BYTE cache;
-} RangeEncoder;
+} RC_encoder;
 
-void RC_reset(RangeEncoder* const rc);
+void RC_reset(RC_encoder* const rc);
 
-void RC_setOutputBuffer(RangeEncoder* const rc, BYTE *const out_buffer);
+void RC_setOutputBuffer(RC_encoder* const rc, BYTE *const out_buffer);
 
-void FORCE_NOINLINE RC_shiftLow(RangeEncoder* const rc);
+void FORCE_NOINLINE RC_shiftLow(RC_encoder* const rc);
 
-void RC_encodeBitTree(RangeEncoder* const rc, Probability *const probs, unsigned bit_count, unsigned symbol);
+void RC_encodeBitTree(RC_encoder* const rc, LZMA2_prob *const probs, unsigned bit_count, unsigned symbol);
 
-void RC_encodeBitTreeReverse(RangeEncoder* const rc, Probability *const probs, unsigned bit_count, unsigned symbol);
+void RC_encodeBitTreeReverse(RC_encoder* const rc, LZMA2_prob *const probs, unsigned bit_count, unsigned symbol);
 
-void FORCE_NOINLINE RC_encodeDirect(RangeEncoder* const rc, unsigned value, unsigned bit_count);
+void FORCE_NOINLINE RC_encodeDirect(RC_encoder* const rc, unsigned value, unsigned bit_count);
 
 HINT_INLINE
-void RC_encodeBit0(RangeEncoder* const rc, Probability *const rprob)
+void RC_encodeBit0(RC_encoder* const rc, LZMA2_prob *const rprob)
 {
 	unsigned prob = *rprob;
     rc->range = (rc->range >> kNumBitModelTotalBits) * prob;
 	prob += (kBitModelTotal - prob) >> kNumMoveBits;
-	*rprob = (Probability)prob;
+	*rprob = (LZMA2_prob)prob;
 	if (rc->range < kTopValue) {
         rc->range <<= 8;
 		RC_shiftLow(rc);
@@ -72,14 +72,14 @@ void RC_encodeBit0(RangeEncoder* const rc, Probability *const rprob)
 }
 
 HINT_INLINE
-void RC_encodeBit1(RangeEncoder* const rc, Probability *const rprob)
+void RC_encodeBit1(RC_encoder* const rc, LZMA2_prob *const rprob)
 {
 	unsigned prob = *rprob;
 	U32 new_bound = (rc->range >> kNumBitModelTotalBits) * prob;
     rc->low += new_bound;
     rc->range -= new_bound;
 	prob -= prob >> kNumMoveBits;
-	*rprob = (Probability)prob;
+	*rprob = (LZMA2_prob)prob;
 	if (rc->range < kTopValue) {
         rc->range <<= 8;
 		RC_shiftLow(rc);
@@ -87,7 +87,7 @@ void RC_encodeBit1(RangeEncoder* const rc, Probability *const rprob)
 }
 
 HINT_INLINE
-void RC_encodeBit(RangeEncoder* const rc, Probability *const rprob, unsigned const bit)
+void RC_encodeBit(RC_encoder* const rc, LZMA2_prob *const rprob, unsigned const bit)
 {
 	unsigned prob = *rprob;
 	if (bit != 0) {
@@ -100,7 +100,7 @@ void RC_encodeBit(RangeEncoder* const rc, Probability *const rprob, unsigned con
         rc->range = (rc->range >> kNumBitModelTotalBits) * prob;
 		prob += (kBitModelTotal - prob) >> kNumMoveBits;
 	}
-	*rprob = (Probability)prob;
+	*rprob = (LZMA2_prob)prob;
 	if (rc->range < kTopValue) {
         rc->range <<= 8;
 		RC_shiftLow(rc);
@@ -117,7 +117,7 @@ void RC_encodeBit(RangeEncoder* const rc, Probability *const rprob, unsigned con
 #define kMinLitPrice 8U
 
 HINT_INLINE
-unsigned RC_getTreePrice(const Probability* const prob_table, unsigned bit_count, size_t symbol)
+unsigned RC_getTreePrice(const LZMA2_prob* const prob_table, unsigned bit_count, size_t symbol)
 {
 	unsigned price = 0;
     symbol |= ((size_t)1 << bit_count);
@@ -132,7 +132,7 @@ unsigned RC_getTreePrice(const Probability* const prob_table, unsigned bit_count
 }
 
 HINT_INLINE
-unsigned RC_getReverseTreePrice(const Probability* const prob_table, unsigned bit_count, size_t symbol)
+unsigned RC_getReverseTreePrice(const LZMA2_prob* const prob_table, unsigned bit_count, size_t symbol)
 {
     unsigned prob = prob_table[1];
     size_t bit = symbol & 1;
@@ -149,7 +149,7 @@ unsigned RC_getReverseTreePrice(const Probability* const prob_table, unsigned bi
 }
 
 HINT_INLINE
-void RC_flush(RangeEncoder* const rc)
+void RC_flush(RC_encoder* const rc)
 {
     for (int i = 0; i < 5; ++i)
         RC_shiftLow(rc);