FG8 combined tests rebased on AVM-v10 Rebased fg8/CT3 commit 9a04494b20 on AVM-v10 tag STATS_CHANGED

diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 2740604..a10802d 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h

@@ -4212,8 +4212,10 @@
   ColorCost color_cost;
 #if CONFIG_PALETTE_IMPROVEMENTS
 #if CONFIG_PALETTE_LINE_COPY
+#if !CONFIG_PLT_DIR_CTX
   aom_cdf_prob *direction_cdf;
   PaletteDirectionCost direction_cost;
+#endif  // !CONFIG_PLT_DIR_CTX
 #endif  // CONFIG_PALETTE_LINE_COPY
   IdentityRowCdf identity_row_cdf;
   IdentityRowCost identity_row_cost;

diff --git a/av1/common/entropy.c b/av1/common/entropy.c
index d0ba1f8..54a13f2 100644
--- a/av1/common/entropy.c
+++ b/av1/common/entropy.c

@@ -70,8 +70,10 @@
            av1_default_coeff_base_lf_multi_uv_cdfs[index]);
   av1_copy(cm->fc->coeff_base_lf_eob_uv_cdf,
            av1_default_coeff_base_lf_eob_multi_uv_cdfs[index]);
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
   av1_copy(cm->fc->coeff_br_lf_uv_cdf,
            av1_default_coeff_lps_lf_multi_uv_cdfs[index]);
+#endif
   av1_copy(cm->fc->coeff_br_uv_cdf, av1_default_coeff_lps_multi_uv_cdfs[index]);
   av1_copy(cm->fc->coeff_base_uv_cdf,
            av1_default_coeff_base_multi_uv_cdfs[index]);
@@ -85,7 +87,9 @@
   av1_copy(cm->fc->eob_flag_cdf512, av1_default_eob_multi512_cdfs[index]);
   av1_copy(cm->fc->eob_flag_cdf1024, av1_default_eob_multi1024_cdfs[index]);
   av1_copy(cm->fc->coeff_base_ph_cdf, av1_default_coeff_base_ph_cdfs[index]);
+#if !CONFIG_COEFF_BR_PH_BYPASS
   av1_copy(cm->fc->coeff_br_ph_cdf, av1_default_coeff_br_ph_cdfs[index]);
+#endif
   av1_copy(cm->fc->coeff_base_bob_cdf,
            av1_default_coeff_base_bob_multi_cdfs[index]);
 #if CONFIG_DIP
@@ -201,7 +205,9 @@
   RESET_CDF_COUNTER(fc->coeff_br_lf_cdf, BR_CDF_SIZE);
   RESET_CDF_COUNTER(fc->coeff_base_lf_uv_cdf, LF_BASE_SYMBOLS);
   RESET_CDF_COUNTER(fc->coeff_base_lf_eob_uv_cdf, LF_BASE_SYMBOLS - 1);
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
   RESET_CDF_COUNTER(fc->coeff_br_lf_uv_cdf, BR_CDF_SIZE);
+#endif
   RESET_CDF_COUNTER(fc->coeff_base_uv_cdf, 4);
   RESET_CDF_COUNTER(fc->coeff_base_eob_uv_cdf, 3);
   RESET_CDF_COUNTER(fc->coeff_br_uv_cdf, BR_CDF_SIZE);
@@ -305,7 +311,9 @@
 #if CONFIG_PALETTE_LINE_COPY
   RESET_CDF_COUNTER(fc->identity_row_cdf_y, 3);
   RESET_CDF_COUNTER(fc->identity_row_cdf_uv, 3);
+#if !CONFIG_PLT_DIR_CTX
   RESET_CDF_COUNTER(fc->palette_direction_cdf, 2);
+#endif  // !CONFIG_PLT_DIR_CTX
 #else
   RESET_CDF_COUNTER(fc->identity_row_cdf_y, 2);
   RESET_CDF_COUNTER(fc->identity_row_cdf_uv, 2);
@@ -424,10 +432,14 @@
   RESET_CDF_COUNTER(fc->wienerns_uv_sym_cdf, 2);
   RESET_CDF_COUNTER(fc->wienerns_4part_cdf, 4);
   RESET_CDF_COUNTER(fc->pc_wiener_restore_cdf, 2);
+#if !CONFIG_MERGE_PARA_CTX
   RESET_CDF_COUNTER(fc->merged_param_cdf, 2);
+#endif  // !CONFIG_MERGE_PARA_CTX
   RESET_CDF_COUNTER(fc->y_mode_set_cdf, INTRA_MODE_SETS);
   RESET_CDF_COUNTER(fc->y_mode_idx_cdf_0, FIRST_MODE_COUNT);
+#if !CONFIG_CTX_Y_SECOND_MODE
   RESET_CDF_COUNTER(fc->y_mode_idx_cdf_1, SECOND_MODE_COUNT);
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
   RESET_CDF_COUNTER(fc->uv_mode_cdf, UV_INTRA_MODES - 1);
   RESET_CDF_COUNTER(fc->cfl_cdf, 2);
 
@@ -528,6 +540,8 @@
   }
 
   RESET_CDF_COUNTER(fc->coeff_base_ph_cdf, NUM_BASE_LEVELS + 2);
+#if !CONFIG_COEFF_BR_PH_BYPASS
   RESET_CDF_COUNTER(fc->coeff_br_ph_cdf, BR_CDF_SIZE);
+#endif
   RESET_CDF_COUNTER(fc->cctx_type_cdf, CCTX_TYPES);
 }

diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index ca57556..df411a8 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c

@@ -162,7 +162,7 @@
                   29340, 31013, 31870),
         75 },
     };
-
+#if !CONFIG_CTX_Y_SECOND_MODE
 static const aom_cdf_prob
     default_y_second_mode_cdf[Y_MODE_CONTEXTS][CDF_SIZE(SECOND_MODE_COUNT)] = {
       { AOM_CDF16(2614, 4872, 7327, 9645, 11546, 13349, 15504, 17424, 19397,
@@ -175,7 +175,7 @@
                   19690, 21835, 25356, 27731, 29157, 30362),
         76 },
     };
-
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
 static const aom_cdf_prob
     default_uv_mode_cdf[UV_MODE_CONTEXTS][CDF_SIZE(UV_INTRA_MODES - 1)] = {
       { AOM_CDF13(13848, 18930, 20641, 22133, 23986, 25450, 28075, 28950, 29740,
@@ -6205,9 +6205,11 @@
       { AOM_CDF3(10923, 21845), 30 },
       { AOM_CDF3(10923, 21845), 56 },
     };
+#if !CONFIG_PLT_DIR_CTX
 static const aom_cdf_prob default_palette_direction_cdf[CDF_SIZE(2)] = {
   AOM_CDF2(21697), 6
 };
+#endif  // !CONFIG_PLT_DIR_CTX
 #else
 static const aom_cdf_prob default_identity_row_cdf_y[3][CDF_SIZE(2)] = {
   { AOM_CDF2(16384), 28 },
@@ -6989,10 +6991,11 @@
 static const aom_cdf_prob default_pc_wiener_restore_cdf[CDF_SIZE(2)] = {
   AOM_CDF2(14330), 8
 };
-
+#if !CONFIG_MERGE_PARA_CTX
 static const aom_cdf_prob default_merged_param_cdf[CDF_SIZE(2)] = {
   AOM_CDF2(14319), 7
 };
+#endif  // !CONFIG_MERGE_PARA_CTX
 
 #if CONFIG_DELTAQ_OPT
 static const aom_cdf_prob default_delta_q_cdf[CDF_SIZE(DELTA_Q_PROBS + 1)] = {
@@ -7540,8 +7543,10 @@
 #if CONFIG_PALETTE_IMPROVEMENTS
   av1_copy(fc->identity_row_cdf_y, default_identity_row_cdf_y);
   av1_copy(fc->identity_row_cdf_uv, default_identity_row_cdf_uv);
+#if !CONFIG_PLT_DIR_CTX
 #if CONFIG_PALETTE_LINE_COPY
   av1_copy(fc->palette_direction_cdf, default_palette_direction_cdf);
+#endif  // !CONFIG_PLT_DIR_CTX
 #endif  // CONFIG_PALETTE_LINE_COPY
 #endif  // CONFIG_PALETTE_IMPROVEMENTS
   av1_copy(fc->palette_y_color_index_cdf, default_palette_y_color_index_cdf);
@@ -7691,10 +7696,14 @@
   av1_copy(fc->wienerns_uv_sym_cdf, default_wienerns_uv_sym_cdf);
   av1_copy(fc->wienerns_4part_cdf, default_wienerns_4part_cdf);
   av1_copy(fc->pc_wiener_restore_cdf, default_pc_wiener_restore_cdf);
+#if !CONFIG_MERGE_PARA_CTX
   av1_copy(fc->merged_param_cdf, default_merged_param_cdf);
+#endif  // CONFIG_MERGE_PARA_CTX
   av1_copy(fc->y_mode_set_cdf, default_y_mode_set_cdf);
   av1_copy(fc->y_mode_idx_cdf_0, default_y_first_mode_cdf);
+#if !CONFIG_CTX_Y_SECOND_MODE
   av1_copy(fc->y_mode_idx_cdf_1, default_y_second_mode_cdf);
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
   av1_copy(fc->uv_mode_cdf, default_uv_mode_cdf);
   av1_copy(fc->cfl_cdf, default_cfl_cdf);
   av1_copy(fc->mrl_index_cdf, default_mrl_index_cdf);
@@ -7985,8 +7994,10 @@
                          ctx_tr->coeff_base_lf_uv_cdf, LF_BASE_SYMBOLS);
   CUMULATIVE_AVERAGE_CDF(ctx_left->coeff_base_lf_eob_uv_cdf,
                          ctx_tr->coeff_base_lf_eob_uv_cdf, LF_BASE_SYMBOLS - 1);
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
   CUMULATIVE_AVERAGE_CDF(ctx_left->coeff_br_lf_uv_cdf,
                          ctx_tr->coeff_br_lf_uv_cdf, BR_CDF_SIZE);
+#endif
 
   CUMULATIVE_AVERAGE_CDF(ctx_left->inter_warp_mode_cdf,
                          ctx_tr->inter_warp_mode_cdf, 2);
@@ -8116,8 +8127,10 @@
                          ctx_tr->identity_row_cdf_y, 3);
   CUMULATIVE_AVERAGE_CDF(ctx_left->identity_row_cdf_uv,
                          ctx_tr->identity_row_cdf_uv, 3);
+#if !CONFIG_PLT_DIR_CTX
   CUMULATIVE_AVERAGE_CDF(ctx_left->palette_direction_cdf,
                          ctx_tr->palette_direction_cdf, 2);
+#endif  // !CONFIG_PLT_DIR_CTX
 #else
   CUMULATIVE_AVERAGE_CDF(ctx_left->identity_row_cdf_y,
                          ctx_tr->identity_row_cdf_y, 2);
@@ -8242,8 +8255,10 @@
                          ctx_tr->wienerns_4part_cdf, 4);
   CUMULATIVE_AVERAGE_CDF(ctx_left->pc_wiener_restore_cdf,
                          ctx_tr->pc_wiener_restore_cdf, 2);
+#if !CONFIG_MERGE_PARA_CTX
   CUMULATIVE_AVERAGE_CDF(ctx_left->merged_param_cdf, ctx_tr->merged_param_cdf,
                          2);
+#endif  // !CONFIG_MERGE_PARA_CTX
   CUMULATIVE_AVERAGE_CDF(ctx_left->fsc_mode_cdf, ctx_tr->fsc_mode_cdf,
                          FSC_MODES);
   CUMULATIVE_AVERAGE_CDF(ctx_left->mrl_index_cdf, ctx_tr->mrl_index_cdf,
@@ -8275,8 +8290,10 @@
                          INTRA_MODE_SETS);
   CUMULATIVE_AVERAGE_CDF(ctx_left->y_mode_idx_cdf_0, ctx_tr->y_mode_idx_cdf_0,
                          FIRST_MODE_COUNT);
+#if !CONFIG_CTX_Y_SECOND_MODE
   CUMULATIVE_AVERAGE_CDF(ctx_left->y_mode_idx_cdf_1, ctx_tr->y_mode_idx_cdf_1,
                          SECOND_MODE_COUNT);
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
   CUMULATIVE_AVERAGE_CDF(ctx_left->uv_mode_cdf, ctx_tr->uv_mode_cdf,
                          UV_INTRA_MODES - 1);
 
@@ -8376,7 +8393,9 @@
 
   CUMULATIVE_AVERAGE_CDF(ctx_left->coeff_base_ph_cdf, ctx_tr->coeff_base_ph_cdf,
                          4);
+#if !CONFIG_COEFF_BR_PH_BYPASS
   CUMULATIVE_AVERAGE_CDF(ctx_left->coeff_br_ph_cdf, ctx_tr->coeff_br_ph_cdf, 4);
+#endif
   CUMULATIVE_AVERAGE_CDF(ctx_left->cctx_type_cdf, ctx_tr->cctx_type_cdf,
                          CCTX_TYPES);
 }
@@ -8500,7 +8519,9 @@
   SHIFT_CDF(ctx_ptr->coeff_base_eob_uv_cdf, 3);
   SHIFT_CDF(ctx_ptr->coeff_base_lf_uv_cdf, LF_BASE_SYMBOLS);
   SHIFT_CDF(ctx_ptr->coeff_base_lf_eob_uv_cdf, LF_BASE_SYMBOLS - 1);
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
   SHIFT_CDF(ctx_ptr->coeff_br_lf_uv_cdf, BR_CDF_SIZE);
+#endif
 
   SHIFT_CDF(ctx_ptr->inter_warp_mode_cdf, 2);
 #if CONFIG_REDESIGN_WARP_MODES_SIGNALING_FLOW
@@ -8590,7 +8611,9 @@
 #if CONFIG_PALETTE_LINE_COPY
   SHIFT_CDF(ctx_ptr->identity_row_cdf_y, 3);
   SHIFT_CDF(ctx_ptr->identity_row_cdf_uv, 3);
+#if !CONFIG_PLT_DIR_CTX
   SHIFT_CDF(ctx_ptr->palette_direction_cdf, 2);
+#endif  // !CONFIG_PLT_DIR_CTX
 #else
   SHIFT_CDF(ctx_ptr->identity_row_cdf_y, 2);
   SHIFT_CDF(ctx_ptr->identity_row_cdf_uv, 2);
@@ -8678,7 +8701,9 @@
   SHIFT_CDF(ctx_ptr->wienerns_uv_sym_cdf, 2);
   SHIFT_CDF(ctx_ptr->wienerns_4part_cdf, 4);
   SHIFT_CDF(ctx_ptr->pc_wiener_restore_cdf, 2);
+#if !CONFIG_MERGE_PARA_CTX
   SHIFT_CDF(ctx_ptr->merged_param_cdf, 2);
+#endif  // !CONFIG_MERGE_PARA_CTX
   SHIFT_CDF(ctx_ptr->fsc_mode_cdf, FSC_MODES);
   SHIFT_CDF(ctx_ptr->mrl_index_cdf, MRL_LINE_NUMBER);
 #if CONFIG_MRLS_IMPROVE
@@ -8699,7 +8724,9 @@
 #endif  // CONFIG_ENABLE_MHCCP
   SHIFT_CDF(ctx_ptr->y_mode_set_cdf, INTRA_MODE_SETS);
   SHIFT_CDF(ctx_ptr->y_mode_idx_cdf_0, FIRST_MODE_COUNT);
+#if !CONFIG_CTX_Y_SECOND_MODE
   SHIFT_CDF(ctx_ptr->y_mode_idx_cdf_1, SECOND_MODE_COUNT);
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
   SHIFT_CDF(ctx_ptr->uv_mode_cdf, UV_INTRA_MODES - 1);
 
   SHIFT_CDF(ctx_ptr->region_type_cdf, REGION_TYPES);
@@ -8769,7 +8796,9 @@
   }
 
   SHIFT_CDF(ctx_ptr->coeff_base_ph_cdf, 4);
+#if !CONFIG_COEFF_BR_PH_BYPASS
   SHIFT_CDF(ctx_ptr->coeff_br_ph_cdf, 4);
+#endif
   SHIFT_CDF(ctx_ptr->cctx_type_cdf, CCTX_TYPES);
 }
 #endif  // CONFIG_TILE_CDFS_AVG_TO_FRAME
@@ -8934,8 +8963,10 @@
               LF_BASE_SYMBOLS);
   AVERAGE_CDF(ctx_left->coeff_base_lf_eob_uv_cdf,
               ctx_tr->coeff_base_lf_eob_uv_cdf, LF_BASE_SYMBOLS - 1);
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
   AVERAGE_CDF(ctx_left->coeff_br_lf_uv_cdf, ctx_tr->coeff_br_lf_uv_cdf,
               BR_CDF_SIZE);
+#endif
 
   AVERAGE_CDF(ctx_left->inter_warp_mode_cdf, ctx_tr->inter_warp_mode_cdf, 2);
 #if CONFIG_REDESIGN_WARP_MODES_SIGNALING_FLOW
@@ -9054,8 +9085,10 @@
 #if CONFIG_PALETTE_LINE_COPY
   AVERAGE_CDF(ctx_left->identity_row_cdf_y, ctx_tr->identity_row_cdf_y, 3);
   AVERAGE_CDF(ctx_left->identity_row_cdf_uv, ctx_tr->identity_row_cdf_uv, 3);
+#if !CONFIG_PLT_DIR_CTX
   AVERAGE_CDF(ctx_left->palette_direction_cdf, ctx_tr->palette_direction_cdf,
               2);
+#endif  // !CONFIG_PLT_DIR_CTX
 #else
   CUMULATIVE_AVERAGE_CDF(ctx_left->identity_row_cdf_y,
                          ctx_tr->identity_row_cdf_y, 2);
@@ -9153,7 +9186,9 @@
   AVERAGE_CDF(ctx_left->wienerns_4part_cdf, ctx_tr->wienerns_4part_cdf, 4);
   AVERAGE_CDF(ctx_left->pc_wiener_restore_cdf, ctx_tr->pc_wiener_restore_cdf,
               2);
+#if !CONFIG_MERGE_PARA_CTX
   AVERAGE_CDF(ctx_left->merged_param_cdf, ctx_tr->merged_param_cdf, 2);
+#endif  // !CONFIG_MERGE_PARA_CTX
   AVERAGE_CDF(ctx_left->fsc_mode_cdf, ctx_tr->fsc_mode_cdf, FSC_MODES);
   AVERAGE_CDF(ctx_left->mrl_index_cdf, ctx_tr->mrl_index_cdf, MRL_LINE_NUMBER);
 #if CONFIG_MRLS_IMPROVE
@@ -9179,8 +9214,10 @@
               INTRA_MODE_SETS);
   AVERAGE_CDF(ctx_left->y_mode_idx_cdf_0, ctx_tr->y_mode_idx_cdf_0,
               FIRST_MODE_COUNT);
+#if !CONFIG_CTX_Y_SECOND_MODE
   AVERAGE_CDF(ctx_left->y_mode_idx_cdf_1, ctx_tr->y_mode_idx_cdf_1,
               SECOND_MODE_COUNT);
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
   AVERAGE_CDF(ctx_left->uv_mode_cdf, ctx_tr->uv_mode_cdf, UV_INTRA_MODES - 1);
   AVERAGE_CDF(ctx_left->region_type_cdf, ctx_tr->region_type_cdf, REGION_TYPES);
 
@@ -9265,7 +9302,9 @@
   }
 
   AVERAGE_CDF(ctx_left->coeff_base_ph_cdf, ctx_tr->coeff_base_ph_cdf, 4);
+#if !CONFIG_COEFF_BR_PH_BYPASS
   AVERAGE_CDF(ctx_left->coeff_br_ph_cdf, ctx_tr->coeff_br_ph_cdf, 4);
+#endif
   AVERAGE_CDF(ctx_left->cctx_type_cdf, ctx_tr->cctx_type_cdf, CCTX_TYPES);
 }
 #endif  // CONFIG_ENHANCED_FRAME_CONTEXT_INIT

diff --git a/av1/common/entropymode.h b/av1/common/entropymode.h
index 5a04c23..154b58f 100644
--- a/av1/common/entropymode.h
+++ b/av1/common/entropymode.h

@@ -190,8 +190,12 @@
 #if CONFIG_CONTEXT_DERIVATION
   aom_cdf_prob v_txb_skip_cdf[V_TXB_SKIP_CONTEXTS][CDF_SIZE(2)];
 #endif  // CONFIG_CONTEXT_DERIVATION
+#if CONFIG_EOB_PT_CTX_REDUCTION
+  aom_cdf_prob eob_extra_cdf[CDF_SIZE(2)];
+#else
   aom_cdf_prob eob_extra_cdf[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS]
                             [CDF_SIZE(2)];
+#endif
   aom_cdf_prob dc_sign_cdf[PLANE_TYPES][DC_SIGN_GROUPS][DC_SIGN_CONTEXTS]
                           [CDF_SIZE(2)];
 #if CONFIG_CONTEXT_DERIVATION
@@ -249,7 +253,9 @@
 #endif  // CONFIG_TCQ
                                 [CDF_SIZE(4)];
   aom_cdf_prob coeff_base_eob_uv_cdf[SIG_COEF_CONTEXTS_EOB][CDF_SIZE(3)];
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
   aom_cdf_prob coeff_br_lf_uv_cdf[LF_LEVEL_CONTEXTS_UV][CDF_SIZE(BR_CDF_SIZE)];
+#endif
   aom_cdf_prob coeff_br_uv_cdf[LEVEL_CONTEXTS_UV][CDF_SIZE(BR_CDF_SIZE)];
   aom_cdf_prob idtx_sign_cdf[TX_SIZES][IDTX_SIGN_CONTEXTS][CDF_SIZE(2)];
   aom_cdf_prob coeff_base_cdf_idtx[TX_SIZES][IDTX_SIG_COEF_CONTEXTS]
@@ -259,8 +265,9 @@
   aom_cdf_prob coeff_base_bob_cdf[TX_SIZES][SIG_COEF_CONTEXTS_BOB][CDF_SIZE(3)];
   aom_cdf_prob coeff_base_ph_cdf[COEFF_BASE_PH_CONTEXTS]
                                 [CDF_SIZE(NUM_BASE_LEVELS + 2)];
+#if !CONFIG_COEFF_BR_PH_BYPASS
   aom_cdf_prob coeff_br_ph_cdf[COEFF_BR_PH_CONTEXTS][CDF_SIZE(BR_CDF_SIZE)];
-
+#endif
 #if CONFIG_OPT_INTER_MODE_CTX
   aom_cdf_prob inter_single_mode_cdf[INTER_MODE_CONTEXTS]
                                     [CDF_SIZE(INTER_SINGLE_MODES)];
@@ -422,7 +429,9 @@
 #if CONFIG_PALETTE_LINE_COPY
   aom_cdf_prob identity_row_cdf_y[PALETTE_ROW_FLAG_CONTEXTS][CDF_SIZE(3)];
   aom_cdf_prob identity_row_cdf_uv[PALETTE_ROW_FLAG_CONTEXTS][CDF_SIZE(3)];
+#if !CONFIG_PLT_DIR_CTX
   aom_cdf_prob palette_direction_cdf[CDF_SIZE(2)];
+#endif  // !CONFIG_PLT_DIR_CTX
 #else
   aom_cdf_prob identity_row_cdf_y[PALETTE_ROW_FLAG_CONTEXTS][CDF_SIZE(2)];
   aom_cdf_prob identity_row_cdf_uv[PALETTE_ROW_FLAG_CONTEXTS][CDF_SIZE(2)];
@@ -548,7 +557,9 @@
   aom_cdf_prob wienerns_uv_sym_cdf[CDF_SIZE(2)];
   aom_cdf_prob wienerns_4part_cdf[WIENERNS_4PART_CTX_MAX][CDF_SIZE(4)];
   aom_cdf_prob pc_wiener_restore_cdf[CDF_SIZE(2)];
+#if !CONFIG_MERGE_PARA_CTX
   aom_cdf_prob merged_param_cdf[CDF_SIZE(2)];
+#endif  // !CONFIG_MERGE_PARA_CTX
 #if CONFIG_IMPROVED_INTRA_DIR_PRED
   aom_cdf_prob mrl_index_cdf[MRL_INDEX_CONTEXTS][CDF_SIZE(MRL_LINE_NUMBER)];
 #else
@@ -582,7 +593,9 @@
   // y mode cdf
   aom_cdf_prob y_mode_set_cdf[CDF_SIZE(INTRA_MODE_SETS)];
   aom_cdf_prob y_mode_idx_cdf_0[Y_MODE_CONTEXTS][CDF_SIZE(FIRST_MODE_COUNT)];
+#if !CONFIG_CTX_Y_SECOND_MODE
   aom_cdf_prob y_mode_idx_cdf_1[Y_MODE_CONTEXTS][CDF_SIZE(SECOND_MODE_COUNT)];
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
   aom_cdf_prob uv_mode_cdf[UV_MODE_CONTEXTS][CDF_SIZE(UV_INTRA_MODES - 1)];
   aom_cdf_prob cfl_cdf[CFL_CONTEXTS][CDF_SIZE(2)];
   aom_cdf_prob do_split_cdf[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS]

diff --git a/av1/common/token_cdfs.h b/av1/common/token_cdfs.h
index 837e2c8..4d9fa22 100644
--- a/av1/common/token_cdfs.h
+++ b/av1/common/token_cdfs.h

@@ -1145,6 +1145,15 @@
       },
     };
 
+#if CONFIG_EOB_PT_CTX_REDUCTION
+static const aom_cdf_prob av1_default_eob_extra_cdfs[TOKEN_CDF_Q_CTXS]
+                                                    [CDF_SIZE(2)] = {
+                                                      { AOM_CDF2(16384), 0 },
+                                                      { AOM_CDF2(16384), 0 },
+                                                      { AOM_CDF2(16384), 0 },
+                                                      { AOM_CDF2(16384), 0 },
+                                                    };
+#else
 static const aom_cdf_prob
     av1_default_eob_extra_cdfs[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
                               [EOB_COEF_CONTEXTS][CDF_SIZE(2)] = {
@@ -1637,6 +1646,7 @@
                                     },
                                 },
                               };
+#endif
 
 #if CONFIG_EOB_POS_LUMA
 static const aom_cdf_prob
@@ -10326,7 +10336,7 @@
                                         { AOM_CDF4(7108, 15722, 21972), 90 },
                                     },
                                   };
-
+#if !CONFIG_COEFF_BR_PH_BYPASS
 static const aom_cdf_prob
     av1_default_coeff_br_ph_cdfs[TOKEN_CDF_Q_CTXS][COEFF_BR_PH_CONTEXTS]
                                 [CDF_SIZE(BR_CDF_SIZE)] = {
@@ -10367,6 +10377,7 @@
                                       { AOM_CDF4(6535, 12315, 17263), 101 },
                                   },
                                 };
+#endif
 
 #if CONFIG_DIP
 static const aom_cdf_prob default_intra_dip_mode_n6_cdf[CDF_SIZE(6)] = {

diff --git a/av1/common/txb_common.h b/av1/common/txb_common.h
index 07792b0..2ef6811 100644
--- a/av1/common/txb_common.h
+++ b/av1/common/txb_common.h

@@ -147,11 +147,13 @@
   return mag;
 }
 
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
 static AOM_FORCE_INLINE int get_br_ctx_lf_eob_chroma(const int c,
                                                      const TX_CLASS tx_class) {
   if (tx_class == TX_CLASS_2D && c == 0) return 0;
   return 4;
 }
+#endif
 
 static INLINE int get_br_ctx_2d_chroma(const uint8_t *const levels, const int c,
                                        const int bwl) {
@@ -193,6 +195,7 @@
   return mag + 4;
 }
 
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
 // This function returns the low range context index/increment for the
 // coefficients residing in the low-frequency region for 1D and 2D
 // transforms and covers the 1D and 2D TX DC terms. For chroma only.
@@ -225,6 +228,7 @@
   }
   return mag + 4;
 }
+#endif
 
 // This function returns the low range context index/increment for the
 // coefficients residing in the higher-frequency default region

diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index d01e782..1c98604 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c

@@ -3200,12 +3200,18 @@
   }
 }
 
-static AOM_INLINE void read_wiener_filter(MACROBLOCKD *xd, int wiener_win,
-                                          WienerInfo *wiener_info,
-                                          WienerInfoBank *bank,
-                                          aom_reader *rb) {
+static AOM_INLINE void read_wiener_filter(
+#if !CONFIG_MERGE_PARA_CTX
+    MACROBLOCKD *xd,
+#endif  // !CONFIG_MERGE_PARA_CTX
+    int wiener_win, WienerInfo *wiener_info, WienerInfoBank *bank,
+    aom_reader *rb) {
+#if CONFIG_MERGE_PARA_CTX
+  const int exact_match = aom_read_bit(rb, ACCT_INFO("exact_match"));
+#else
   const int exact_match = aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf, 2,
                                           ACCT_INFO("exact_match"));
+#endif  // CONFIG_MERGE_PARA_CTX
   int k;
   for (k = 0; k < bank->bank_size - 1; ++k) {
     if (aom_read_literal(rb, 1, ACCT_INFO("bank_size"))) break;
@@ -3282,12 +3288,17 @@
   av1_add_to_wiener_bank(bank, wiener_info);
 }
 
-static AOM_INLINE void read_sgrproj_filter(MACROBLOCKD *xd,
-                                           SgrprojInfo *sgrproj_info,
-                                           SgrprojInfoBank *bank,
-                                           aom_reader *rb) {
+static AOM_INLINE void read_sgrproj_filter(
+#if !CONFIG_MERGE_PARA_CTX
+    MACROBLOCKD *xd,
+#endif  // !CONFIG_MERGE_PARA_CTX
+    SgrprojInfo *sgrproj_info, SgrprojInfoBank *bank, aom_reader *rb) {
+#if CONFIG_MERGE_PARA_CTX
+  const int exact_match = aom_read_bit(rb, ACCT_INFO("exact_match"));
+#else
   const int exact_match = aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf, 2,
                                           ACCT_INFO("exact_match"));
+#endif  // CONFIG_MERGE_PARA_CTX
   int k;
   for (k = 0; k < bank->bank_size - 1; ++k) {
     if (aom_read_literal(rb, 1, ACCT_INFO("bank"))) break;
@@ -3445,8 +3456,12 @@
   read_match_indices(&rsi->frame_filters, rb, nopcw);
 #endif  // CONFIG_COMBINE_PC_NS_WIENER_ADD
   for (int c_id = 0; c_id < num_classes; ++c_id) {
+#if CONFIG_MERGE_PARA_CTX
+    const int exact_match = aom_read_bit(rb, ACCT_INFO("exact_match"));
+#else
     const int exact_match = aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf,
                                             2, ACCT_INFO("exact_match"));
+#endif  // CONFIG_MERGE_PARA_CTX
     skip_filter_read_for_class[c_id] = exact_match;
   }
   const WienernsFilterParameters *nsfilter_params =
@@ -3543,8 +3558,12 @@
   if (rsi->frame_filters_on) return;
 #endif  // CONFIG_COMBINE_PC_NS_WIENER
   for (int c_id = 0; c_id < num_classes; ++c_id) {
+#if CONFIG_MERGE_PARA_CTX
+    const int exact_match = aom_read_bit(rb, ACCT_INFO("exact_match"));
+#else
     const int exact_match = aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf,
                                             2, ACCT_INFO("exact_match"));
+#endif  // CONFIG_MERGE_PARA_CTX
     int ref;
     for (ref = 0; ref < bank->bank_size_for_class[c_id] - 1; ++ref) {
       if (aom_read_literal(rb, 1, ACCT_INFO("bank"))) break;
@@ -3656,12 +3675,18 @@
     }
     switch (rui->restoration_type) {
       case RESTORE_WIENER:
-        read_wiener_filter(xd, wiener_win, &rui->wiener_info,
-                           &xd->wiener_info[plane], r);
+        read_wiener_filter(
+#if !CONFIG_MERGE_PARA_CTX
+            xd,
+#endif  // !CONFIG_MERGE_PARA_CTX
+            wiener_win, &rui->wiener_info, &xd->wiener_info[plane], r);
         break;
       case RESTORE_SGRPROJ:
-        read_sgrproj_filter(xd, &rui->sgrproj_info, &xd->sgrproj_info[plane],
-                            r);
+        read_sgrproj_filter(
+#if !CONFIG_MERGE_PARA_CTX
+            xd,
+#endif  // !CONFIG_MERGE_PARA_CTX
+            &rui->sgrproj_info, &xd->sgrproj_info[plane], r);
         break;
       case RESTORE_WIENER_NONSEP:
         read_wienerns_filter(xd, plane != AOM_PLANE_Y, rsi, &rui->wienerns_info,
@@ -3676,8 +3701,11 @@
     if (aom_read_symbol(r, xd->tile_ctx->wiener_restore_cdf, 2,
                         ACCT_INFO("wiener_restore_cdf"))) {
       rui->restoration_type = RESTORE_WIENER;
-      read_wiener_filter(xd, wiener_win, &rui->wiener_info,
-                         &xd->wiener_info[plane], r);
+      read_wiener_filter(
+#if !CONFIG_MERGE_PARA_CTX
+          xd,
+#endif  // !CONFIG_MERGE_PARA_CTX
+          wiener_win, &rui->wiener_info, &xd->wiener_info[plane], r);
     } else {
       rui->restoration_type = RESTORE_NONE;
     }
@@ -3685,7 +3713,11 @@
     if (aom_read_symbol(r, xd->tile_ctx->sgrproj_restore_cdf, 2,
                         ACCT_INFO("sgrproj_restore_cdf"))) {
       rui->restoration_type = RESTORE_SGRPROJ;
-      read_sgrproj_filter(xd, &rui->sgrproj_info, &xd->sgrproj_info[plane], r);
+      read_sgrproj_filter(
+#if !CONFIG_MERGE_PARA_CTX
+          xd,
+#endif  // !CONFIG_MERGE_PARA_CTX
+          &rui->sgrproj_info, &xd->sgrproj_info[plane], r);
     } else {
       rui->restoration_type = RESTORE_NONE;
     }

diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 33a6137..e32cc67 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c

@@ -702,6 +702,12 @@
   }
   int max_idx_bits = mbmi->max_num_warp_candidates - 1;
   for (int bit_idx = 0; bit_idx < max_idx_bits; ++bit_idx) {
+    if ((CONFIG_CTX_WARP_REFIDX_REDUCTION >> bit_idx) & 1) {
+      int warp_idx = aom_read_literal(r, 1, ACCT_INFO("warp_idx"));
+      mbmi->warp_ref_idx = bit_idx + warp_idx;
+      if (!warp_idx) break;
+      continue;
+    }
     aom_cdf_prob *warp_ref_idx_cdf = av1_get_warp_ref_idx_cdf(ec_ctx, bit_idx);
     int warp_idx =
         aom_read_symbol(r, warp_ref_idx_cdf, 2, ACCT_INFO("warp_idx"));
@@ -748,10 +754,15 @@
 #if CONFIG_WARP_PRECISION
   if (max_coded_index >= WARP_DELTA_NUMSYMBOLS_LOW &&
       coded_value >= (WARP_DELTA_NUMSYMBOLS_LOW - 1)) {
+#if CONFIG_BYPASS_WARP_PARAM_HIGH
+    coded_value =
+        7 + aom_read_literal(r, WARP_DELTA_NUMSYMBOLS_HIGH, ACCT_INFO());
+#else
     coded_value =
         7 + aom_read_symbol(r,
                             xd->tile_ctx->warp_delta_param_high_cdf[index_type],
                             WARP_DELTA_NUMSYMBOLS_HIGH, ACCT_INFO());
+#endif  //
   }
 #endif  // CONFIG_WARP_PRECISION
 
@@ -815,8 +826,13 @@
       decoded_delta_param[index] = coded_value;
       // decode sign
       if (coded_value) {
+#if CONFIG_BYPASS_WARP_PARAM_SIGN
+        int sign = aom_read_bit(r, ACCT_INFO());
+#else
+
         int sign = aom_read_symbol(r, xd->tile_ctx->warp_param_sign_cdf, 2,
                                    ACCT_INFO());
+#endif
         decoded_delta_param[index] = sign ? -coded_value : coded_value;
       }
 #else
@@ -2077,16 +2093,27 @@
 }
 
 #if CONFIG_IBC_BV_IMPROVEMENT
-static void read_intrabc_drl_idx(int max_ref_bv_cnt, FRAME_CONTEXT *ec_ctx,
+static void read_intrabc_drl_idx(int max_ref_bv_cnt,
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
+                                 FRAME_CONTEXT *ec_ctx,
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
                                  MB_MODE_INFO *mbmi, aom_reader *r) {
   mbmi->intrabc_drl_idx = 0;
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
   int bit_cnt = 0;
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
   for (int idx = 0; idx < max_ref_bv_cnt - 1; ++idx) {
+#if CONFIG_BYPASS_INTRABC_DRL_IDX
+    const int intrabc_drl_idx = aom_read_bit(r, ACCT_INFO());
+#else
     const int intrabc_drl_idx = aom_read_symbol(
         r, ec_ctx->intrabc_drl_idx_cdf[bit_cnt], 2, ACCT_INFO());
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
     mbmi->intrabc_drl_idx = idx + intrabc_drl_idx;
     if (!intrabc_drl_idx) break;
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
     ++bit_cnt;
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
   }
   assert(mbmi->intrabc_drl_idx < max_ref_bv_cnt);
 }
@@ -2159,7 +2186,11 @@
     mbmi->intrabc_mode =
         aom_read_symbol(r, ec_ctx->intrabc_mode_cdf, 2, ACCT_INFO());
 #if CONFIG_IBC_MAX_DRL
-    read_intrabc_drl_idx(cm->features.max_bvp_drl_bits + 1, ec_ctx, mbmi, r);
+    read_intrabc_drl_idx(cm->features.max_bvp_drl_bits + 1,
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
+                         ec_ctx,
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
+                         mbmi, r);
 #else
     read_intrabc_drl_idx(MAX_REF_BV_STACK_SIZE, ec_ctx, mbmi, r);
 #endif  // CONFIG_IBC_MAX_DRL
@@ -2280,10 +2311,14 @@
         aom_read_symbol(r, ec_ctx->y_mode_idx_cdf_0[context], FIRST_MODE_COUNT,
                         ACCT_INFO("mode_idx", "y_mode_idx_cdf_0"));
   } else {
-    mode_idx =
-        FIRST_MODE_COUNT + (mode_set_index - 1) * SECOND_MODE_COUNT +
-        aom_read_symbol(r, ec_ctx->y_mode_idx_cdf_1[context], SECOND_MODE_COUNT,
-                        ACCT_INFO("mode_idx", "y_mode_idx_cdf_1"));
+    mode_idx = FIRST_MODE_COUNT + (mode_set_index - 1) * SECOND_MODE_COUNT +
+#if CONFIG_CTX_Y_SECOND_MODE
+               aom_read_literal(r, 4, ACCT_INFO("mode_idx"));
+#else
+               aom_read_symbol(r, ec_ctx->y_mode_idx_cdf_1[context],
+                               SECOND_MODE_COUNT,
+                               ACCT_INFO("mode_idx", "y_mode_idx_cdf_1"));
+#endif  // CONFIG_CTX_Y_SECOND_MODE
   }
   assert(mode_idx < LUMA_MODE_COUNT);
   get_y_intra_mode_set(mbmi, xd);
@@ -2948,6 +2983,9 @@
     const int num_of_bits_for_this_offset =
         (shell_class == 0) ? 1 : shell_class;
     for (int i = 0; i < num_of_bits_for_this_offset; ++i) {
+#if CONFIG_CTX_MV_SHELL_OFFSET_OTHER
+      shell_cls_offset |= aom_read_bit(r, ACCT_INFO("offset")) << i;
+#else
       shell_cls_offset |=
 #if CONFIG_CTX_MV_SHELL_OFFSET_OTHER
           aom_read_bit(r, ACCT_INFO("offset"))
@@ -2956,6 +2994,7 @@
                           ACCT_INFO("offset"))
 #endif  // CONFIG_CTX_MV_SHELL_OFFSET_OTHER
           << i;
+#endif
     }
   }
 

diff --git a/av1/decoder/decodetxb.c b/av1/decoder/decodetxb.c
index 1af82e3..6d7e39b 100644
--- a/av1/decoder/decodetxb.c
+++ b/av1/decoder/decodetxb.c

@@ -157,8 +157,18 @@
                                   ,
                                   int *hr_avg
 #endif
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+                                  ,
+                                  int plane
+#endif
 ) {
+#if CONFIG_COEFF_BR_LF_UV_BYPASS                        // code_hr_t
+  int max_br = lf ? (plane == 0 ? LF_MAX_BASE_BR_RANGE  // 8
+                                : LF_NUM_BASE_LEVELS + 1)
+                  : MAX_BASE_BR_RANGE;
+#else
   int max_br = lf ? LF_MAX_BASE_BR_RANGE : MAX_BASE_BR_RANGE;
+#endif
   int use_tcq_hr = tcq_mode && (level >= max_br - 1);
 #if CONFIG_COEFF_HR_ADAPTIVE
   int hr_level_avg = *hr_avg;
@@ -208,7 +218,10 @@
     aom_reader *r, int start_si, int end_si, const int16_t *scan, int bwl,
     uint8_t *levels, base_lf_cdf_arr base_lf_cdf, br_cdf_arr br_lf_cdf,
     int plane, base_cdf_arr base_cdf, br_cdf_arr br_cdf,
-    base_lf_cdf_arr base_lf_uv_cdf, br_cdf_arr br_lf_uv_cdf,
+    base_lf_cdf_arr base_lf_uv_cdf,
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
+    br_cdf_arr br_lf_uv_cdf,
+#endif
     base_cdf_arr base_uv_cdf, br_cdf_arr br_uv_cdf
 #if CONFIG_TCQ
     ,
@@ -236,11 +249,13 @@
         level += aom_read_symbol(r, base_lf_uv_cdf[coeff_ctx], LF_BASE_SYMBOLS,
                                  ACCT_INFO("level", "base_lf_uv_cdf"));
 #endif  // CONFIG_TCQ
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
         if (level > LF_NUM_BASE_LEVELS) {
           const int br_ctx = get_br_lf_ctx_2d_chroma(levels, pos, bwl);
           aom_cdf_prob *cdf = br_lf_uv_cdf[br_ctx];
           level += read_low_range(r, cdf);
         }
+#endif
       } else {
         const int coeff_ctx =
             get_lower_levels_ctx_2d_chroma(levels, pos, bwl, plane);
@@ -300,7 +315,10 @@
     aom_reader *r, TX_CLASS tx_class, int start_si, int end_si,
     const int16_t *scan, int bwl, uint8_t *levels, base_lf_cdf_arr base_lf_cdf,
     br_cdf_arr br_lf_cdf, int plane, base_cdf_arr base_cdf, br_cdf_arr br_cdf,
-    base_lf_cdf_arr base_lf_uv_cdf, br_cdf_arr br_lf_uv_cdf,
+    base_lf_cdf_arr base_lf_uv_cdf,
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
+    br_cdf_arr br_lf_uv_cdf,
+#endif
     base_cdf_arr base_uv_cdf, br_cdf_arr br_uv_cdf
 #if CONFIG_TCQ
     ,
@@ -329,11 +347,13 @@
         level += aom_read_symbol(r, base_lf_uv_cdf[coeff_ctx], LF_BASE_SYMBOLS,
                                  ACCT_INFO("level", "base_lf_uv_cdf"));
 #endif  // CONFIG_TCQ
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
         if (level > LF_NUM_BASE_LEVELS) {
           const int br_ctx = get_br_lf_ctx_chroma(levels, pos, bwl, tx_class);
           aom_cdf_prob *cdf = br_lf_uv_cdf[br_ctx];
           level += read_low_range(r, cdf);
         }
+#endif
       } else {
         const int coeff_ctx =
             get_lower_levels_ctx_chroma(levels, pos, bwl, tx_class, plane);
@@ -421,7 +441,9 @@
 #endif
 ) {
   MACROBLOCKD *const xd = &dcb->xd;
+#if !CONFIG_EOB_PT_CTX_REDUCTION
   const PLANE_TYPE plane_type = get_plane_type(plane);
+#endif
   FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
 #if CONFIG_EOB_POS_LUMA
   const int is_inter = is_inter_block(xd->mi[0], xd->tree_type);
@@ -429,8 +451,9 @@
 #else
   const int pl_ctx = plane_type;
 #endif  // CONFIG_EOB_POS_LUMA
-
+#if !CONFIG_EOB_PT_CTX_REDUCTION
   const TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size);
+#endif
   eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
   uint16_t *const eob = &(eob_data->eob);
   eob_info *bob_data = dcb->bob_data[plane] + dcb->txb_offset[plane];
@@ -515,10 +538,17 @@
 
   const int eob_offset_bits = av1_eob_offset_bits[eob_pt];
   if (eob_offset_bits > 0) {
+#if !CONFIG_EOB_PT_CTX_REDUCTION
     const int eob_ctx = eob_pt - 3;
+#endif
     int bit =
+#if CONFIG_EOB_PT_CTX_REDUCTION
+        aom_read_symbol(r, ec_ctx->eob_extra_cdf, 2,
+                        ACCT_INFO("eob_extra_cdf"));
+#else
         aom_read_symbol(r, ec_ctx->eob_extra_cdf[txs_ctx][plane_type][eob_ctx],
                         2, ACCT_INFO("eob_extra_cdf"));
+#endif
     if (bit) {
       eob_extra += (1 << (eob_offset_bits - 1));
     }
@@ -781,6 +811,10 @@
                               ,
                               &hr_level_avg
 #endif
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+                              ,
+                              plane
+#endif
       );
 #endif
       if (c == 0) dc_val = sign ? -level : level;
@@ -816,18 +850,24 @@
 static INLINE tran_low_t read_coeff_hidden(aom_reader *r, TX_CLASS tx_class,
                                            const int16_t *scan, int bwl,
                                            uint8_t *levels, int parity,
-                                           base_ph_cdf_arr base_cdf_ph,
-                                           br_cdf_arr br_cdf_ph) {
+                                           base_ph_cdf_arr base_cdf_ph
+#if !CONFIG_COEFF_BR_PH_BYPASS
+                                           ,
+                                           br_cdf_arr br_cdf_ph
+#endif
+) {
   int q_index;
   const int pos = scan[0];
   int ctx_idx = get_base_ctx_ph(levels, pos, bwl, tx_class);
   q_index = aom_read_symbol(r, base_cdf_ph[ctx_idx], 4, ACCT_INFO("q_index"));
 
+#if !CONFIG_COEFF_BR_PH_BYPASS
   if (q_index > NUM_BASE_LEVELS) {
     ctx_idx = get_par_br_ctx(levels, pos, bwl, tx_class);
     aom_cdf_prob *cdf_br = br_cdf_ph[ctx_idx];
     q_index += read_low_range(r, cdf_br);
   }
+#endif
   assert(q_index <= MAX_BASE_BR_RANGE);
   uint8_t level = (q_index << 1) + parity;
   levels[get_padded_idx(pos, bwl)] = level;
@@ -936,12 +976,13 @@
             aom_read_symbol(r, cdf, LF_BASE_SYMBOLS - 1,
                             ACCT_INFO("level", "coeff_base_lf_eob_uv_cdf")) +
             1;
-
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
         if (level > LF_NUM_BASE_LEVELS) {
           const int br_ctx = get_br_ctx_lf_eob_chroma(pos, tx_class);
           cdf = ec_ctx->coeff_br_lf_uv_cdf[br_ctx];
           level += read_low_range(r, cdf);
         }
+#endif
       } else {
         aom_cdf_prob *cdf = ec_ctx->coeff_base_eob_uv_cdf[coeff_ctx];
         level += aom_read_symbol(r, cdf, 3,
@@ -997,14 +1038,19 @@
     base_cdf_arr base_cdf = ec_ctx->coeff_base_cdf[txs_ctx];
     br_cdf_arr br_cdf = ec_ctx->coeff_br_cdf;
     base_lf_cdf_arr base_lf_uv_cdf = ec_ctx->coeff_base_lf_uv_cdf;
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
     br_cdf_arr br_lf_uv_cdf = ec_ctx->coeff_br_lf_uv_cdf;
+#endif
     base_cdf_arr base_uv_cdf = ec_ctx->coeff_base_uv_cdf;
     br_cdf_arr br_uv_cdf = ec_ctx->coeff_br_uv_cdf;
 
     if (tx_class == TX_CLASS_2D) {
       read_coeffs_reverse_2d(r, 1, *eob - 2, scan, bwl, levels, base_lf_cdf,
                              br_lf_cdf, plane, base_cdf, br_cdf, base_lf_uv_cdf,
-                             br_lf_uv_cdf, base_uv_cdf, br_uv_cdf
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
+                             br_lf_uv_cdf,
+#endif
+                             base_uv_cdf, br_uv_cdf
 #if CONFIG_TCQ
                              ,
                              &state
@@ -1024,11 +1070,19 @@
       }
       if (is_hidden) {
         read_coeff_hidden(r, tx_class, scan, bwl, levels, (sum_abs1 & 1),
-                          ec_ctx->coeff_base_ph_cdf, ec_ctx->coeff_br_ph_cdf);
+                          ec_ctx->coeff_base_ph_cdf
+#if !CONFIG_COEFF_BR_PH_BYPASS
+                          ,
+                          ec_ctx->coeff_br_ph_cdf
+#endif
+        );
       } else {
         read_coeffs_reverse(r, tx_class, 0, 0, scan, bwl, levels, base_lf_cdf,
                             br_lf_cdf, plane, base_cdf, br_cdf, base_lf_uv_cdf,
-                            br_lf_uv_cdf, base_uv_cdf, br_uv_cdf
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
+                            br_lf_uv_cdf,
+#endif
+                            base_uv_cdf, br_uv_cdf
 #if CONFIG_TCQ
                             ,
                             &state
@@ -1038,7 +1092,11 @@
     } else {
       read_coeffs_reverse(r, tx_class, 1, *eob - 2, scan, bwl, levels,
                           base_lf_cdf, br_lf_cdf, plane, base_cdf, br_cdf,
-                          base_lf_uv_cdf, br_lf_uv_cdf, base_uv_cdf, br_uv_cdf
+                          base_lf_uv_cdf,
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
+                          br_lf_uv_cdf,
+#endif
+                          base_uv_cdf, br_uv_cdf
 #if CONFIG_TCQ
                           ,
                           &state
@@ -1058,11 +1116,19 @@
       }
       if (is_hidden) {
         read_coeff_hidden(r, tx_class, scan, bwl, levels, (sum_abs1 & 1),
-                          ec_ctx->coeff_base_ph_cdf, ec_ctx->coeff_br_ph_cdf);
+                          ec_ctx->coeff_base_ph_cdf
+#if !CONFIG_COEFF_BR_PH_BYPASS
+                          ,
+                          ec_ctx->coeff_br_ph_cdf
+#endif
+        );
       } else {
         read_coeffs_reverse(r, tx_class, 0, 0, scan, bwl, levels, base_lf_cdf,
                             br_lf_cdf, plane, base_cdf, br_cdf, base_lf_uv_cdf,
-                            br_lf_uv_cdf, base_uv_cdf, br_uv_cdf
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
+                            br_lf_uv_cdf,
+#endif
+                            base_uv_cdf, br_uv_cdf
 #if CONFIG_TCQ
                             ,
                             &state
@@ -1101,11 +1167,16 @@
               ec_ctx->dc_sign_cdf[plane_type][is_hidden ? 1 : 0][dc_sign_ctx],
               2, ACCT_INFO("sign", "dc_sign_cdf", "plane_y_or_u"));
         } else {
+#if CONFIG_BY_PASS_V_SIGN
+          sign = aom_read_literal(
+              r, 1, ACCT_INFO("sign", "v_dc_sign_cdf", "plane_v"));
+#else
           int32_t tmp_sign = 0;
           if (c < xd->eob_u) tmp_sign = xd->tmp_sign[tmp_sign_idx];
           sign =
               aom_read_symbol(r, ec_ctx->v_dc_sign_cdf[tmp_sign][dc_sign_ctx],
                               2, ACCT_INFO("sign", "v_dc_sign_cdf", "plane_v"));
+#endif
         }
         if (plane == AOM_PLANE_U) xd->tmp_sign[tmp_sign_idx] = (sign ? 2 : 1);
 #else
@@ -1129,6 +1200,13 @@
       }
 
       if (is_hidden && c == 0) {
+#if CONFIG_COEFF_BR_PH_BYPASS
+        if (level >= ((NUM_BASE_LEVELS + 1) << 1)) {
+          int hr_level = (read_adaptive_hr(xd, r, hr_level_avg >> 1) << 1);
+          level += hr_level;
+          hr_level_avg = (hr_level_avg + hr_level) >> 1;
+        }
+#else
         if (level >= (MAX_BASE_BR_RANGE << 1)) {
 #if CONFIG_COEFF_HR_ADAPTIVE
           int hr_level = (read_adaptive_hr(xd, r, hr_level_avg >> 1) << 1);
@@ -1138,6 +1216,7 @@
           level += (read_exp_golomb(xd, r, 0) << 1);
 #endif  // CONFIG_COEFF_HR_ADAPTIVE
         }
+#endif
       } else {
         int limits = get_lf_limits(row, col, tx_class, plane);
 #if !CONFIG_TCQ /* read_high_range / hr_adap */
@@ -1168,6 +1247,10 @@
                                 ,
                                 &hr_level_avg
 #endif
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+                                ,
+                                plane
+#endif
         );
 #endif
       }

diff --git a/av1/decoder/detokenize.c b/av1/decoder/detokenize.c
index 7ccdc4a..7af01c7 100644
--- a/av1/decoder/detokenize.c
+++ b/av1/decoder/detokenize.c

@@ -37,7 +37,11 @@
       plane_block_width < 64 && plane_block_height < 64;
   int direction;
   if (transverse_allowed) {
+#if CONFIG_PLT_DIR_CTX
+    direction = aom_read_bit(r, ACCT_INFO());
+#else
     direction = aom_read_symbol(r, param->direction_cdf, 2, ACCT_INFO());
+#endif  // CONFIG_PLT_DIR_CTX
   } else {
     direction = 0;
   }
@@ -204,8 +208,10 @@
 #if CONFIG_PALETTE_IMPROVEMENTS
   params.identity_row_cdf = plane ? xd->tile_ctx->identity_row_cdf_uv
                                   : xd->tile_ctx->identity_row_cdf_y;
+#if !CONFIG_PLT_DIR_CTX
 #if CONFIG_PALETTE_LINE_COPY
   params.direction_cdf = xd->tile_ctx->palette_direction_cdf;
+#endif  // !CONFIG_PLT_DIR_CTX
 #endif  // CONFIG_PALETTE_LINE_COPY
 #endif  // CONFIG_PALETTE_IMPROVEMENTS
   const MB_MODE_INFO *const mbmi = xd->mi[0];

diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index faf246c..39eec6b 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c

@@ -226,6 +226,11 @@
   }
   int max_idx_bits = mbmi->max_num_warp_candidates - 1;
   for (int bit_idx = 0; bit_idx < max_idx_bits; ++bit_idx) {
+    if ((CONFIG_CTX_WARP_REFIDX_REDUCTION >> bit_idx) & 1) {
+      aom_write_literal(w, mbmi->warp_ref_idx != bit_idx, 1);
+      if (mbmi->warp_ref_idx == bit_idx) break;
+      continue;
+    }
     aom_cdf_prob *warp_ref_idx_cdf = av1_get_warp_ref_idx_cdf(ec_ctx, bit_idx);
     aom_write_symbol(w, mbmi->warp_ref_idx != bit_idx, warp_ref_idx_cdf, 2);
 
@@ -727,9 +732,14 @@
 #if CONFIG_WARP_PRECISION
   if (max_coded_index >= WARP_DELTA_NUMSYMBOLS_LOW &&
       coded_value >= coded_value_low_max) {
+#if CONFIG_BYPASS_WARP_PARAM_HIGH
+    aom_write_literal(w, coded_value - 7, WARP_DELTA_NUMSYMBOLS_HIGH);
+
+#else
     aom_write_symbol(w, coded_value - 7,
                      xd->tile_ctx->warp_delta_param_high_cdf[index_type],
                      WARP_DELTA_NUMSYMBOLS_HIGH);
+#endif
   }
 #endif  // CONFIG_WARP_PRECISION
 }
@@ -783,8 +793,12 @@
                            max_coded_index);
     // Code sign
     if (coded_delta_param[index]) {
+#if CONFIG_BYPASS_WARP_PARAM_SIGN
+      aom_write_bit(w, coded_delta_param[index] < 0);
+#else
       aom_write_symbol(w, coded_delta_param[index] < 0,
                        xd->tile_ctx->warp_param_sign_cdf, 2);
+#endif
     }
 #else
     coded_delta_param[index] = (value / step_size) + max_coded_index;
@@ -1013,7 +1027,11 @@
 #if CONFIG_PALETTE_LINE_COPY
   const int direction = (direction_allowed) ? p->direction : 0;
   if (direction_allowed) {
+#if CONFIG_PLT_DIR_CTX
+    aom_write_bit(w, p->direction);
+#else
     aom_write_symbol(w, p->direction, xd->tile_ctx->palette_direction_cdf, 2);
+#endif  // CONFIG_PLT_DIR_CTX
   }
 #else
   const int direction = 0;
@@ -2233,10 +2251,17 @@
     aom_write_symbol(w, mode_idx, ec_ctx->y_mode_idx_cdf_0[context],
                      FIRST_MODE_COUNT);
   } else {
+#if CONFIG_CTX_Y_SECOND_MODE
+    aom_write_literal(
+        w,
+        mode_idx - FIRST_MODE_COUNT - (mode_set_index - 1) * SECOND_MODE_COUNT,
+        4);
+#else
     aom_write_symbol(
         w,
         mode_idx - FIRST_MODE_COUNT - (mode_set_index - 1) * SECOND_MODE_COUNT,
         ec_ctx->y_mode_idx_cdf_1[context], SECOND_MODE_COUNT);
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
   }
   if (mbmi->joint_y_mode_delta_angle < NON_DIRECTIONAL_MODES_COUNT)
     assert(mbmi->joint_y_mode_delta_angle == mbmi->y_mode_idx);
@@ -3123,7 +3148,10 @@
 }
 
 #if CONFIG_IBC_BV_IMPROVEMENT
-static void write_intrabc_drl_idx(int max_ref_bv_num, FRAME_CONTEXT *ec_ctx,
+static void write_intrabc_drl_idx(int max_ref_bv_num,
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
+                                  FRAME_CONTEXT *ec_ctx,
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
                                   const MB_MODE_INFO *mbmi,
                                   const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame,
                                   aom_writer *w) {
@@ -3135,13 +3163,21 @@
 #endif
   assert(mbmi->intrabc_drl_idx < max_ref_bv_num);
   (void)mbmi_ext_frame;
-
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
   int bit_cnt = 0;
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
   for (int idx = 0; idx < max_ref_bv_num - 1; ++idx) {
+#if CONFIG_BYPASS_INTRABC_DRL_IDX
+    aom_write_bit(w, mbmi->intrabc_drl_idx != idx);
+#else
     aom_write_symbol(w, mbmi->intrabc_drl_idx != idx,
                      ec_ctx->intrabc_drl_idx_cdf[bit_cnt], 2);
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
+
     if (mbmi->intrabc_drl_idx == idx) break;
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
     ++bit_cnt;
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
   }
 }
 #endif  // CONFIG_IBC_BV_IMPROVEMENT
@@ -3194,7 +3230,10 @@
 #else
         MAX_REF_BV_STACK_SIZE,
 #endif  // CONFIG_IBC_MAX_DRL
-        ec_ctx, mbmi, mbmi_ext_frame, w);
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
+        ec_ctx,
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
+        mbmi, mbmi_ext_frame, w);
 
 #if CONFIG_IBC_SUBPEL_PRECISION
     if (is_intraBC_bv_precision_active(cm, mbmi->intrabc_mode)) {
@@ -4523,13 +4562,19 @@
   }
 }
 
-static AOM_INLINE void write_wiener_filter(MACROBLOCKD *xd, int wiener_win,
-                                           const WienerInfo *wiener_info,
-                                           WienerInfoBank *bank,
-                                           aom_writer *wb) {
+static AOM_INLINE void write_wiener_filter(
+#if !CONFIG_MERGE_PARA_CTX
+    MACROBLOCKD *xd,
+#endif  // !CONFIG_MERGE_PARA_CTX
+    int wiener_win, const WienerInfo *wiener_info, WienerInfoBank *bank,
+    aom_writer *wb) {
   const int equal_ref = check_wiener_bank_eq(bank, wiener_info);
   const int exact_match = (equal_ref >= 0);
+#if CONFIG_MERGE_PARA_CTX
+  aom_write_bit(wb, exact_match);
+#else
   aom_write_symbol(wb, exact_match, xd->tile_ctx->merged_param_cdf, 2);
+#endif  // CONFIG_MERGE_PARA_CTX
   const int ref = wiener_info->bank_ref;
   assert(IMPLIES(exact_match, ref == equal_ref));
   assert(ref < AOMMAX(1, bank->bank_size));
@@ -4587,13 +4632,18 @@
   return;
 }
 
-static AOM_INLINE void write_sgrproj_filter(MACROBLOCKD *xd,
-                                            const SgrprojInfo *sgrproj_info,
-                                            SgrprojInfoBank *bank,
-                                            aom_writer *wb) {
+static AOM_INLINE void write_sgrproj_filter(
+#if !CONFIG_MERGE_PARA_CTX
+    MACROBLOCKD *xd,
+#endif  // !CONFIG_MERGE_PARA_CTX
+    const SgrprojInfo *sgrproj_info, SgrprojInfoBank *bank, aom_writer *wb) {
   const int equal_ref = check_sgrproj_bank_eq(bank, sgrproj_info);
   const int exact_match = (equal_ref >= 0);
+#if CONFIG_MERGE_PARA_CTX
+  aom_write_bit(wb, exact_match);
+#else
   aom_write_symbol(wb, exact_match, xd->tile_ctx->merged_param_cdf, 2);
+#endif  // CONFIG_MERGE_PARA_CTX
   const int ref = sgrproj_info->bank_ref;
   assert(IMPLIES(exact_match, ref == equal_ref));
   assert(ref < AOMMAX(1, bank->bank_size));
@@ -4646,8 +4696,12 @@
       check_wienerns_bank_eq(bank, wienerns_info, nsfilter_params->ncoeffs,
                              wiener_class_id, ref_for_class);
   const int exact_match = (is_equal >= 0);
+#if CONFIG_MERGE_PARA_CTX
+  (void)xd;
+  aom_write_bit(wb, exact_match);
+#else
   aom_write_symbol(wb, exact_match, xd->tile_ctx->merged_param_cdf, 2);
-
+#endif  // CONFIG_MERGE_PARA_CTX
   if (!exact_match) {
     ref_for_class[wiener_class_id] =
         wienerns_info->bank_ref_for_class[wiener_class_id];
@@ -4675,7 +4729,12 @@
   const int exact_match =
       check_wienerns_eq(wienerns_info, ref_wienerns_info,
                         nsfilter_params->ncoeffs, wiener_class_id);
+#if CONFIG_MERGE_PARA_CTX
+  (void)xd;
+  aom_write_bit(wb, exact_match);
+#else
   aom_write_symbol(wb, exact_match, xd->tile_ctx->merged_param_cdf, 2);
+#endif  // CONFIG_MERGE_PARA_CTX
   return exact_match;
 }
 
@@ -5017,12 +5076,18 @@
         (int)unit_rtype == cm->features.lr_last_switchable_ndx_0_type[plane]));
     switch (unit_rtype) {
       case RESTORE_WIENER:
-        write_wiener_filter(xd, wiener_win, &rui->wiener_info,
-                            &xd->wiener_info[plane], w);
+        write_wiener_filter(
+#if !CONFIG_MERGE_PARA_CTX
+            xd,
+#endif  // !CONFIG_MERGE_PARA_CTX
+            wiener_win, &rui->wiener_info, &xd->wiener_info[plane], w);
         break;
       case RESTORE_SGRPROJ:
-        write_sgrproj_filter(xd, &rui->sgrproj_info, &xd->sgrproj_info[plane],
-                             w);
+        write_sgrproj_filter(
+#if !CONFIG_MERGE_PARA_CTX
+            xd,
+#endif  // !CONFIG_MERGE_PARA_CTX
+            &rui->sgrproj_info, &xd->sgrproj_info[plane], w);
         break;
       case RESTORE_WIENER_NONSEP:
         write_wienerns_filter(xd, plane, rsi, &rui->wienerns_info,
@@ -5040,8 +5105,11 @@
     ++counts->wiener_restore[unit_rtype != RESTORE_NONE];
 #endif
     if (unit_rtype != RESTORE_NONE) {
-      write_wiener_filter(xd, wiener_win, &rui->wiener_info,
-                          &xd->wiener_info[plane], w);
+      write_wiener_filter(
+#if !CONFIG_MERGE_PARA_CTX
+          xd,
+#endif  // !CONFIG_MERGE_PARA_CTX
+          wiener_win, &rui->wiener_info, &xd->wiener_info[plane], w);
     }
   } else if (frame_rtype == RESTORE_SGRPROJ) {
     aom_write_symbol(w, unit_rtype != RESTORE_NONE,
@@ -5050,7 +5118,11 @@
     ++counts->sgrproj_restore[unit_rtype != RESTORE_NONE];
 #endif
     if (unit_rtype != RESTORE_NONE) {
-      write_sgrproj_filter(xd, &rui->sgrproj_info, &xd->sgrproj_info[plane], w);
+      write_sgrproj_filter(
+#if !CONFIG_MERGE_PARA_CTX
+          xd,
+#endif  // !CONFIG_MERGE_PARA_CTX
+          &rui->sgrproj_info, &xd->sgrproj_info[plane], w);
     }
   } else if (frame_rtype == RESTORE_WIENER_NONSEP) {
     aom_write_symbol(w, unit_rtype != RESTORE_NONE,

diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 83b35e8..88eea09 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h

@@ -192,8 +192,10 @@
 #endif  // CONFIG_TCQ
                      [LF_BASE_SYMBOLS * 2];
   //! Cost for encoding an increment to the low-frequency chroma coefficient
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
   int lps_lf_cost_uv[LF_LEVEL_CONTEXTS_UV]
                     [COEFF_BASE_RANGE + 1 + COEFF_BASE_RANGE + 1];
+#endif
   /*! \brief Cost for encoding the base_eob of a chroma level.
    *
    * Decoder uses base_eob to derive the base_level as base_eob := base_eob+1.
@@ -229,8 +231,10 @@
   //! Cost for encoding the base level of a parity-hidden coefficient
   int base_ph_cost[COEFF_BASE_PH_CONTEXTS][4];
   //! Cost for encoding an increment to the parity-hidden coefficient
+#if !CONFIG_COEFF_BR_PH_BYPASS
   int lps_ph_cost[COEFF_BR_PH_CONTEXTS]
                  [COEFF_BASE_RANGE + 1 + COEFF_BASE_RANGE + 1];
+#endif
   /*! \brief Cost for encoding the base_eob of a level.
    *
    * Decoder uses base_eob to derive the base_level as base_eob := base_eob+1.
@@ -1002,7 +1006,9 @@
   //! y first mode cost
   int y_first_mode_costs[Y_MODE_CONTEXTS][FIRST_MODE_COUNT];
   //! y second mode cost
+#if !CONFIG_CTX_Y_SECOND_MODE
   int y_second_mode_costs[Y_MODE_CONTEXTS][SECOND_MODE_COUNT];
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
   //! uv mode cost
   int intra_uv_mode_cost[UV_MODE_CONTEXTS][UV_INTRA_MODES - 1];
   //! CFL mode cost
@@ -1068,8 +1074,10 @@
   int palette_uv_mode_cost[PALETTE_UV_MODE_CONTEXTS][2];
 #if CONFIG_PALETTE_IMPROVEMENTS
 #if CONFIG_PALETTE_LINE_COPY
+#if !CONFIG_PLT_DIR_CTX
   //! palette_direction_cost
   int palette_direction_cost[2];
+#endif  // !CONFIG_PLT_DIR_CTX
   //! palette_y_row_flag_cost
   int palette_y_row_flag_cost[PALETTE_ROW_FLAG_CONTEXTS][3];
   //! palette_uv_row_flag_cost

diff --git a/av1/encoder/encodeframe_utils.c b/av1/encoder/encodeframe_utils.c
index d4e9e09..52264a8 100644
--- a/av1/encoder/encodeframe_utils.c
+++ b/av1/encoder/encodeframe_utils.c

@@ -598,7 +598,9 @@
           ++counts->y_mode_idx_0[context][mode_idx];
 #endif
           update_cdf(fc->y_mode_idx_cdf_0[context], mode_idx, FIRST_MODE_COUNT);
-        } else {
+        }
+#if !CONFIG_CTX_Y_SECOND_MODE
+        else {
           const int mode_idx_in_set = mode_idx - FIRST_MODE_COUNT -
                                       SECOND_MODE_COUNT * (mode_set_index - 1);
 #if CONFIG_ENTROPY_STATS
@@ -607,6 +609,7 @@
           update_cdf(fc->y_mode_idx_cdf_1[context], mode_idx_in_set,
                      SECOND_MODE_COUNT);
         }
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
       } else {
         update_cdf(fc->dpcm_vert_horz_cdf, mbmi->dpcm_mode_y, 2);
       }
@@ -624,7 +627,9 @@
         ++counts->y_mode_idx_0[context][mode_idx];
 #endif
         update_cdf(fc->y_mode_idx_cdf_0[context], mode_idx, FIRST_MODE_COUNT);
-      } else {
+      }
+#if !CONFIG_CTX_Y_SECOND_MODE
+      else {
         const int mode_idx_in_set = mode_idx - FIRST_MODE_COUNT -
                                     SECOND_MODE_COUNT * (mode_set_index - 1);
 #if CONFIG_ENTROPY_STATS
@@ -633,6 +638,7 @@
         update_cdf(fc->y_mode_idx_cdf_1[context], mode_idx_in_set,
                    SECOND_MODE_COUNT);
       }
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
     }
 #else  // CONFIG_LOSSLESS_DPCM
     const int context = get_y_mode_idx_ctx(xd);
@@ -648,7 +654,9 @@
       ++counts->y_mode_idx_0[context][mode_idx];
 #endif
       update_cdf(fc->y_mode_idx_cdf_0[context], mode_idx, FIRST_MODE_COUNT);
-    } else {
+    }
+#if !CONFIG_CTX_Y_SECOND_MODE
+    else {
       const int mode_idx_in_set = mode_idx - FIRST_MODE_COUNT -
                                   SECOND_MODE_COUNT * (mode_set_index - 1);
 #if CONFIG_ENTROPY_STATS
@@ -657,6 +665,7 @@
       update_cdf(fc->y_mode_idx_cdf_1[context], mode_idx_in_set,
                  SECOND_MODE_COUNT);
     }
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
 #endif  // CONFIG_LOSSLESS_DPCM
     update_fsc_cdf(cm, xd,
 #if CONFIG_ENTROPY_STATS
@@ -1493,9 +1502,10 @@
               LF_BASE_SYMBOLS);
   AVERAGE_CDF(ctx_left->coeff_base_lf_eob_uv_cdf,
               ctx_tr->coeff_base_lf_eob_uv_cdf, LF_BASE_SYMBOLS - 1);
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
   AVERAGE_CDF(ctx_left->coeff_br_lf_uv_cdf, ctx_tr->coeff_br_lf_uv_cdf,
               BR_CDF_SIZE);
-
+#endif
   AVERAGE_CDF(ctx_left->inter_warp_mode_cdf, ctx_tr->inter_warp_mode_cdf, 2);
 #if CONFIG_REDESIGN_WARP_MODES_SIGNALING_FLOW
   AVERAGE_CDF(ctx_left->is_warpmv_or_warp_newmv_cdf,
@@ -1709,7 +1719,9 @@
   AVERAGE_CDF(ctx_left->wienerns_4part_cdf, ctx_tr->wienerns_4part_cdf, 4);
   AVERAGE_CDF(ctx_left->pc_wiener_restore_cdf, ctx_tr->pc_wiener_restore_cdf,
               2);
+#if !CONFIG_MERGE_PARA_CTX
   AVERAGE_CDF(ctx_left->merged_param_cdf, ctx_tr->merged_param_cdf, 2);
+#endif  // !CONFIG_MERGE_PARA_CTX
   AVERAGE_CDF(ctx_left->fsc_mode_cdf, ctx_tr->fsc_mode_cdf, FSC_MODES);
   AVERAGE_CDF(ctx_left->mrl_index_cdf, ctx_tr->mrl_index_cdf, MRL_LINE_NUMBER);
 #if CONFIG_MRLS_IMPROVE
@@ -1734,8 +1746,10 @@
               INTRA_MODE_SETS);
   AVERAGE_CDF(ctx_left->y_mode_idx_cdf_0, ctx_tr->y_mode_idx_cdf_0,
               FIRST_MODE_COUNT);
+#if !CONFIG_CTX_Y_SECOND_MODE
   AVERAGE_CDF(ctx_left->y_mode_idx_cdf_1, ctx_tr->y_mode_idx_cdf_1,
               SECOND_MODE_COUNT);
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
   AVERAGE_CDF(ctx_left->uv_mode_cdf, ctx_tr->uv_mode_cdf, UV_INTRA_MODES);
 
   for (int i = 0; i < INTER_SDP_BSIZE_GROUP; i++) {
@@ -1861,7 +1875,9 @@
   }
 
   AVERAGE_CDF(ctx_left->coeff_base_ph_cdf, ctx_tr->coeff_base_ph_cdf, 4);
+#if !CONFIG_COEFF_BR_PH_BYPASS
   AVERAGE_CDF(ctx_left->coeff_br_ph_cdf, ctx_tr->coeff_br_ph_cdf, 4);
+#endif
   AVERAGE_CDF(ctx_left->cctx_type_cdf, ctx_tr->cctx_type_cdf, CCTX_TYPES);
 }
 #endif  // !CONFIG_ENHANCED_FRAME_CONTEXT_INIT

diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index 231c950..3cdc948 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c

@@ -253,7 +253,9 @@
 #endif
   int eob_extra;
   const int eob_pt = get_eob_pos_token(eob, &eob_extra);
+#if !CONFIG_EOB_PT_CTX_REDUCTION
   TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size);
+#endif
 
   const int eob_multi_size = txsize_log2_minus4[tx_size];
 #if CONFIG_EOB_POS_LUMA
@@ -327,14 +329,24 @@
 
   const int eob_offset_bits = av1_eob_offset_bits[eob_pt];
   if (eob_offset_bits > 0) {
+#if !CONFIG_EOB_PT_CTX_REDUCTION
     int eob_ctx = eob_pt - 3;
+#endif
     int eob_shift = eob_offset_bits - 1;
     int bit = (eob_extra & (1 << eob_shift)) ? 1 : 0;
 #if CONFIG_ENTROPY_STATS
+#if CONFIG_EOB_PT_CTX_REDUCTION
+    counts->eob_extra[cdf_idx][0][0][0][bit]++;
+#else
     counts->eob_extra[cdf_idx][txs_ctx][plane][eob_ctx][bit]++;
+#endif
 #endif  // CONFIG_ENTROPY_STATS
     if (allow_update_cdf)
+#if CONFIG_EOB_PT_CTX_REDUCTION
+      update_cdf(ec_ctx->eob_extra_cdf, bit, 2);
+#else
       update_cdf(ec_ctx->eob_extra_cdf[txs_ctx][plane][eob_ctx], bit, 2);
+#endif
   }
 }
 
@@ -364,6 +376,20 @@
   return eob_cost;
 }
 
+#if CONFIG_COEFF_BR_PH_BYPASS
+static AOM_FORCE_INLINE int get_br_ph_cost(tran_low_t level, int hr_ctx,
+                                           int *hr_level) {
+  int cost = 0;
+  *hr_level = 0;
+  if (level >= 1 + NUM_BASE_LEVELS) {
+    const int r = level - NUM_BASE_LEVELS - 1;
+    *hr_level = r;
+    cost += av1_cost_literal(get_adaptive_hr_length(r, hr_ctx));
+  }
+  return cost;
+}
+#endif
+
 #if CONFIG_COEFF_HR_ADAPTIVE
 static AOM_FORCE_INLINE int get_br_cost(tran_low_t level, const int *coeff_lps,
                                         int hr_ctx, int *hr_level) {
@@ -379,6 +405,20 @@
   return cost;
 }
 
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+static AOM_FORCE_INLINE int get_br_lf_cost_uv(tran_low_t level, int hr_ctx,
+                                              int *hr_level) {
+  int cost = 0;
+  *hr_level = 0;
+  if (level >= 1 + LF_NUM_BASE_LEVELS) {
+    const int r = level - LF_NUM_BASE_LEVELS - 1;
+    *hr_level = r;
+    cost += av1_cost_literal(get_adaptive_hr_length(r, hr_ctx));
+  }
+  return cost;
+}
+#endif
+
 static AOM_FORCE_INLINE int get_br_lf_cost(tran_low_t level,
                                            const int *coeff_lps, int hr_ctx,
                                            int *hr_level) {
@@ -419,6 +459,24 @@
   return cost;
 }
 
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+static AOM_FORCE_INLINE int get_br_lf_cost_with_diff_uv(tran_low_t level,
+                                                        int *diff, int hr_ctx,
+                                                        int *hr_level) {
+  int cost = 0;
+  *hr_level = 0;
+  if (level >= 1 + LF_NUM_BASE_LEVELS) {
+    const int r = level - LF_NUM_BASE_LEVELS - 1;
+    *hr_level = r;
+    int bits, diff_bits;
+    bits = get_adaptive_hr_length_diff(r, hr_ctx, &diff_bits);
+    *diff += av1_cost_literal(diff_bits);
+    cost += av1_cost_literal(bits);
+  }
+  return cost;
+}
+#endif
+
 static AOM_FORCE_INLINE int get_br_lf_cost_with_diff(tran_low_t level,
                                                      const int *coeff_lps,
                                                      int *diff, int hr_ctx,
@@ -459,6 +517,16 @@
   return low;
 }
 
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+static INLINE int get_high_range_uv(int abs_qc, int lf) {
+  int base_levels = lf ? 6 : 4;
+  int parity = abs_qc & 1;
+  // int br_max = base_levels - 1 - parity;
+  int high_range = (abs_qc - parity - (base_levels - 1)) >> 1;
+  return high_range;
+}
+#endif
+
 static INLINE int get_high_range(int abs_qc, int lf) {
   int base_levels = lf ? 6 : 4;
   int low_range = get_low_range(abs_qc, lf);
@@ -706,8 +774,10 @@
                             TX_SIZE tx_size, int eob) {
   MACROBLOCKD *xd = &x->e_mbd;
   FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
+#if !CONFIG_EOB_PT_CTX_REDUCTION
   const PLANE_TYPE plane_type = get_plane_type(plane);
   const TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size);
+#endif
 #if CONFIG_EOB_POS_LUMA
   const int is_inter = is_inter_block(xd->mi[0], xd->tree_type);
   const int pl_ctx = get_eob_plane_ctx(plane, is_inter);
@@ -751,11 +821,17 @@
   }
   const int eob_offset_bits = av1_eob_offset_bits[eob_pt];
   if (eob_offset_bits > 0) {
+#if !CONFIG_EOB_PT_CTX_REDUCTION
     const int eob_ctx = eob_pt - 3;
+#endif
     int eob_shift = eob_offset_bits - 1;
     int bit = (eob_extra & (1 << eob_shift)) ? 1 : 0;
+#if CONFIG_EOB_PT_CTX_REDUCTION
+    aom_write_symbol(w, bit, ec_ctx->eob_extra_cdf, 2);
+#else
     aom_write_symbol(w, bit,
                      ec_ctx->eob_extra_cdf[txs_ctx][plane_type][eob_ctx], 2);
+#endif
 #if CONFIG_BYPASS_IMPROVEMENT
     // Zero out top bit; write (eob_offset_bits - 1) lsb bits.
     eob_extra &= (1 << (eob_offset_bits - 1)) - 1;
@@ -974,14 +1050,19 @@
 static INLINE void write_coeff_hidden(aom_writer *w, TX_CLASS tx_class,
                                       const int16_t *scan, int bwl,
                                       uint8_t *levels, const int level,
-                                      base_ph_cdf_arr base_cdf_ph,
-                                      br_cdf_arr br_cdf_ph) {
+                                      base_ph_cdf_arr base_cdf_ph
+#if !CONFIG_COEFF_BR_PH_BYPASS
+                                      ,
+                                      br_cdf_arr br_cdf_ph
+#endif
+) {
   const int q_index = (level >> 1);
   const int pos = scan[0];
 
   int ctx_id = get_base_ctx_ph(levels, pos, bwl, tx_class);
   aom_write_symbol(w, AOMMIN(q_index, 3), base_cdf_ph[ctx_id], 4);
 
+#if !CONFIG_COEFF_BR_PH_BYPASS
   if (q_index > NUM_BASE_LEVELS) {
     ctx_id = get_par_br_ctx(levels, pos, bwl, tx_class);
     aom_cdf_prob *cdf_br = br_cdf_ph[ctx_id];
@@ -992,6 +1073,7 @@
       if (k < BR_CDF_SIZE - 1) break;
     }
   }
+#endif
 }
 
 static void write_high_range(aom_writer *w, int enable_tcq, int level, int lf
@@ -999,14 +1081,32 @@
                              ,
                              int *hr_avg
 #endif
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+                             ,
+                             int plane
+#endif
 ) {
+#if CONFIG_COEFF_BR_LF_UV_BYPASS  // code_hr_t
+  int max = lf ? (plane == 0 ? (COEFF_BASE_RANGE + LF_NUM_BASE_LEVELS)
+                             : LF_NUM_BASE_LEVELS)
+               : COEFF_BASE_RANGE + NUM_BASE_LEVELS;
+#else
   int max = lf ? COEFF_BASE_RANGE + LF_NUM_BASE_LEVELS
                : COEFF_BASE_RANGE + NUM_BASE_LEVELS;
+#endif
   max -= enable_tcq ? 1 : 0;
   if (level > max) {
     int hr = 0;
     if (enable_tcq) {
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+      if (lf && (plane != 0)) {
+        hr = get_high_range_uv(level, lf);
+      } else {
+        hr = get_high_range(level, lf);
+      }
+#else
       hr = get_high_range(level, lf);
+#endif
     } else {
       hr = level - max - 1;
     }
@@ -1186,11 +1286,13 @@
     int limits = get_lf_limits(row, col, tx_class, plane);
     if (plane > 0) {
       if (limits) {
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
         if (level > LF_NUM_BASE_LEVELS) {
           const int br_ctx = get_br_lf_ctx_chroma(levels, pos, bwl, tx_class);
           aom_cdf_prob *cdf = ec_ctx->coeff_br_lf_uv_cdf[br_ctx];
           write_low_range(w, cdf, level, 1, tcq_mode);
         }
+#endif
       } else {
         if (level > NUM_BASE_LEVELS) {
           const int br_ctx = get_br_ctx_chroma(levels, pos, bwl, tx_class);
@@ -1232,8 +1334,13 @@
     const int pos = scan[0];
     const tran_low_t v = tcoeff[pos];
     const tran_low_t level = abs(v);
+#if CONFIG_COEFF_BR_PH_BYPASS
+    write_coeff_hidden(w, tx_class, scan, bwl, levels, level,
+                       ec_ctx->coeff_base_ph_cdf);
+#else
     write_coeff_hidden(w, tx_class, scan, bwl, levels, level,
                        ec_ctx->coeff_base_ph_cdf, ec_ctx->coeff_br_ph_cdf);
+#endif
   } else {
     const int c = 0;
     const int pos = scan[c];
@@ -1323,11 +1430,13 @@
     int limits = get_lf_limits(row, col, tx_class, plane);
     if (plane > 0) {
       if (limits) {
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
         if (level > LF_NUM_BASE_LEVELS) {
           const int br_ctx = get_br_lf_ctx_chroma(levels, pos, bwl, tx_class);
           aom_cdf_prob *cdf = ec_ctx->coeff_br_lf_uv_cdf[br_ctx];
           write_low_range(w, cdf, level, 1, tcq_mode);
         }
+#endif
       } else {
         if (level > NUM_BASE_LEVELS) {
           const int br_ctx = get_br_ctx_chroma(levels, pos, bwl, tx_class);
@@ -1386,10 +1495,14 @@
 #if CONFIG_CONTEXT_DERIVATION
         if (plane == AOM_PLANE_U) xd->tmp_sign[tmp_sign_idx] = (sign ? 2 : 1);
         if (plane == AOM_PLANE_V) {
+#if CONFIG_BY_PASS_V_SIGN
+          aom_write_literal(w, sign, 1);
+#else
           aom_write_symbol(
               w, sign,
               ec_ctx->v_dc_sign_cdf[xd->tmp_sign[tmp_sign_idx]][dc_sign_ctx],
               2);
+#endif
         } else {
           aom_write_symbol(
               w, sign,
@@ -1414,6 +1527,13 @@
       }
       if (is_hidden && c == 0) {
         int q_index = level >> 1;
+#if CONFIG_COEFF_BR_PH_BYPASS
+        if (q_index > NUM_BASE_LEVELS) {
+          int hr_level = q_index - 1 - NUM_BASE_LEVELS;
+          write_adaptive_hr(w, hr_level, hr_level_avg >> 1);
+          hr_level_avg = (hr_level_avg + hr_level) >> 1;
+        }
+#else
         if (q_index > COEFF_BASE_RANGE + NUM_BASE_LEVELS) {
 #if CONFIG_COEFF_HR_ADAPTIVE
           int hr_level = q_index - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS;
@@ -1424,6 +1544,7 @@
                            0);
 #endif  // CONFIG_COEFF_HR_ADAPTIVE
         }
+#endif
       } else {
         int limits = get_lf_limits(row, col, tx_class, plane);
 #if 0 /* fix write_high_range() */
@@ -1456,6 +1577,10 @@
                          ,
                          &hr_level_avg
 #endif
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+                         ,
+                         plane
+#endif
         );
 #endif
       }
@@ -2093,8 +2218,10 @@
       coeff_costs->lps_lf_cost;
   const int(*lps_cost_uv)[COEFF_BASE_RANGE + 1 + COEFF_BASE_RANGE + 1] =
       coeff_costs->lps_cost_uv;
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
   const int(*lps_lf_cost_uv)[COEFF_BASE_RANGE + 1 + COEFF_BASE_RANGE + 1] =
       coeff_costs->lps_lf_cost_uv;
+#endif
 #if CONFIG_COEFF_HR_ADAPTIVE
   int hr_level = 0;
 #endif  // CONFIG_COEFF_HR_ADAPTIVE
@@ -2132,11 +2259,21 @@
       if (plane > 0) {
         if (limits) {
           if (level > LF_NUM_BASE_LEVELS) {
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
             const int ctx = get_br_ctx_lf_eob_chroma(pos, tx_class);
+#endif
 #if CONFIG_COEFF_HR_ADAPTIVE
-            int hr_ctx = 0; /* eob */
-            cost +=
-                get_br_lf_cost(level, lps_lf_cost_uv[ctx], hr_ctx, &hr_level);
+            int hr_ctx = 0;       /* eob */
+#if CONFIG_COEFF_BR_LF_UV_BYPASS  // cost
+            cost += get_br_lf_cost_uv(level, hr_ctx, &hr_level);
+#else
+            cost += get_br_lf_cost(level, lps_lf_cost_uv[ctx], hr_ctx, &hr_level
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+                                   ,
+                                   plane, 1
+#endif
+            );
+#endif
 #else
             cost += get_br_lf_cost(level, lps_lf_cost_uv[ctx]);
 #endif  // CONFIG_COEFF_HR_ADAPTIVE
@@ -2289,13 +2426,23 @@
       if (plane > 0) {
         if (limits) {
           if (level > LF_NUM_BASE_LEVELS) {
+#if CONFIG_COEFF_BR_LF_UV_BYPASS  // cost
+            cost += get_br_lf_cost_uv(level, hr_level_avg, &hr_level);
+            hr_level_avg = (hr_level_avg + hr_level) >> 1;
+#else
             const int ctx = get_br_lf_ctx_chroma(levels, pos, bwl, tx_class);
 #if CONFIG_COEFF_HR_ADAPTIVE
             cost += get_br_lf_cost(level, lps_lf_cost_uv[ctx], hr_level_avg,
-                                   &hr_level);
+                                   &hr_level
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+                                   ,
+                                   plane, 0
+#endif
+            );
             hr_level_avg = (hr_level_avg + hr_level) >> 1;
 #else
             cost += get_br_lf_cost(level, lps_lf_cost_uv[ctx]);
+#endif
 #endif  // CONFIG_COEFF_HR_ADAPTIVE
           }
         } else {
@@ -2360,6 +2507,9 @@
       cost += coeff_costs->dc_sign_cost[dc_ph_group][dc_sign_ctx][v < 0];
 
       if (q_index > NUM_BASE_LEVELS) {
+#if CONFIG_COEFF_BR_PH_BYPASS  // cost
+        cost += get_br_ph_cost(q_index, hr_level_avg >> 1, &hr_level);
+#else
         const int ctx = get_par_br_ctx(levels, pos, bwl, tx_class);
 #if CONFIG_COEFF_HR_ADAPTIVE
         // Use context divided by 2 since the coefficient is also divided by
@@ -2368,6 +2518,7 @@
                             hr_level_avg >> 1, &hr_level);
 #else
         cost += get_br_cost(q_index, coeff_costs_ph->lps_ph_cost[ctx]);
+#endif
 #endif  // CONFIG_COEFF_HR_ADAPTIVE
       }
     }
@@ -2427,12 +2578,21 @@
       if (plane > 0) {
         if (limits) {
           if (level > LF_NUM_BASE_LEVELS) {
+#if CONFIG_COEFF_BR_LF_UV_BYPASS  // cost
+            cost += get_br_lf_cost_uv(level, hr_level_avg, &hr_level);
+#else
             const int ctx = get_br_lf_ctx_chroma(levels, pos, bwl, tx_class);
 #if CONFIG_COEFF_HR_ADAPTIVE
             cost += get_br_lf_cost(level, lps_lf_cost_uv[ctx], hr_level_avg,
-                                   &hr_level);
+                                   &hr_level
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+                                   ,
+                                   plane, 0
+#endif
+            );
 #else
             cost += get_br_lf_cost(level, lps_lf_cost_uv[ctx]);
+#endif
 #endif  // CONFIG_COEFF_HR_ADAPTIVE
           }
         } else {
@@ -2791,6 +2951,12 @@
     if (plane > 0) {
       if (limits) {
         if (abs_qc > LF_NUM_BASE_LEVELS) {
+#if CONFIG_COEFF_BR_LF_UV_BYPASS  // cost
+          int brcost_diff = 0;
+          cost += get_br_lf_cost_with_diff_uv(abs_qc, &brcost_diff,
+                                              hr_level_avg, hr_level);
+          diff += brcost_diff;
+#else
           const int br_ctx = get_br_lf_ctx_chroma(levels, ci, bwl, tx_class);
           int brcost_diff = 0;
 #if CONFIG_COEFF_HR_ADAPTIVE
@@ -2802,6 +2968,7 @@
               abs_qc, txb_costs->lps_lf_cost_uv[br_ctx], &brcost_diff);
 #endif  // CONFIG_COEFF_HR_ADAPTIVE
           diff += brcost_diff;
+#endif
         }
       } else {
         if (abs_qc > NUM_BASE_LEVELS) {
@@ -2957,15 +3124,26 @@
     if (plane > 0) {
       if (limits) {
         if (abs_qc > LF_NUM_BASE_LEVELS) {
+#if CONFIG_COEFF_BR_LF_UV_BYPASS  // cost
+          int hr_level_avg = 0;
+          int dummy_hr_level;
+          cost += get_br_lf_cost_uv(abs_qc, hr_level_avg, &dummy_hr_level);
+#else
           int br_ctx = get_br_ctx_lf_eob_chroma(ci, tx_class);
 #if CONFIG_COEFF_HR_ADAPTIVE
           int hr_level_avg = 0;
           int dummy_hr_level;
           cost += get_br_lf_cost(abs_qc, txb_costs->lps_lf_cost_uv[br_ctx],
-                                 hr_level_avg, &dummy_hr_level);
+                                 hr_level_avg, &dummy_hr_level
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+                                 ,
+                                 plane, 1
+#endif
+          );
 #else
           cost += get_br_lf_cost(abs_qc, txb_costs->lps_lf_cost_uv[br_ctx]);
 #endif  // CONFIG_COEFF_HR_ADAPTIVE
+#endif
         }
       } else {
         if (abs_qc > NUM_BASE_LEVELS) {
@@ -3082,6 +3260,9 @@
     if (plane > 0) {
       if (limits) {
         if (abs_qc > LF_NUM_BASE_LEVELS) {
+#if CONFIG_COEFF_BR_LF_UV_BYPASS  // cost
+          cost += get_br_lf_cost_uv(abs_qc, hr_level_avg, hr_level);
+#else
           int br_ctx;
           if (is_last)
             br_ctx = get_br_ctx_lf_eob_chroma(ci, tx_class);
@@ -3089,9 +3270,15 @@
             br_ctx = get_br_lf_ctx_chroma(levels, ci, bwl, tx_class);
 #if CONFIG_COEFF_HR_ADAPTIVE
           cost += get_br_lf_cost(abs_qc, txb_costs->lps_lf_cost_uv[br_ctx],
-                                 hr_level_avg, hr_level);
+                                 hr_level_avg, hr_level
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+                                 ,
+                                 plane, is_last
+#endif
+          );
 #else
           cost += get_br_lf_cost(abs_qc, txb_costs->lps_lf_cost_uv[br_ctx]);
+#endif
 #endif  // CONFIG_COEFF_HR_ADAPTIVE
         }
       } else {
@@ -4048,12 +4235,16 @@
   const int base_ctx_ph = get_base_ctx_ph(levels, pos, bwl, tx_class);
   int rate_ph = txb_costs_ph->base_ph_cost[base_ctx_ph][AOMMIN(q_index, 3)];
   if (q_index > NUM_BASE_LEVELS) {
+#if CONFIG_COEFF_BR_PH_BYPASS  // cost
+    rate_ph += get_br_ph_cost(q_index, hr_level_avg, &dummy_hr_level);
+#else
     int br_ctx = get_par_br_ctx(levels, pos, bwl, tx_class);
 #if CONFIG_COEFF_HR_ADAPTIVE
     rate_ph += get_br_cost(q_index, txb_costs_ph->lps_ph_cost[br_ctx],
                            hr_level_avg, &dummy_hr_level);
 #else
     rate_ph += get_br_cost(q_index, txb_costs_ph->lps_ph_cost[br_ctx]);
+#endif
 #endif  // CONFIG_COEFF_HR_ADAPTIVE
   }
   const int dc_ph_group = 1;  // PH enabled
@@ -4103,6 +4294,10 @@
     const int dc_ph_group = 1;  // PH enabled
     rate_cand += txb_costs->dc_sign_cost[dc_ph_group][dc_sign_ctx][tcoeff < 0];
     if (q_index > NUM_BASE_LEVELS) {
+#if CONFIG_COEFF_BR_PH_BYPASS  // cost
+      int dummy_hr_level;
+      rate_cand += get_br_ph_cost(q_index, hr_level_avg, &dummy_hr_level);
+#else
       int br_ctx = get_par_br_ctx(levels, pos, bwl, tx_class);
 #if CONFIG_COEFF_HR_ADAPTIVE
       int dummy_hr_level;
@@ -4110,6 +4305,7 @@
                                hr_level_avg, &dummy_hr_level);
 #else
       rate_cand += get_br_cost(q_index, txb_costs_ph->lps_ph_cost[br_ctx]);
+#endif
 #endif  // CONFIG_COEFF_HR_ADAPTIVE
     }
   }
@@ -5200,7 +5396,11 @@
 
 void update_coeff_ctx_hiden(TX_CLASS tx_class, const int16_t *scan, int bwl,
                             uint8_t *levels, int level,
-                            base_ph_cdf_arr base_cdf_ph, br_cdf_arr br_cdf_ph
+                            base_ph_cdf_arr base_cdf_ph
+#if !CONFIG_COEFF_BR_PH_BYPASS
+                            ,
+                            br_cdf_arr br_cdf_ph
+#endif
 #if CONFIG_ENTROPY_STATS
                             ,
                             ThreadData *const td, int cdf_idx
@@ -5214,6 +5414,7 @@
   ++td->counts->coeff_base_ph_multi[cdf_idx][coeff_ctx][AOMMIN(level, 3)];
 #endif  // CONFIG_ENTROPY_STATS
 
+#if !CONFIG_COEFF_BR_PH_BYPASS
   if (q_index > NUM_BASE_LEVELS) {
     int br_ctx = get_par_br_ctx(levels, pos, bwl, tx_class);
     aom_cdf_prob *cdf_br = br_cdf_ph[br_ctx];
@@ -5233,6 +5434,7 @@
       if (k < BR_CDF_SIZE - 1) break;
     }
   }
+#endif
 }
 void av1_update_and_record_txb_context(int plane, int block, int blk_row,
                                        int blk_col, BLOCK_SIZE plane_bsize,
@@ -5547,6 +5749,7 @@
       int limits = get_lf_limits(row, col, tx_class, plane);
       if (plane > 0) {
         if (limits) {
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
           if (level > LF_NUM_BASE_LEVELS) {
             const int base_range = level - 1 - LF_NUM_BASE_LEVELS;
             const int br_ctx = get_br_lf_ctx_chroma(levels, pos, bwl, tx_class);
@@ -5567,6 +5770,7 @@
               if (k < BR_CDF_SIZE - 1) break;
             }
           }
+#endif
         } else {
           if (level > NUM_BASE_LEVELS) {
             const int base_range = level - 1 - NUM_BASE_LEVELS;
@@ -5652,8 +5856,11 @@
       if (allow_update_cdf) {
         const int level = abs(qcoeff[scan[0]]);
         update_coeff_ctx_hiden(tx_class, scan, bwl, levels, level,
-                               ec_ctx->coeff_base_ph_cdf,
+                               ec_ctx->coeff_base_ph_cdf
+#if !CONFIG_COEFF_BR_PH_BYPASS
+                               ,
                                ec_ctx->coeff_br_ph_cdf
+#endif
 #if CONFIG_ENTROPY_STATS
                                ,
                                td, cdf_idx
@@ -5802,6 +6009,7 @@
       int limits = get_lf_limits(row, col, tx_class, plane);
       if (plane > 0) {
         if (limits) {
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
           if (level > LF_NUM_BASE_LEVELS) {
             const int base_range = level - 1 - LF_NUM_BASE_LEVELS;
             const int br_ctx = get_br_lf_ctx_chroma(levels, pos, bwl, tx_class);
@@ -5822,6 +6030,7 @@
               if (k < BR_CDF_SIZE - 1) break;
             }
           }
+#endif
         } else {
           if (level > NUM_BASE_LEVELS) {
             const int base_range = level - 1 - NUM_BASE_LEVELS;

diff --git a/av1/encoder/intra_mode_search.c b/av1/encoder/intra_mode_search.c
index c31b7b5..a50b2b0 100644
--- a/av1/encoder/intra_mode_search.c
+++ b/av1/encoder/intra_mode_search.c

@@ -1516,11 +1516,15 @@
         mode_cost +=
             x->mode_costs.y_first_mode_costs[context][mbmi->y_mode_idx];
       } else {
+#if CONFIG_CTX_Y_SECOND_MODE
+        mode_cost += av1_cost_literal(4);
+#else
         mode_cost +=
             x->mode_costs
                 .y_second_mode_costs[context]
                                     [mbmi->y_mode_idx - FIRST_MODE_COUNT -
                                      SECOND_MODE_COUNT * (mode_set_index - 1)];
+#endif  // CONFIG_CTX_Y_SECOND_MODE
       }
       mode_cost += ref_frame_cost;
       mode_cost += mrl_idx_cost;
@@ -1536,16 +1540,20 @@
     if (mbmi->y_mode_idx < FIRST_MODE_COUNT) {
       mode_cost += x->mode_costs.y_first_mode_costs[context][mbmi->y_mode_idx];
     } else {
+#if CONFIG_CTX_Y_SECOND_MODE
+      mode_cost += av1_cost_literal(4);
+#else
       mode_cost +=
           x->mode_costs
               .y_second_mode_costs[context]
                                   [mbmi->y_mode_idx - FIRST_MODE_COUNT -
                                    SECOND_MODE_COUNT * (mode_set_index - 1)];
+#endif  // CONFIG_CTX_Y_SECOND_MODE
     }
     mode_cost += ref_frame_cost;
     mode_cost += mrl_idx_cost;
   }
-#else   // CONFIG_LOSSLESS_DPCM
+#else  // CONFIG_LOSSLESS_DPCM
   const int context = get_y_mode_idx_ctx(xd);
   int mode_set_index = mbmi->y_mode_idx < FIRST_MODE_COUNT ? 0 : 1;
   mode_set_index += ((mbmi->y_mode_idx - FIRST_MODE_COUNT) / SECOND_MODE_COUNT);
@@ -1553,11 +1561,15 @@
   if (mbmi->y_mode_idx < FIRST_MODE_COUNT) {
     mode_cost += x->mode_costs.y_first_mode_costs[context][mbmi->y_mode_idx];
   } else {
+#if CONFIG_CTX_Y_SECOND_MODE
+    mode_cost += av1_cost_literal(4);
+#else
     mode_cost +=
         x->mode_costs
             .y_second_mode_costs[context]
                                 [mbmi->y_mode_idx - FIRST_MODE_COUNT -
                                  SECOND_MODE_COUNT * (mode_set_index - 1)];
+#endif  // CONFIG_CTX_Y_SECOND_MODE
   }
   if (mbmi->region_type != INTRA_REGION) mode_cost += ref_frame_cost;
   mode_cost += mrl_idx_cost;
@@ -1889,10 +1901,16 @@
             if (mode_idx < FIRST_MODE_COUNT) {
               mode_costs += x->mode_costs.y_first_mode_costs[context][mode_idx];
             } else {
-              mode_costs +=
-                  x->mode_costs.y_second_mode_costs
-                      [context][mbmi->y_mode_idx - FIRST_MODE_COUNT -
-                                SECOND_MODE_COUNT * (mode_set_index - 1)];
+#if CONFIG_CTX_Y_SECOND_MODE
+              mode_costs += av1_cost_literal(4);
+#else
+        mode_costs +=
+            x->mode_costs
+                .y_second_mode_costs[context]
+                                    [mbmi->y_mode_idx - FIRST_MODE_COUNT -
+                                     SECOND_MODE_COUNT * (mode_set_index - 1)];
+
+#endif  // CONFIG_CTX_Y_SECOND_MODE
             }
 #if CONFIG_LOSSLESS_DPCM
           } else {
@@ -2192,10 +2210,15 @@
             if (mode_idx < FIRST_MODE_COUNT) {
               mode_costs += x->mode_costs.y_first_mode_costs[context][mode_idx];
             } else {
-              mode_costs +=
-                  x->mode_costs.y_second_mode_costs
-                      [context][mbmi->y_mode_idx - FIRST_MODE_COUNT -
-                                SECOND_MODE_COUNT * (mode_set_index - 1)];
+#if CONFIG_CTX_Y_SECOND_MODE
+              mode_costs += av1_cost_literal(4);
+#else
+        mode_costs +=
+            x->mode_costs
+                .y_second_mode_costs[context]
+                                    [mbmi->y_mode_idx - FIRST_MODE_COUNT -
+                                     SECOND_MODE_COUNT * (mode_set_index - 1)];
+#endif  // CONFIG_CTX_Y_SECOND_MODE
             }
 #if CONFIG_LOSSLESS_DPCM
           } else {

diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c
index 71663b5..4dd3def 100644
--- a/av1/encoder/mcomp.c
+++ b/av1/encoder/mcomp.c

@@ -2914,15 +2914,27 @@
 #endif  // CONFIG_IBC_SUBPEL_PRECISION
 }
 
-int av1_get_intrabc_drl_idx_cost(int max_ref_bv_num, int intrabc_drl_idx,
-                                 const MACROBLOCK *x) {
+int av1_get_intrabc_drl_idx_cost(int max_ref_bv_num, int intrabc_drl_idx
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
+                                 ,
+                                 const MACROBLOCK *x
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
+) {
   assert(intrabc_drl_idx < max_ref_bv_num);
   int cost = 0;
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
   int bit_cnt = 0;
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
   for (int idx = 0; idx < max_ref_bv_num - 1; ++idx) {
+#if CONFIG_BYPASS_INTRABC_DRL_IDX
+    cost += av1_cost_literal(1);
+#else
     cost += x->mode_costs.intrabc_drl_idx_cost[bit_cnt][intrabc_drl_idx != idx];
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
     if (intrabc_drl_idx == idx) return cost;
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
     ++bit_cnt;
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
   }
   return cost;
 }
@@ -2937,7 +2949,12 @@
   ref_bv_cost += x->mode_costs.intrabc_mode_cost[intrabc_mode];
   ref_bv_cost +=
 #if CONFIG_IBC_BV_IMPROVEMENT && CONFIG_IBC_MAX_DRL
-      av1_get_intrabc_drl_idx_cost(max_bvp_drl_bits + 1, intrabc_drl_idx, x);
+      av1_get_intrabc_drl_idx_cost(max_bvp_drl_bits + 1, intrabc_drl_idx
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
+                                   ,
+                                   x
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
+      );
 #else
       av1_get_intrabc_drl_idx_cost(MAX_REF_BV_STACK_SIZE, intrabc_drl_idx, x);
 #endif  // CONFIG_IBC_BV_IMPROVEMENT && CONFIG_IBC_MAX_DRL

diff --git a/av1/encoder/mcomp.h b/av1/encoder/mcomp.h
index cfe4f45..4f57036 100644
--- a/av1/encoder/mcomp.h
+++ b/av1/encoder/mcomp.h

@@ -802,8 +802,12 @@
 void av1_init_ref_mv(MV_COST_PARAMS *mv_cost_params, const MV *ref_mv);
 
 // Compute the cost for signalling the intrabc DRL index
-int av1_get_intrabc_drl_idx_cost(int max_ref_bv_num, int intrabc_drl_idx,
-                                 const MACROBLOCK *x);
+int av1_get_intrabc_drl_idx_cost(int max_ref_bv_num, int intrabc_drl_idx
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
+                                 ,
+                                 const MACROBLOCK *x
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
+);
 
 // Compute the cost for signalling the intrabc mode and intrabc DRL index. This
 // is only used during the motion search

diff --git a/av1/encoder/partition_search.c b/av1/encoder/partition_search.c
index 367aab3..10699fa 100644
--- a/av1/encoder/partition_search.c
+++ b/av1/encoder/partition_search.c

@@ -1180,22 +1180,31 @@
 }
 
 #if CONFIG_IBC_BV_IMPROVEMENT
-static void update_intrabc_drl_idx_stats(int max_ref_bv_num, FRAME_CONTEXT *fc,
+static void update_intrabc_drl_idx_stats(int max_ref_bv_num,
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
+                                         FRAME_CONTEXT *fc,
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
                                          FRAME_COUNTS *counts,
                                          const MB_MODE_INFO *mbmi) {
 #if !CONFIG_ENTROPY_STATS
   (void)counts;
 #endif  // !CONFIG_ENTROPY_STATS
   assert(mbmi->intrabc_drl_idx < max_ref_bv_num);
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
   int bit_cnt = 0;
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
   for (int idx = 0; idx < max_ref_bv_num - 1; ++idx) {
-#if CONFIG_ENTROPY_STATS
+#if CONFIG_ENTROPY_STATS && !CONFIG_BYPASS_INTRABC_DRL_IDX
     counts->intrabc_drl_idx[bit_cnt][mbmi->intrabc_drl_idx != idx]++;
 #endif  // CONFIG_ENTROPY_STATS
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
     update_cdf(fc->intrabc_drl_idx_cdf[bit_cnt], mbmi->intrabc_drl_idx != idx,
                2);
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
     if (mbmi->intrabc_drl_idx == idx) break;
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
     ++bit_cnt;
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
   }
 }
 #endif  // CONFIG_IBC_BV_IMPROVEMENT
@@ -1234,6 +1243,10 @@
 #endif  // CONFIG_WARP_PRECISION
 
 ) {
+#if CONFIG_BYPASS_WARP_PARAM_HIGH
+  (void)max_coded_index;
+#endif
+
   assert(2 <= index && index <= 5);
   int index_type = (index == 2 || index == 5) ? 0 : 1;
   int coded_value_low_max = (WARP_DELTA_NUMSYMBOLS_LOW - 1);
@@ -1246,11 +1259,13 @@
              WARP_DELTA_NUMSYMBOLS_LOW);
 
 #if CONFIG_WARP_PRECISION
+#if !CONFIG_BYPASS_WARP_PARAM_HIGH
   if (max_coded_index >= WARP_DELTA_NUMSYMBOLS_LOW &&
       coded_value >= coded_value_low_max) {
     update_cdf(fc->warp_delta_param_high_cdf[index_type], coded_value - 7,
                WARP_DELTA_NUMSYMBOLS_HIGH);
   }
+#endif
 #endif  // CONFIG_WARP_PRECISION
 
 #if CONFIG_ENTROPY_STATS
@@ -1325,10 +1340,12 @@
                                     counts,
 #endif  // CONFIG_ENTROPY_STATS
                                     fc, max_coded_index);
+#if !CONFIG_BYPASS_WARP_PARAM_SIGN
       // update sign context
       if (coded_value) {
         update_cdf(fc->warp_param_sign_cdf, coded_value < 0, 2);
       }
+#endif
 #else
       int coded_value = (value / step_size) + max_coded_index;
       update_warp_delta_param_stats(index, coded_value,
@@ -1561,7 +1578,10 @@
       ++td->counts->intrabc_mode[mbmi->intrabc_mode];
 #endif  // CONFIG_ENTROPY_STATS
 #if CONFIG_IBC_MAX_DRL
-      update_intrabc_drl_idx_stats(cm->features.max_bvp_drl_bits + 1, fc,
+      update_intrabc_drl_idx_stats(cm->features.max_bvp_drl_bits + 1,
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
+                                   fc,
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
                                    td->counts, mbmi);
 #else
       update_intrabc_drl_idx_stats(MAX_REF_BV_STACK_SIZE, fc, td->counts, mbmi);

diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index ff59d5c..e2643a6 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c

@@ -199,8 +199,10 @@
     // y mode costs
     av1_cost_tokens_from_cdf(mode_costs->y_first_mode_costs[i],
                              fc->y_mode_idx_cdf_0[i], NULL);
+#if !CONFIG_CTX_Y_SECOND_MODE
     av1_cost_tokens_from_cdf(mode_costs->y_second_mode_costs[i],
                              fc->y_mode_idx_cdf_1[i], NULL);
+#endif  // !CONFIG_CTX_Y_SECOND_MODE
   }
 
   for (j = 0; j < UV_MODE_CONTEXTS; ++j)
@@ -263,8 +265,10 @@
 
 #if CONFIG_PALETTE_IMPROVEMENTS
 #if CONFIG_PALETTE_LINE_COPY
+#if !CONFIG_PLT_DIR_CTX
   av1_cost_tokens_from_cdf(mode_costs->palette_direction_cost,
                            fc->palette_direction_cdf, NULL);
+#endif  // !CONFIG_PLT_DIR_CTX
 #endif  // CONFIG_PALETTE_LINE_COPY
   for (i = 0; i < PALETTE_ROW_FLAG_CONTEXTS; ++i) {
     av1_cost_tokens_from_cdf(mode_costs->palette_y_row_flag_cost[i],
@@ -777,9 +781,16 @@
 #endif  // CONFIG_WARP_PRECISION
 
     for (i = 0; i < 3; i++) {
-      for (j = 0; j < WARP_REF_CONTEXTS; j++) {
-        av1_cost_tokens_from_cdf(mode_costs->warp_ref_idx_cost[i][j],
-                                 fc->warp_ref_idx_cdf[i][j], NULL);
+      if ((CONFIG_CTX_WARP_REFIDX_REDUCTION >> i) & 1) {
+        for (j = 0; j < WARP_REF_CONTEXTS; j++) {
+          mode_costs->warp_ref_idx_cost[i][j][0] = av1_cost_literal(1);
+          mode_costs->warp_ref_idx_cost[i][j][1] = av1_cost_literal(1);
+        }
+      } else {
+        for (j = 0; j < WARP_REF_CONTEXTS; j++) {
+          av1_cost_tokens_from_cdf(mode_costs->warp_ref_idx_cost[i][j],
+                                   fc->warp_ref_idx_cdf[i][j], NULL);
+        }
       }
     }
 
@@ -859,8 +870,13 @@
   av1_cost_tokens_from_cdf(mode_costs->pc_wiener_restore_cost,
                            fc->pc_wiener_restore_cdf, NULL);
   // Bit cost for parameter to designate whether unit coeffs are merged.
+#if CONFIG_MERGE_PARA_CTX
+  mode_costs->merged_param_cost[0] = av1_cost_literal(1);
+  mode_costs->merged_param_cost[1] = av1_cost_literal(1);
+#else
   av1_cost_tokens_from_cdf(mode_costs->merged_param_cost, fc->merged_param_cdf,
                            NULL);
+#endif  // !CONFIG_MERGE_PARA_CTX
 }
 
 // Values are now correlated to quantizer.
@@ -1319,8 +1335,13 @@
             pcost->base_bob_cost[ctx],
             fc->coeff_base_bob_cdf[AOMMIN(tx_size, TX_16X16)][ctx], NULL);
       for (int ctx = 0; ctx < EOB_COEF_CONTEXTS; ++ctx)
+#if CONFIG_EOB_PT_CTX_REDUCTION
+        av1_cost_tokens_from_cdf(pcost->eob_extra_cost[ctx], fc->eob_extra_cdf,
+                                 NULL);
+#else
         av1_cost_tokens_from_cdf(pcost->eob_extra_cost[ctx],
                                  fc->eob_extra_cdf[tx_size][plane][ctx], NULL);
+#endif
       for (int gr = 0; gr < DC_SIGN_GROUPS; ++gr) {
         for (int ctx = 0; ctx < DC_SIGN_CONTEXTS; ++ctx) {
           av1_cost_tokens_from_cdf(pcost->dc_sign_cost[gr][ctx],
@@ -1331,8 +1352,15 @@
       if (plane == PLANE_TYPE_UV) {
         for (int i = 0; i < CROSS_COMPONENT_CONTEXTS; ++i)
           for (int ctx = 0; ctx < DC_SIGN_CONTEXTS; ++ctx)
+#if CONFIG_BY_PASS_V_SIGN
+          {
+            pcost->v_dc_sign_cost[i][ctx][0] = av1_cost_literal(1);
+            pcost->v_dc_sign_cost[i][ctx][1] = av1_cost_literal(1);
+          }
+#else
             av1_cost_tokens_from_cdf(pcost->v_dc_sign_cost[i][ctx],
                                      fc->v_dc_sign_cdf[i][ctx], NULL);
+#endif
 #if !CONFIG_CTX_V_AC_SIGN
         for (int i = 0; i < CROSS_COMPONENT_CONTEXTS; ++i)
           av1_cost_tokens_from_cdf(pcost->v_ac_sign_cost[i],
@@ -1341,12 +1369,15 @@
       }
 #endif  // CONFIG_CONTEXT_DERIVATION
 
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS
       for (int ctx = 0; ctx < LF_LEVEL_CONTEXTS_UV; ++ctx) {
         int br_lf_cctx_rate[BR_CDF_SIZE];
         int prev_cost_lf_cctx = 0;
         int i, j;
+#if !CONFIG_COEFF_BR_LF_UV_BYPASS  // cost
         av1_cost_tokens_from_cdf(br_lf_cctx_rate, fc->coeff_br_lf_uv_cdf[ctx],
                                  NULL);
+#endif
         for (i = 0; i < COEFF_BASE_RANGE; i += BR_CDF_SIZE - 1) {
           for (j = 0; j < BR_CDF_SIZE - 1; j++) {
             pcost->lps_lf_cost_uv[ctx][i + j] =
@@ -1364,6 +1395,7 @@
               pcost->lps_lf_cost_uv[ctx][i] - pcost->lps_lf_cost_uv[ctx][i - 1];
         }
       }
+#endif
 
       for (int ctx = 0; ctx < LEVEL_CONTEXTS_UV; ++ctx) {
         int br_rate_cctx[BR_CDF_SIZE];
@@ -1532,6 +1564,7 @@
                              fc->coeff_base_ph_cdf[ctx], NULL);
   }
 
+#if !CONFIG_COEFF_BR_PH_BYPASS  // cost
   for (int ctx = 0; ctx < COEFF_BR_PH_CONTEXTS; ++ctx) {
     int br_ph_rate[BR_CDF_SIZE];
     int prev_cost = 0;
@@ -1553,6 +1586,7 @@
           pcost->lps_ph_cost[ctx][i] - pcost->lps_ph_cost[ctx][i - 1];
     }
   }
+#endif
 }
 
 #if CONFIG_IBC_SUBPEL_PRECISION

diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 30986b7..05aa679 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c

@@ -7986,7 +7986,12 @@
 #else
           MAX_REF_BV_STACK_SIZE,
 #endif  // CONFIG_IBC_BV_IMPROVEMENT && CONFIG_IBC_MAX_DRL
-          mbmi->intrabc_drl_idx, x);
+          mbmi->intrabc_drl_idx
+#if !CONFIG_BYPASS_INTRABC_DRL_IDX
+          ,
+          x
+#endif  // CONFIG_BYPASS_INTRABC_DRL_IDX
+      );
 #else
     // TODO(aconverse@google.com): The full motion field defining discount
     // in MV_COST_WEIGHT is too large. Explore other values.

diff --git a/av1/encoder/tokenize.c b/av1/encoder/tokenize.c
index 59cdae3..2b0b99b 100644
--- a/av1/encoder/tokenize.c
+++ b/av1/encoder/tokenize.c

@@ -55,9 +55,15 @@
   int identity_row_flag = 0;
   const int axis1_limit = direction ? rows : cols;
   const int axis2_limit = direction ? cols : rows;
+#if !CONFIG_PLT_DIR_CTX
   PaletteDirectionCost direction_cost = param->direction_cost;
+#endif  // !CONFIG_PLT_DIR_CTX
   if (calc_rate && plane_block_width < 64 && plane_block_height < 64) {
+#if CONFIG_PLT_DIR_CTX
+    this_rate += av1_cost_literal(1);  // direction_cost
+#else
     this_rate += (*direction_cost)[direction];
+#endif  // CONFIG_PLT_DIR_CTX
   }
   for (int ax2 = 0; ax2 < axis2_limit; ax2++) {
     int line_copy_flag = 0;
@@ -114,9 +120,11 @@
           (*t)->direction = direction;
           (*t)++;
           if (allow_update_cdf) {
+#if !CONFIG_PLT_DIR_CTX
             if (plane_block_width < 64 && plane_block_height < 64) {
               update_cdf(param->direction_cdf, direction, 2);
             }
+#endif  // !CONFIG_PLT_DIR_CTX
             update_cdf(identity_row_cdf[ctx], identity_row_flag, 3);
           }
         } else {
@@ -370,8 +378,10 @@
 
 #if CONFIG_PALETTE_IMPROVEMENTS
 #if CONFIG_PALETTE_LINE_COPY
+#if !CONFIG_PLT_DIR_CTX
   params->direction_cdf = xd->tile_ctx->palette_direction_cdf;
   params->direction_cost = &x->mode_costs.palette_direction_cost;
+#endif  // !CONFIG_PLT_DIR_CTX
 #endif  // CONFIG_PALETTE_LINE_COPY
   params->identity_row_cdf = plane ? xd->tile_ctx->identity_row_cdf_uv
                                    : xd->tile_ctx->identity_row_cdf_y;

diff --git a/av1/encoder/trellis_quant.c b/av1/encoder/trellis_quant.c
index 8ca3f76..ae8818a 100644
--- a/av1/encoder/trellis_quant.c
+++ b/av1/encoder/trellis_quant.c

@@ -156,8 +156,12 @@
     if (plane > 0) {
       if (limits) {
         if (abs_qc > LF_NUM_BASE_LEVELS) {
+#if CONFIG_COEFF_BR_LF_UV_BYPASS  // cost
+          cost += get_br_lf_cost_tcq_uv(abs_qc);
+#else
           int br_ctx = get_br_ctx_lf_eob_chroma(ci, tx_class);
           cost += get_br_lf_cost_tcq(abs_qc, txb_costs->lps_lf_cost_uv[br_ctx]);
+#endif
         }
       } else {
         if (abs_qc > NUM_BASE_LEVELS) {
@@ -255,8 +259,12 @@
     if (plane > 0) {
       if (limits) {
         if (abs_qc > LF_NUM_BASE_LEVELS) {
+#if CONFIG_COEFF_BR_LF_UV_BYPASS  // cost
+          cost += get_br_lf_cost_tcq_uv(abs_qc);
+#else
           cost +=
               get_br_lf_cost_tcq(abs_qc, txb_costs->lps_lf_cost_uv[mid_ctx]);
+#endif
         }
       } else {
         if (abs_qc > NUM_BASE_LEVELS) {
@@ -1061,9 +1069,13 @@
         for (int i = 0; i < TCQ_N_STATES; i++) {
           int base_ctx = get_lower_levels_lf_ctx_chroma(prev_levels[i], blk_pos,
                                                         bwl, tx_class, plane);
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+          coeff_ctx.coef[i] = base_ctx - diag_ctx;
+#else
           int br_ctx =
               get_br_lf_ctx_chroma(prev_levels[i], blk_pos, bwl, tx_class);
           coeff_ctx.coef[i] = base_ctx - diag_ctx + (br_ctx << 4);
+#endif
         }
         av1_get_rate_dist_lf_chroma(txb_costs, &pqData, &coeff_ctx, blk_pos,
                                     diag_ctx, eob_rate, dc_sign_ctx, tmp_sign,

diff --git a/av1/encoder/trellis_quant.h b/av1/encoder/trellis_quant.h
index 9f18193..f6fb4a6 100644
--- a/av1/encoder/trellis_quant.h
+++ b/av1/encoder/trellis_quant.h

@@ -152,6 +152,15 @@
   return low;
 }
 
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+// Get the high range part of a coeff
+static AOM_FORCE_INLINE int get_high_range_uv(int abs_qc, int lf) {
+  int base_levels = lf ? 6 : 4;
+  int high_range = (abs_qc - (base_levels - 1)) >> 1;
+  return high_range;
+}
+#endif
+
 // Get the high range part of a coeff
 static AOM_FORCE_INLINE int get_high_range(int abs_qc, int lf) {
   int base_levels = lf ? 6 : 4;
@@ -173,6 +182,15 @@
 #endif
 }
 
+#if CONFIG_COEFF_BR_LF_UV_BYPASS
+// Calculate the cost of low range of a coeff in low-freq region
+static AOM_FORCE_INLINE int get_br_lf_cost_tcq_uv(tran_low_t level) {
+  const int r = 1 + get_high_range_uv(level, 1);
+  const int length = get_msb(r) + 1;
+  return av1_cost_literal(2 * length - 1);
+}
+#endif
+
 // Calculate the cost of low range of a coeff in low-freq region
 static AOM_FORCE_INLINE int get_br_lf_cost_tcq(tran_low_t level,
                                                const int *coeff_lps) {

diff --git a/av1/encoder/x86/trellis_quant_avx2.c b/av1/encoder/x86/trellis_quant_avx2.c
index 5364027..492ae45 100644
--- a/av1/encoder/x86/trellis_quant_avx2.c
+++ b/av1/encoder/x86/trellis_quant_avx2.c

@@ -348,8 +348,12 @@
     }
     if (plane > 0) {
       if (abs_qc > LF_NUM_BASE_LEVELS) {
+#if CONFIG_COEFF_BR_LF_UV_BYPASS  // cost
+        cost += get_br_lf_cost_tcq_uv(abs_qc);
+#else
         int br_ctx = get_br_ctx_lf_eob_chroma(ci, tx_class);
         cost += get_br_lf_cost_tcq(abs_qc, txb_costs->lps_lf_cost_uv[br_ctx]);
+#endif
       }
     } else {
       if (abs_qc > LF_NUM_BASE_LEVELS) {
@@ -393,9 +397,13 @@
   else
     cost += txb_costs->dc_sign_cost[dc_ph_group][dc_sign_ctx][sign];
   if (plane > 0) {
+#if CONFIG_COEFF_BR_LF_UV_BYPASS  // cost
+    cost += get_br_lf_cost_tcq_uv(abs_qc);
+#else
     if (abs_qc > LF_NUM_BASE_LEVELS) {
       cost += get_br_lf_cost_tcq(abs_qc, txb_costs->lps_lf_cost_uv[mid_ctx]);
     }
+#endif
   } else {
     if (abs_qc > LF_NUM_BASE_LEVELS) {
       cost += get_br_lf_cost_tcq(abs_qc, txb_costs->lps_lf_cost[mid_ctx]);

diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake
index 49ca8a0..020294f 100644
--- a/build/cmake/aom_config_defaults.cmake
+++ b/build/cmake/aom_config_defaults.cmake

@@ -147,8 +147,24 @@
 set_aom_config_var(CONFIG_PARAKIT_COLLECT_DATA 0
                    "enables data collection for ParaKit training.")
 
+# FG8 context simplification tests
 set_aom_config_var(CONFIG_CTX_V_AC_SIGN 1 "FG8-Test1.")
 set_aom_config_var(CONFIG_CTX_MV_SHELL_OFFSET_OTHER 1 "FG8-Test3.")
+set_aom_config_var(CONFIG_EOB_PT_CTX_REDUCTION 1 "FG8-Test4.")
+set_aom_config_var(CONFIG_COEFF_BR_LF_UV_BYPASS 1
+                   "AV2 experiment flag to bypass UV LF syntax. FG8-Test9.")
+set_aom_config_var(CONFIG_COEFF_BR_PH_BYPASS 1
+                   "AV2 experiment flag to bypass BR PH syntax. FG8-Test10.")
+set_aom_config_var(CONFIG_BY_PASS_V_SIGN 1 "FG8-Test11.")
+set_aom_config_var(CONFIG_CTX_WARP_REFIDX_REDUCTION 7
+                   "FG8-Test19, Test20, Test21")
+set_aom_config_var(CONFIG_BYPASS_WARP_PARAM_HIGH 1 "bypass coding FG8-Test22")
+set_aom_config_var(CONFIG_BYPASS_WARP_PARAM_SIGN 1 "bypass coding FG8-Test23")
+set_aom_config_var(CONFIG_PLT_DIR_CTX 1 "by-pass PLT dir coding. FG8-Test24")
+set_aom_config_var(CONFIG_BYPASS_INTRABC_DRL_IDX 1 "bypass coding FG8-Test25")
+set_aom_config_var(CONFIG_MERGE_PARA_CTX 1
+                   "by-pass merge para coding. FG8-Test26")
+set_aom_config_var(CONFIG_CTX_Y_SECOND_MODE 1 "bypass coding FG8-Test27")
 
 # AV2 experiment flags.
 set_aom_config_var(