diff --git a/aom/aom_encoder.h b/aom/aom_encoder.h
index 44ff95c..366c890 100644
--- a/aom/aom_encoder.h
+++ b/aom/aom_encoder.h
@@ -258,6 +258,18 @@
    *
    */
   unsigned int use_ml_erp_pruning;
+  /*!\brief disable 3-way partitions for 64xN and Nx64 (N <= 64) blocks
+   *
+   */
+  unsigned int disable_3way_part_64xn;
+  /*!\brief disable 3-way partitions for 32xN and Nx32 (N <= 32) blocks
+   *
+   */
+  unsigned int disable_3way_part_32xn;
+  /*!\brief disable 3-way partitions for 16xN and Nx16 (N <= 16) blocks
+   *
+   */
+  unsigned int disable_3way_part_16xn;
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   /*!\brief disable ml-based speed-up for transform search
    *
diff --git a/apps/aomenc.c b/apps/aomenc.c
index 638ffd0..94c83f6 100644
--- a/apps/aomenc.c
+++ b/apps/aomenc.c
@@ -425,6 +425,9 @@
 #if CONFIG_EXT_RECUR_PARTITIONS
   &g_av1_codec_arg_defs.erp_pruning_level,
   &g_av1_codec_arg_defs.use_ml_erp_pruning,
+  &g_av1_codec_arg_defs.disable_3way_part_64xn,
+  &g_av1_codec_arg_defs.disable_3way_part_32xn,
+  &g_av1_codec_arg_defs.disable_3way_part_16xn,
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   &g_av1_codec_arg_defs.enable_sdp,
   &g_av1_codec_arg_defs.enable_mrls,
@@ -605,6 +608,9 @@
 #if CONFIG_EXT_RECUR_PARTITIONS
   config->erp_pruning_level = 5;
   config->use_ml_erp_pruning = 0;
+  config->disable_3way_part_64xn = 0;
+  config->disable_3way_part_32xn = 0;
+  config->disable_3way_part_16xn = 0;
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   config->enable_sdp = 1;
   config->enable_mrls = 1;
diff --git a/av1/arg_defs.c b/av1/arg_defs.c
index 5b20964..75df663 100644
--- a/av1/arg_defs.c
+++ b/av1/arg_defs.c
@@ -345,6 +345,18 @@
   .use_ml_erp_pruning = ARG_DEF(NULL, "use-ml-erp-pruning", 1,
                                 "Use ML model to perform ERP Pruning."
                                 "(0: off (default), 1: on)."),
+  .disable_3way_part_64xn =
+      ARG_DEF(NULL, "disable-3way-part-64xn", 1,
+              "Disable ternary partitions in 64xN/Nx64 (N<=64) blocks."
+              "(0: off (default), 1: on)."),
+  .disable_3way_part_32xn =
+      ARG_DEF(NULL, "disable-3way-part-32xn", 1,
+              "Disable ternary partitions in 32xN/Nx32 (N<=32) blocks."
+              "(0: off (default), 1: on)."),
+  .disable_3way_part_16xn =
+      ARG_DEF(NULL, "disable-3way-part-16xn", 1,
+              "Disable ternary partitions in 16xN/Nx16 (N<=16) blocks."
+              "(0: off (default), 1: on)."),
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   .enable_rect_partitions = ARG_DEF(NULL, "enable-rect-partitions", 1,
                                     "Enable rectangular partitions "
diff --git a/av1/arg_defs.h b/av1/arg_defs.h
index 8c66828..6523ac9 100644
--- a/av1/arg_defs.h
+++ b/av1/arg_defs.h
@@ -138,6 +138,9 @@
 #if CONFIG_EXT_RECUR_PARTITIONS
   arg_def_t erp_pruning_level;
   arg_def_t use_ml_erp_pruning;
+  arg_def_t disable_3way_part_64xn;
+  arg_def_t disable_3way_part_32xn;
+  arg_def_t disable_3way_part_16xn;
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   arg_def_t enable_rect_partitions;
   arg_def_t enable_ab_partitions;
diff --git a/av1/av1_cx_iface.c b/av1/av1_cx_iface.c
index 57bac05..a0f55c1 100644
--- a/av1/av1_cx_iface.c
+++ b/av1/av1_cx_iface.c
@@ -112,6 +112,9 @@
 #if CONFIG_EXT_RECUR_PARTITIONS
   unsigned int erp_pruning_level;
   int use_ml_erp_pruning;
+  unsigned int disable_3way_part_64xn;
+  unsigned int disable_3way_part_32xn;
+  unsigned int disable_3way_part_16xn;
 #endif                         // CONFIG_EXT_RECUR_PARTITIONS
   int enable_rect_partitions;  // enable rectangular partitions for sequence
   int enable_ab_partitions;    // enable AB partitions for sequence
@@ -413,6 +416,9 @@
   1,  // disable ML based partition speed up features
   5,  // aggressiveness for erp pruning
   0,  // use ml model for erp pruning
+  0,  // disable ternary partitions in 64xN/Nx64(N<=64) blocks
+  0,  // disable ternary partitions in 32xN/Nx32(N<=32) blocks
+  0,  // disable ternary partitions in 16xN/Nx16(N<=16) blocks
 #else
   0,  // disable ML based partition speed up features
 #endif
@@ -887,6 +893,9 @@
 #if CONFIG_EXT_RECUR_PARTITIONS
   cfg->erp_pruning_level = extra_cfg->erp_pruning_level;
   cfg->use_ml_erp_pruning = extra_cfg->use_ml_erp_pruning;
+  cfg->disable_3way_part_64xn = extra_cfg->disable_3way_part_64xn;
+  cfg->disable_3way_part_32xn = extra_cfg->disable_3way_part_32xn;
+  cfg->disable_3way_part_16xn = extra_cfg->disable_3way_part_16xn;
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   cfg->enable_rect_partitions = extra_cfg->enable_rect_partitions;
   cfg->enable_ab_partitions = extra_cfg->enable_ab_partitions;
@@ -983,6 +992,9 @@
 #if CONFIG_EXT_RECUR_PARTITIONS
   extra_cfg->erp_pruning_level = cfg->erp_pruning_level;
   extra_cfg->use_ml_erp_pruning = cfg->use_ml_erp_pruning;
+  extra_cfg->disable_3way_part_64xn = cfg->disable_3way_part_64xn;
+  extra_cfg->disable_3way_part_32xn = cfg->disable_3way_part_32xn;
+  extra_cfg->disable_3way_part_16xn = cfg->disable_3way_part_16xn;
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   extra_cfg->enable_sdp = cfg->enable_sdp;
   extra_cfg->enable_mrls = cfg->enable_mrls;
@@ -1460,6 +1472,9 @@
 #if CONFIG_EXT_RECUR_PARTITIONS
   part_cfg->erp_pruning_level = extra_cfg->erp_pruning_level;
   part_cfg->use_ml_erp_pruning = extra_cfg->use_ml_erp_pruning;
+  part_cfg->disable_3way_part_64xn = extra_cfg->disable_3way_part_64xn;
+  part_cfg->disable_3way_part_32xn = extra_cfg->disable_3way_part_32xn;
+  part_cfg->disable_3way_part_16xn = extra_cfg->disable_3way_part_16xn;
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   part_cfg->min_partition_size = extra_cfg->min_partition_size;
   part_cfg->max_partition_size = extra_cfg->max_partition_size;
@@ -3602,6 +3617,18 @@
   } else if (arg_match_helper(&arg, &g_av1_codec_arg_defs.use_ml_erp_pruning,
                               argv, err_string)) {
     extra_cfg.use_ml_erp_pruning = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.disable_3way_part_64xn,
+                              argv, err_string)) {
+    extra_cfg.disable_3way_part_64xn = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.disable_3way_part_32xn,
+                              argv, err_string)) {
+    extra_cfg.disable_3way_part_32xn = arg_parse_int_helper(&arg, err_string);
+  } else if (arg_match_helper(&arg,
+                              &g_av1_codec_arg_defs.disable_3way_part_16xn,
+                              argv, err_string)) {
+    extra_cfg.disable_3way_part_16xn = arg_parse_int_helper(&arg, err_string);
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   } else if (arg_match_helper(
                  &arg,
@@ -4070,6 +4097,9 @@
         1,
         5,  // aggressiveness for erp pruning
         0,  // use ml model for erp pruning
+        0,  // disable ternary partition in 64xN/Nx64(N<=64) blocks
+        0,  // disable ternary partition in 32xN/Nx32(N<=32) blocks
+        0,  // disable ternary partition in 16xN/Nx16(N<=16) blocks
 #else       // CONFIG_EXT_RECUR_PARTITIONS
         0,
 #endif      // CONFIG_EXT_RECUR_PARTITIONS
diff --git a/av1/common/av1_common_int.h b/av1/common/av1_common_int.h
index 78b6d1a..9a299f2 100644
--- a/av1/common/av1_common_int.h
+++ b/av1/common/av1_common_int.h
@@ -466,6 +466,11 @@
 #if CONFIG_REF_MV_BANK
   uint8_t enable_refmvbank;  // To turn on/off Ref MV Bank
 #endif                       // CONFIG_REF_MV_BANK
+#if CONFIG_EXT_RECUR_PARTITIONS
+  uint8_t disable_3way_part_64xn;  // disable 3way part in 64xn/nx64(n <= 64)
+  uint8_t disable_3way_part_32xn;  // disable 3way part in 32xn/nx32(n <= 32)
+  uint8_t disable_3way_part_16xn;  // disable 3way part in 16xn/nx16(n <= 16)
+#endif                             // CONFIG_EXT_RECUR_PARTITIONS
   BITSTREAM_PROFILE profile;
 
   // Color config.
@@ -2208,6 +2213,7 @@
     return EXT_PARTITION_TYPES;
 }
 
+#if CONFIG_EXT_RECUR_PARTITIONS
 static INLINE int limited_partition_cdf_length(BLOCK_SIZE bsize) {
   assert(block_size_wide[bsize] == block_size_high[bsize]);
   assert(is_bsize_geq(bsize, BLOCK_8X8));
@@ -2215,7 +2221,6 @@
   return partition_cdf_length(bsize) - 1;
 }
 
-#if CONFIG_EXT_RECUR_PARTITIONS
 static INLINE int partition_rec_cdf_length(BLOCK_SIZE bsize) {
   assert(block_size_wide[bsize] != block_size_high[bsize]);
 
@@ -2240,6 +2245,26 @@
   }
 }
 
+static INLINE int partition_noext_rec_cdf_length(BLOCK_SIZE bsize) {
+  assert(block_size_wide[bsize] != block_size_high[bsize]);
+
+  switch (bsize) {
+    case BLOCK_4X8:
+    case BLOCK_8X4:
+    case BLOCK_64X128:
+    case BLOCK_128X64: return 2;
+    case BLOCK_8X16:
+    case BLOCK_16X8:
+    case BLOCK_16X32:
+    case BLOCK_32X16:
+    case BLOCK_32X64:
+    case BLOCK_64X32: return PARTITION_TYPES;
+    default:
+      assert(0 && "Invalid splittable rectangular bsize");
+      return PARTITION_INVALID_REC;
+  }
+}
+
 static INLINE int is_1_to_2_block(BLOCK_SIZE bsize) {
   return 2 * block_size_high[bsize] == block_size_wide[bsize] ||
          block_size_high[bsize] == 2 * block_size_wide[bsize];
@@ -2253,6 +2278,15 @@
   assert(is_1_to_2_block(bsize));
   return partition_rec_cdf_length(bsize) - 1;
 }
+
+static INLINE int partition_middle_noext_rec_cdf_length(BLOCK_SIZE bsize) {
+  // For some bock sizes, HORZ|VERT is already unavailable, so we shouldn't call
+  // this function.
+  assert(is_bsize_geq(bsize, BLOCK_8X8));
+  assert(is_bsize_geq(BLOCK_64X64, bsize));
+  assert(is_1_to_2_block(bsize));
+  return partition_noext_rec_cdf_length(bsize) - 1;
+}
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
 
 static INLINE int max_block_wide(const MACROBLOCKD *xd, BLOCK_SIZE bsize,
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 14df418..a48491c 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -579,7 +579,19 @@
          is_inter_ref_frame(mbmi->ref_frame[0]);
 }
 
+static INLINE int is_square_block(BLOCK_SIZE bsize) {
+  return block_size_high[bsize] == block_size_wide[bsize];
+}
+
 #if CONFIG_EXT_RECUR_PARTITIONS
+static INLINE bool is_tall_block(BLOCK_SIZE bsize) {
+  return block_size_high[bsize] > block_size_wide[bsize];
+}
+
+static INLINE bool is_wide_block(BLOCK_SIZE bsize) {
+  return block_size_high[bsize] < block_size_wide[bsize];
+}
+
 static INLINE PARTITION_TYPE get_partition_from_symbol_rec_block(
     BLOCK_SIZE bsize, PARTITION_TYPE_REC partition_rec) {
   if (block_size_wide[bsize] > block_size_high[bsize])
@@ -590,6 +602,26 @@
     return PARTITION_INVALID;
 }
 
+static INLINE PARTITION_TYPE
+get_partition_noext_from_symbol_rec_block(BLOCK_SIZE bsize, int symbol) {
+  if (symbol == 0) {
+    return PARTITION_NONE;
+  } else {
+    const int is_wide = is_wide_block(bsize);
+    const PARTITION_TYPE partition_longside_2way =
+        is_wide ? PARTITION_VERT : PARTITION_HORZ;
+    const PARTITION_TYPE partition_shortside_2way =
+        is_wide ? PARTITION_HORZ : PARTITION_VERT;
+
+    if (symbol == 1)
+      return partition_longside_2way;
+    else if (symbol == 2)
+      return partition_shortside_2way;
+    else
+      return PARTITION_INVALID;
+  }
+}
+
 static INLINE PARTITION_TYPE_REC get_symbol_from_partition_rec_block(
     BLOCK_SIZE bsize, PARTITION_TYPE partition) {
   assert(bsize < BLOCK_SIZES_ALL);
@@ -602,6 +634,23 @@
     return PARTITION_INVALID_REC;
 }
 
+static INLINE PARTITION_TYPE_REC get_symbol_from_partition_noext_rec_block(
+    BLOCK_SIZE bsize, PARTITION_TYPE partition) {
+  assert(bsize < BLOCK_SIZES_ALL);
+  assert(partition < EXT_PARTITION_TYPES);
+
+  if (partition >= PARTITION_TYPES) return PARTITION_INVALID_REC;
+  if (partition == PARTITION_NONE) return 0;
+
+  PARTITION_TYPE partition_longside_2way =
+      is_wide_block(bsize) ? PARTITION_VERT : PARTITION_HORZ;
+  if (is_bsize_geq(BLOCK_8X8, bsize) || is_bsize_geq(bsize, BLOCK_64X64)) {
+    return partition == partition_longside_2way ? 1 : PARTITION_INVALID_REC;
+  } else {
+    return partition == partition_longside_2way ? 1 : 2;
+  }
+}
+
 static INLINE PARTITION_TYPE get_symbol_from_limited_partition(
     PARTITION_TYPE part, PARTITION_TYPE parent_part) {
   assert(part != PARTITION_INVALID);
@@ -620,6 +669,26 @@
   return symbol;
 }
 
+static INLINE PARTITION_TYPE get_symbol_from_limited_partition_noext(
+    PARTITION_TYPE part, PARTITION_TYPE parent_part) {
+  assert(part != PARTITION_INVALID);
+  assert(parent_part == PARTITION_HORZ_3 || parent_part == PARTITION_VERT_3);
+  static const int partition_to_symbol_map[NUM_LIMITED_PARTITION_PARENTS]
+                                          [EXT_PARTITION_TYPES] = {
+                                            // PARTITION_HORZ_3
+                                            { 0, PARTITION_INVALID_REC, 1,
+                                              PARTITION_INVALID_REC,
+                                              PARTITION_INVALID_REC },
+                                            // PARTITION_VERT_3
+                                            { 0, 1, PARTITION_INVALID_REC,
+                                              PARTITION_INVALID_REC,
+                                              PARTITION_INVALID_REC },
+                                          };
+  const int dir = (parent_part == PARTITION_HORZ_3) ? 0 : 1;
+  const int symbol = partition_to_symbol_map[dir][part];
+  return symbol;
+}
+
 static INLINE PARTITION_TYPE
 get_limited_partition_from_symbol(int symbol, PARTITION_TYPE parent_part) {
   assert(parent_part == PARTITION_HORZ_3 || parent_part == PARTITION_VERT_3);
@@ -641,6 +710,25 @@
   }
 }
 
+static INLINE PARTITION_TYPE get_limited_partition_noext_from_symbol(
+    int symbol, PARTITION_TYPE parent_part) {
+  assert(parent_part == PARTITION_HORZ_3 || parent_part == PARTITION_VERT_3);
+  static const PARTITION_TYPE horz3_parts[LIMITED_PARTITION_TYPES] = {
+    PARTITION_NONE, PARTITION_VERT
+  };
+  static const PARTITION_TYPE vert3_parts[LIMITED_PARTITION_TYPES] = {
+    PARTITION_NONE, PARTITION_HORZ
+  };
+  switch (parent_part) {
+    case PARTITION_HORZ_3: return horz3_parts[symbol];
+    case PARTITION_VERT_3: return vert3_parts[symbol];
+    default:
+      assert(0 &&
+             "Invalid parent partition in get_limited_partition from symbol");
+      return PARTITION_INVALID;
+  }
+}
+
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
 
 static INLINE int has_second_ref(const MB_MODE_INFO *mbmi) {
@@ -704,20 +792,6 @@
          block_size_allowed;
 }
 
-static INLINE int is_square_block(BLOCK_SIZE bsize) {
-  return block_size_high[bsize] == block_size_wide[bsize];
-}
-
-#if CONFIG_EXT_RECUR_PARTITIONS
-static INLINE bool is_tall_block(BLOCK_SIZE bsize) {
-  return block_size_high[bsize] > block_size_wide[bsize];
-}
-
-static INLINE bool is_wide_block(BLOCK_SIZE bsize) {
-  return block_size_high[bsize] < block_size_wide[bsize];
-}
-#endif  // CONFIG_EXT_RECUR_PARTITIONS
-
 static INLINE int is_partition_point(BLOCK_SIZE bsize) {
 #if CONFIG_EXT_RECUR_PARTITIONS
   return bsize != BLOCK_4X4 && bsize < BLOCK_SIZES;
diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index 3e6e0b4..a22fbc2 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -285,6 +285,64 @@
                                       { AOM_CDF3(2715, 30175) },
                                       { AOM_CDF3(2286, 20850) },
                                   } };
+static const aom_cdf_prob
+    default_partition_noext_cdf[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS]
+                               [CDF_SIZE(PARTITION_TYPES)] = {
+                                 {
+                                     // 8x8
+                                     { AOM_CDF3(25405, 29765) },
+                                     { AOM_CDF3(20718, 26547) },
+                                     { AOM_CDF3(18495, 29033) },
+                                     { AOM_CDF3(14030, 27418) },
+                                     // 16x16
+                                     { AOM_CDF3(17068, 26841) },
+                                     { AOM_CDF3(11534, 19955) },
+                                     { AOM_CDF3(9216, 26696) },
+                                     { AOM_CDF3(7987, 20777) },
+                                     // 32x32
+                                     { AOM_CDF3(13065, 27593) },
+                                     { AOM_CDF3(8608, 20630) },
+                                     { AOM_CDF3(5281, 27411) },
+                                     { AOM_CDF3(6459, 20044) },
+                                     // 64x64
+                                     { AOM_CDF3(9265, 26250) },
+                                     { AOM_CDF3(7509, 17214) },
+                                     { AOM_CDF3(2577, 28098) },
+                                     { AOM_CDF3(2577, 28098) },
+                                     // 128x128
+                                     { AOM_CDF3(22143, 27468) },
+                                     { AOM_CDF3(6754, 12691) },
+                                     { AOM_CDF3(2715, 30175) },
+                                     { AOM_CDF3(2286, 20850) },
+                                 },
+                                 {
+                                     // 8x8
+                                     { AOM_CDF3(25405, 29765) },
+                                     { AOM_CDF3(20718, 26547) },
+                                     { AOM_CDF3(18495, 29033) },
+                                     { AOM_CDF3(14030, 27418) },
+                                     // 16x16
+                                     { AOM_CDF3(17068, 26841) },
+                                     { AOM_CDF3(11534, 19955) },
+                                     { AOM_CDF3(9216, 26696) },
+                                     { AOM_CDF3(7987, 20777) },
+                                     // 32x32
+                                     { AOM_CDF3(13065, 27593) },
+                                     { AOM_CDF3(8608, 20630) },
+                                     { AOM_CDF3(5281, 27411) },
+                                     { AOM_CDF3(6459, 20044) },
+                                     // 64x64
+                                     { AOM_CDF3(9265, 26250) },
+                                     { AOM_CDF3(7509, 17214) },
+                                     { AOM_CDF3(2577, 28098) },
+                                     { AOM_CDF3(2577, 28098) },
+                                     // 128x128
+                                     { AOM_CDF3(22143, 27468) },
+                                     { AOM_CDF3(6754, 12691) },
+                                     { AOM_CDF3(2715, 30175) },
+                                     { AOM_CDF3(2286, 20850) },
+                                 }
+                               };
 #else   // !ERP_LIMIT_PARTITION3_128
 static const aom_cdf_prob
     default_partition_cdf[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS][CDF_SIZE(
@@ -378,7 +436,6 @@
         },
         // VERT_3
         {
-
             // 8x8
             { AOM_CDF2(24114) },
             { AOM_CDF2(20966) },
@@ -404,7 +461,6 @@
             { AOM_CDF2(16584) },
             { AOM_CDF2(15476) },
             { AOM_CDF2(11625) },
-
         } },
       // Chroma
       { // HORZ_3
@@ -437,7 +493,6 @@
         },
         // VERT_3
         {
-
             // 8x8
             { AOM_CDF2(24114) },
             { AOM_CDF2(20966) },
@@ -463,7 +518,124 @@
             { AOM_CDF2(16584) },
             { AOM_CDF2(15476) },
             { AOM_CDF2(11625) },
-
+        } }
+    };
+static const aom_cdf_prob default_limited_partition_noext_cdf
+    [PARTITION_STRUCTURE_NUM][NUM_LIMITED_PARTITION_PARENTS][PARTITION_CONTEXTS]
+    [CDF_SIZE(LIMITED_PARTITION_TYPES)] = {
+      // Luma/Shared
+      { // HORZ_3
+        {
+            // 8x8
+            { AOM_CDF2(25550) },
+            { AOM_CDF2(21449) },
+            { AOM_CDF2(22555) },
+            { AOM_CDF2(21203) },
+            // 16x16
+            { AOM_CDF2(16588) },
+            { AOM_CDF2(9278) },
+            { AOM_CDF2(11426) },
+            { AOM_CDF2(7824) },
+            // 32x32
+            { AOM_CDF2(13817) },
+            { AOM_CDF2(7015) },
+            { AOM_CDF2(9045) },
+            { AOM_CDF2(5801) },
+            // 64x64
+            { AOM_CDF2(22701) },
+            { AOM_CDF2(7745) },
+            { AOM_CDF2(9203) },
+            { AOM_CDF2(5150) },
+            // 128x128
+            { AOM_CDF2(27175) },  // Unused
+            { AOM_CDF2(11141) },  // Unused
+            { AOM_CDF2(15312) },  // Unused
+            { AOM_CDF2(7362) },   // Unused
+        },
+        // VERT_3
+        {
+            // 8x8
+            { AOM_CDF2(24114) },
+            { AOM_CDF2(20966) },
+            { AOM_CDF2(18259) },
+            { AOM_CDF2(17964) },
+            // 16x16
+            { AOM_CDF2(16315) },
+            { AOM_CDF2(11233) },
+            { AOM_CDF2(8724) },
+            { AOM_CDF2(7346) },
+            // 32x32
+            { AOM_CDF2(13603) },
+            { AOM_CDF2(8550) },
+            { AOM_CDF2(7448) },
+            { AOM_CDF2(6276) },
+            // 64x64
+            { AOM_CDF2(22750) },
+            { AOM_CDF2(8951) },
+            { AOM_CDF2(8126) },
+            { AOM_CDF2(49802) },
+            // 128x128
+            { AOM_CDF2(27774) },
+            { AOM_CDF2(16584) },
+            { AOM_CDF2(15476) },
+            { AOM_CDF2(11625) },
+        } },
+      // Chroma
+      { // HORZ_3
+        {
+            // 8x8
+            { AOM_CDF2(25550) },
+            { AOM_CDF2(21449) },
+            { AOM_CDF2(22555) },
+            { AOM_CDF2(21203) },
+            // 16x16
+            { AOM_CDF2(16588) },
+            { AOM_CDF2(9278) },
+            { AOM_CDF2(11426) },
+            { AOM_CDF2(7824) },
+            // 32x32
+            { AOM_CDF2(13817) },
+            { AOM_CDF2(7015) },
+            { AOM_CDF2(9045) },
+            { AOM_CDF2(5801) },
+            // 64x64
+            { AOM_CDF2(22701) },
+            { AOM_CDF2(7745) },
+            { AOM_CDF2(9203) },
+            { AOM_CDF2(5150) },
+            // 128x128
+            { AOM_CDF2(27175) },  // Unused
+            { AOM_CDF2(11141) },  // Unused
+            { AOM_CDF2(15312) },  // Unused
+            { AOM_CDF2(7362) },   // Unused
+        },
+        // VERT_3
+        {
+            // 8x8
+            { AOM_CDF2(24114) },
+            { AOM_CDF2(20966) },
+            { AOM_CDF2(18259) },
+            { AOM_CDF2(17964) },
+            // 16x16
+            { AOM_CDF2(16315) },
+            { AOM_CDF2(11233) },
+            { AOM_CDF2(8724) },
+            { AOM_CDF2(7346) },
+            // 32x32
+            { AOM_CDF2(13603) },
+            { AOM_CDF2(8550) },
+            { AOM_CDF2(7448) },
+            { AOM_CDF2(6276) },
+            // 64x64
+            { AOM_CDF2(22750) },
+            { AOM_CDF2(8951) },
+            { AOM_CDF2(8126) },
+            { AOM_CDF2(4980) },
+            // 128x128
+            { AOM_CDF2(27774) },
+            { AOM_CDF2(16584) },
+            { AOM_CDF2(15476) },
+            { AOM_CDF2(11625) },
         } }
     };
 #else
@@ -572,6 +744,35 @@
                                { AOM_CDF2(8532) },
                                { AOM_CDF2(8532) },
                              };
+static const aom_cdf_prob
+    default_partition_noext_rec_cdf[PARTITION_CONTEXTS_REC]
+                                   [CDF_SIZE(PARTITION_TYPES)] = {
+                                     // 8x4, 4x8
+                                     { AOM_CDF2(30612) },
+                                     { AOM_CDF2(26074) },
+                                     { AOM_CDF2(28683) },
+                                     { AOM_CDF2(21191) },
+                                     // 16x8, 8x16
+                                     { AOM_CDF3(21708, 29163) },
+                                     { AOM_CDF3(13852, 27221) },
+                                     { AOM_CDF3(19187, 27661) },
+                                     { AOM_CDF3(9933, 21239) },
+                                     // 32x16, 16x32
+                                     { AOM_CDF3(14474, 25684) },
+                                     { AOM_CDF3(5925, 22613) },
+                                     { AOM_CDF3(12840, 23573) },
+                                     { AOM_CDF3(6088, 16570) },
+                                     // 64x32, 32x64
+                                     { AOM_CDF3(11157, 25388) },
+                                     { AOM_CDF3(3692, 24449) },
+                                     { AOM_CDF3(13455, 23113) },
+                                     { AOM_CDF3(13455, 23113) },
+                                     // 128x64, 64x128
+                                     { AOM_CDF2(9487) },
+                                     { AOM_CDF2(2668) },
+                                     { AOM_CDF2(8532) },
+                                     { AOM_CDF2(8532) },
+                                   };
 #else   // !ERP_LIMIT_PARTITION3_128
 static const aom_cdf_prob
     default_partition_rec_cdf[PARTITION_CONTEXTS_REC]
@@ -633,6 +834,34 @@
                                       { AOM_CDF3(9068, 21038) },   // Not used
                                       { AOM_CDF3(10923, 21845) },  // Not used
                                     };
+static const aom_cdf_prob
+    default_partition_middle_noext_rec_cdf[PARTITION_CONTEXTS_REC][CDF_SIZE(
+        LIMITED_PARTITION_TYPES)] = {
+      // 8x4, 4x8
+      { AOM_CDF2(30462) },  // Not used
+      { AOM_CDF2(25506) },  // Not used
+      { AOM_CDF2(27632) },  // Not used
+      { AOM_CDF2(19443) },  // Not used
+      // 16x8, 8x16
+      { AOM_CDF2(20645) }, { AOM_CDF2(13282) }, { AOM_CDF2(17766) },
+      {
+          AOM_CDF2(13067),
+          // 32x16, 16x32
+          { AOM_CDF2(14234) },
+          { AOM_CDF2(7421) },
+          { AOM_CDF2(8692) },
+          { AOM_CDF2(5458) },
+          // 64x32, 32x64
+          { AOM_CDF2(14706) },
+          { AOM_CDF2(6131) },
+          { AOM_CDF2(6588) },
+          { AOM_CDF2(8175) },
+          // 128x64, 64x128
+          { AOM_CDF2(15208) },  // Not used
+          { AOM_CDF2(6597) },   // Not used
+          { AOM_CDF2(9068) },   // Not used
+          { AOM_CDF2(10923) },  // Not used
+      };
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
 
 static const aom_cdf_prob default_intra_ext_tx_cdf
@@ -2211,8 +2440,14 @@
   av1_copy(fc->partition_cdf, default_partition_cdf);
 #if CONFIG_EXT_RECUR_PARTITIONS
   av1_copy(fc->limited_partition_cdf, default_limited_partition_cdf);
+  av1_copy(fc->partition_noext_cdf, default_partition_noext_cdf);
+  av1_copy(fc->limited_partition_noext_cdf,
+           default_limited_partition_noext_cdf);
   av1_copy(fc->partition_rec_cdf, default_partition_rec_cdf);
   av1_copy(fc->partition_middle_rec_cdf, default_partition_middle_rec_cdf);
+  av1_copy(fc->partition_noext_rec_cdf, default_partition_noext_rec_cdf);
+  av1_copy(fc->partition_middle_noext_rec_cdf,
+           default_partition_middle_noext_rec_cdf);
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   av1_copy(fc->intra_ext_tx_cdf, default_intra_ext_tx_cdf);
   av1_copy(fc->inter_ext_tx_cdf, default_inter_ext_tx_cdf);
diff --git a/av1/common/entropymode.h b/av1/common/entropymode.h
index bfa842b..c13bb85 100644
--- a/av1/common/entropymode.h
+++ b/av1/common/entropymode.h
@@ -234,12 +234,20 @@
                                     [NUM_LIMITED_PARTITION_PARENTS]
                                     [PARTITION_CONTEXTS]
                                     [CDF_SIZE(LIMITED_EXT_PARTITION_TYPES)];
-#endif  // CONFIG_EXT_RECUR_PARTITIONS
-#if CONFIG_EXT_RECUR_PARTITIONS
+  aom_cdf_prob partition_noext_cdf[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS]
+                                  [CDF_SIZE(PARTITION_TYPES)];
+  aom_cdf_prob limited_partition_noext_cdf[PARTITION_STRUCTURE_NUM]
+                                          [NUM_LIMITED_PARTITION_PARENTS]
+                                          [PARTITION_CONTEXTS]
+                                          [CDF_SIZE(LIMITED_PARTITION_TYPES)];
   aom_cdf_prob partition_rec_cdf[PARTITION_CONTEXTS_REC]
                                 [CDF_SIZE(PARTITION_TYPES_REC)];
   aom_cdf_prob partition_middle_rec_cdf[PARTITION_CONTEXTS_REC]
                                        [CDF_SIZE(PARTITION_TYPES_MIDDLE_REC)];
+  aom_cdf_prob partition_noext_rec_cdf[PARTITION_CONTEXTS_REC]
+                                      [CDF_SIZE(PARTITION_TYPES)];
+  aom_cdf_prob partition_middle_noext_rec_cdf[PARTITION_CONTEXTS_REC][CDF_SIZE(
+      LIMITED_PARTITION_TYPES)];
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   aom_cdf_prob switchable_interp_cdf[SWITCHABLE_FILTER_CONTEXTS]
                                     [CDF_SIZE(SWITCHABLE_FILTERS)];
diff --git a/av1/common/enums.h b/av1/common/enums.h
index 91a97c0..26d6433 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -270,6 +270,7 @@
   LIMITED_EXT_PARTITION_TYPES = EXT_PARTITION_TYPES - 1,
   PARTITION_SPLIT = EXT_PARTITION_TYPES,
   PARTITION_TYPES = PARTITION_VERT + 1,
+  LIMITED_PARTITION_TYPES = PARTITION_TYPES - 1,
   PARTITION_INVALID = 255
 } UENUM1BYTE(PARTITION_TYPE);
 #else   // CONFIG_EXT_RECUR_PARTITIONS
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 7ed7f64..9a3737a 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -1854,49 +1854,91 @@
   const bool limit_rect_split = is_middle_block &&
                                 is_bsize_geq(bsize, BLOCK_8X8) &&
                                 is_bsize_geq(BLOCK_64X64, bsize);
+  const int max_1dsize = AOMMAX(block_size_wide[bsize], block_size_high[bsize]);
+  const bool disable_ext_part =
+      (max_1dsize == 64 && cm->seq_params.disable_3way_part_64xn) ||
+      (max_1dsize == 32 && cm->seq_params.disable_3way_part_32xn) ||
+      (max_1dsize == 16 && cm->seq_params.disable_3way_part_16xn);
 
   if (is_square_block(bsize)) {
     assert(ctx >= 0);
-    aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[plane][ctx];
+    if (disable_ext_part) {
+      aom_cdf_prob *partition_cdf = ec_ctx->partition_noext_cdf[plane][ctx];
 
-    if (limit_rect_split) {
-      const int dir_index = parent_partition == PARTITION_HORZ_3 ? 0 : 1;
-      partition_cdf = ec_ctx->limited_partition_cdf[plane][dir_index][ctx];
-      const int symbol = aom_read_symbol(
-          r, partition_cdf, limited_partition_cdf_length(bsize), ACCT_STR);
-      return get_limited_partition_from_symbol(symbol, parent_partition);
+      if (limit_rect_split) {
+        const int dir_index = parent_partition == PARTITION_HORZ_3 ? 0 : 1;
+        partition_cdf =
+            ec_ctx->limited_partition_noext_cdf[plane][dir_index][ctx];
+        const int symbol = aom_read_symbol(r, partition_cdf,
+                                           LIMITED_PARTITION_TYPES, ACCT_STR);
+        return get_limited_partition_noext_from_symbol(symbol,
+                                                       parent_partition);
+      } else {
+        return (PARTITION_TYPE)aom_read_symbol(r, partition_cdf,
+                                               PARTITION_TYPES, ACCT_STR);
+      }
     } else {
-      return (PARTITION_TYPE)aom_read_symbol(
-          r, partition_cdf, partition_cdf_length(bsize), ACCT_STR);
+      aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[plane][ctx];
+
+      if (limit_rect_split) {
+        const int dir_index = parent_partition == PARTITION_HORZ_3 ? 0 : 1;
+        partition_cdf = ec_ctx->limited_partition_cdf[plane][dir_index][ctx];
+        const int symbol = aom_read_symbol(
+            r, partition_cdf, limited_partition_cdf_length(bsize), ACCT_STR);
+        return get_limited_partition_from_symbol(symbol, parent_partition);
+      } else {
+        return (PARTITION_TYPE)aom_read_symbol(
+            r, partition_cdf, partition_cdf_length(bsize), ACCT_STR);
+      }
     }
-  } else {  // Rectangular block.
-    if (limit_rect_split) {
-      // If we are the middle block of a 3-way partitioning, disable HORZ/VERT
-      // of the middle partition because it is redundant.
-      assert(IMPLIES(parent_partition == PARTITION_HORZ_3,
-                     block_size_wide[bsize] == 2 * block_size_high[bsize]));
-      assert(IMPLIES(parent_partition == PARTITION_VERT_3,
-                     2 * block_size_wide[bsize] == block_size_high[bsize]));
-      aom_cdf_prob *partition_middle_rec_cdf =
-          ec_ctx->partition_middle_rec_cdf[ctx];
+  } else {
+    if (disable_ext_part) {
+      if (limit_rect_split) {
+        aom_cdf_prob *partition_cdf =
+            ec_ctx->partition_middle_noext_rec_cdf[ctx];
+        const int cdf_length = partition_middle_noext_rec_cdf_length(bsize);
+        const int symbol =
+            aom_read_symbol(r, partition_cdf, cdf_length, ACCT_STR);
+
+        return get_limited_partition_noext_from_symbol(symbol,
+                                                       parent_partition);
+      } else {
+        aom_cdf_prob *partition_cdf = ec_ctx->partition_noext_rec_cdf[ctx];
+        const int cdf_length = partition_noext_rec_cdf_length(bsize);
+        const int symbol =
+            aom_read_symbol(r, partition_cdf, cdf_length, ACCT_STR);
+
+        return get_partition_noext_from_symbol_rec_block(bsize, symbol);
+      }
+    } else {
+      if (limit_rect_split) {
+        // If we are the middle block of a 3-way partitioning, disable HORZ/VERT
+        // of the middle partition because it is redundant.
+        assert(IMPLIES(parent_partition == PARTITION_HORZ_3,
+                       block_size_wide[bsize] == 2 * block_size_high[bsize]));
+        assert(IMPLIES(parent_partition == PARTITION_VERT_3,
+                       2 * block_size_wide[bsize] == block_size_high[bsize]));
+        aom_cdf_prob *partition_middle_rec_cdf =
+            ec_ctx->partition_middle_rec_cdf[ctx];
+        const PARTITION_TYPE_REC symbol = (PARTITION_TYPE_REC)aom_read_symbol(
+            r, partition_middle_rec_cdf, partition_middle_rec_cdf_length(bsize),
+            ACCT_STR);
+
+        const PARTITION_TYPE partition =
+            get_partition_from_symbol_rec_block(bsize, symbol);
+        assert(IMPLIES(parent_partition == PARTITION_HORZ_3,
+                       partition != PARTITION_HORZ));
+        assert(IMPLIES(parent_partition == PARTITION_VERT_3,
+                       partition != PARTITION_VERT));
+
+        return partition;
+      }
+      aom_cdf_prob *partition_rec_cdf = ec_ctx->partition_rec_cdf[ctx];
       const PARTITION_TYPE_REC symbol = (PARTITION_TYPE_REC)aom_read_symbol(
-          r, partition_middle_rec_cdf, partition_middle_rec_cdf_length(bsize),
-          ACCT_STR);
+          r, partition_rec_cdf, partition_rec_cdf_length(bsize), ACCT_STR);
 
-      const PARTITION_TYPE partition =
-          get_partition_from_symbol_rec_block(bsize, symbol);
-      assert(IMPLIES(parent_partition == PARTITION_HORZ_3,
-                     partition != PARTITION_HORZ));
-      assert(IMPLIES(parent_partition == PARTITION_VERT_3,
-                     partition != PARTITION_VERT));
-
-      return partition;
+      return get_partition_from_symbol_rec_block(bsize, symbol);
     }
-    aom_cdf_prob *partition_rec_cdf = ec_ctx->partition_rec_cdf[ctx];
-    const PARTITION_TYPE_REC symbol = (PARTITION_TYPE_REC)aom_read_symbol(
-        r, partition_rec_cdf, partition_rec_cdf_length(bsize), ACCT_STR);
-
-    return get_partition_from_symbol_rec_block(bsize, symbol);
   }
 #else   // !CONFIG_EXT_RECUR_PARTITIONS
   if (!has_rows && !has_cols) return PARTITION_SPLIT;
@@ -5374,6 +5416,11 @@
 #if CONFIG_NEW_TX_PARTITION
   seq_params->enable_tx_split_4way = aom_rb_read_bit(rb);
 #endif  // CONFIG_NEW_TX_PARTITION
+#if CONFIG_EXT_RECUR_PARTITIONS
+  seq_params->disable_3way_part_64xn = aom_rb_read_bit(rb);
+  seq_params->disable_3way_part_32xn = aom_rb_read_bit(rb);
+  seq_params->disable_3way_part_16xn = aom_rb_read_bit(rb);
+#endif  // CONFIG_EXT_RECUR_PARTITIONS
 }
 
 static int read_global_motion_params(WarpedMotionParams *params,
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 7720d84..f117953 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -2321,36 +2321,84 @@
   const bool limit_rect_split = is_middle_block &&
                                 is_bsize_geq(bsize, BLOCK_8X8) &&
                                 is_bsize_geq(BLOCK_64X64, bsize);
+  const int max_1dsize = AOMMAX(block_size_wide[bsize], block_size_high[bsize]);
+  const bool disable_ext_part =
+      (max_1dsize == 64 && cm->seq_params.disable_3way_part_64xn) ||
+      (max_1dsize == 32 && cm->seq_params.disable_3way_part_32xn) ||
+      (max_1dsize == 16 && cm->seq_params.disable_3way_part_16xn);
   if (is_square_block(bsize)) {
-    aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[plane][ctx];
-    if (limit_rect_split) {
-      const int dir_index = parent_partition == PARTITION_HORZ_3 ? 0 : 1;
-      partition_cdf = ec_ctx->limited_partition_cdf[plane][dir_index][ctx];
-      const int symbol = get_symbol_from_limited_partition(p, parent_partition);
-      aom_write_symbol(w, symbol, partition_cdf,
-                       limited_partition_cdf_length(bsize));
+#endif  // CONFIG_EXT_RECUR_PARTITIONS
+
+#if CONFIG_EXT_RECUR_PARTITIONS
+    if (disable_ext_part) {
+      aom_cdf_prob *partition_cdf;
+      int symbol, cdf_length;
+      if (limit_rect_split) {
+        const int dir_index = parent_partition == PARTITION_HORZ_3 ? 0 : 1;
+        partition_cdf =
+            ec_ctx->limited_partition_noext_cdf[plane][dir_index][ctx];
+        symbol = get_symbol_from_limited_partition_noext(p, parent_partition);
+        cdf_length = LIMITED_PARTITION_TYPES;
+      } else {
+        partition_cdf = ec_ctx->partition_noext_cdf[plane][ctx];
+        symbol = p;
+        cdf_length = PARTITION_TYPES;
+      }
+      aom_write_symbol(w, symbol, partition_cdf, cdf_length);
     } else {
-      aom_write_symbol(w, p, partition_cdf, partition_cdf_length(bsize));
+      aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[plane][ctx];
+      if (limit_rect_split) {
+        const int dir_index = parent_partition == PARTITION_HORZ_3 ? 0 : 1;
+        partition_cdf = ec_ctx->limited_partition_cdf[plane][dir_index][ctx];
+        const int symbol =
+            get_symbol_from_limited_partition(p, parent_partition);
+        aom_write_symbol(w, symbol, partition_cdf,
+                         limited_partition_cdf_length(bsize));
+      } else {
+        aom_write_symbol(w, p, partition_cdf, partition_cdf_length(bsize));
+      }
     }
   } else {  // 1:2 or 2:1 rectangular blocks
-    if (limit_rect_split) {
-      assert(IMPLIES(parent_partition == PARTITION_HORZ_3,
-                     block_size_wide[bsize] == 2 * block_size_high[bsize]));
-      assert(IMPLIES(parent_partition == PARTITION_VERT_3,
-                     2 * block_size_wide[bsize] == block_size_high[bsize]));
-      assert(
-          IMPLIES(parent_partition == PARTITION_HORZ_3, p != PARTITION_HORZ));
-      assert(
-          IMPLIES(parent_partition == PARTITION_VERT_3, p != PARTITION_VERT));
-      const PARTITION_TYPE_REC symbol =
-          get_symbol_from_partition_rec_block(bsize, p);
-      aom_write_symbol(w, symbol, ec_ctx->partition_middle_rec_cdf[ctx],
-                       partition_middle_rec_cdf_length(bsize));
+    if (disable_ext_part) {
+      if (limit_rect_split) {
+        assert(IMPLIES(parent_partition == PARTITION_HORZ_3,
+                       block_size_wide[bsize] == 2 * block_size_high[bsize]));
+        assert(IMPLIES(parent_partition == PARTITION_VERT_3,
+                       2 * block_size_wide[bsize] == block_size_high[bsize]));
+        assert(
+            IMPLIES(parent_partition == PARTITION_HORZ_3, p != PARTITION_HORZ));
+        assert(
+            IMPLIES(parent_partition == PARTITION_VERT_3, p != PARTITION_VERT));
+        const PARTITION_TYPE_REC symbol =
+            get_symbol_from_limited_partition_noext(bsize, p);
+        aom_write_symbol(w, symbol, ec_ctx->partition_middle_noext_rec_cdf[ctx],
+                         partition_middle_noext_rec_cdf_length(bsize));
+      } else {
+        const PARTITION_TYPE_REC symbol =
+            get_symbol_from_partition_noext_rec_block(bsize, p);
+        aom_write_symbol(w, symbol, ec_ctx->partition_noext_rec_cdf[ctx],
+                         partition_noext_rec_cdf_length(bsize));
+      }
     } else {
-      const PARTITION_TYPE_REC symbol =
-          get_symbol_from_partition_rec_block(bsize, p);
-      aom_write_symbol(w, symbol, ec_ctx->partition_rec_cdf[ctx],
-                       partition_rec_cdf_length(bsize));
+      if (limit_rect_split) {
+        assert(IMPLIES(parent_partition == PARTITION_HORZ_3,
+                       block_size_wide[bsize] == 2 * block_size_high[bsize]));
+        assert(IMPLIES(parent_partition == PARTITION_VERT_3,
+                       2 * block_size_wide[bsize] == block_size_high[bsize]));
+        assert(
+            IMPLIES(parent_partition == PARTITION_HORZ_3, p != PARTITION_HORZ));
+        assert(
+            IMPLIES(parent_partition == PARTITION_VERT_3, p != PARTITION_VERT));
+        const PARTITION_TYPE_REC symbol =
+            get_symbol_from_partition_rec_block(bsize, p);
+        aom_write_symbol(w, symbol, ec_ctx->partition_middle_rec_cdf[ctx],
+                         partition_middle_rec_cdf_length(bsize));
+      } else {
+        const PARTITION_TYPE_REC symbol =
+            get_symbol_from_partition_rec_block(bsize, p);
+        aom_write_symbol(w, symbol, ec_ctx->partition_rec_cdf[ctx],
+                         partition_rec_cdf_length(bsize));
+      }
     }
   }
 #else   // CONFIG_EXT_RECUR_PARTITIONS
@@ -3785,6 +3833,11 @@
 #if CONFIG_NEW_TX_PARTITION
   aom_wb_write_bit(wb, seq_params->enable_tx_split_4way);
 #endif  // CONFIG_NEW_TX_PARTITION
+#if CONFIG_EXT_RECUR_PARTITIONS
+  aom_wb_write_bit(wb, seq_params->disable_3way_part_64xn);
+  aom_wb_write_bit(wb, seq_params->disable_3way_part_32xn);
+  aom_wb_write_bit(wb, seq_params->disable_3way_part_16xn);
+#endif  // CONFIG_EXT_RECUR_PARTITIONS
 }
 
 static AOM_INLINE void write_global_motion_params(
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 335aa95..01c3a7b 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -707,17 +707,29 @@
   int partition_cost[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS]
                     [EXT_PARTITION_TYPES];
 #if CONFIG_EXT_RECUR_PARTITIONS
+  //! Cost for coding the partition when ext partitions are disabled
+  int partition_noext_cost[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS]
+                          [PARTITION_TYPES];
   //! Cost for coding the limited partition.
   int limited_partition_cost[PARTITION_STRUCTURE_NUM]
                             [NUM_LIMITED_PARTITION_PARENTS][PARTITION_CONTEXTS]
                             [EXT_PARTITION_TYPES];
-#endif  // CONFIG_EXT_RECUR_PARTITIONS
-#if CONFIG_EXT_RECUR_PARTITIONS
+  //! Cost for coding the limited partition when ext partitions are disabled
+  int limited_partition_noext_cost[PARTITION_STRUCTURE_NUM]
+                                  [NUM_LIMITED_PARTITION_PARENTS]
+                                  [PARTITION_CONTEXTS][LIMITED_PARTITION_TYPES];
   /*! Cost for coding the partition for rectangular blocks. */
   int partition_rec_cost[PARTITION_CONTEXTS_REC][PARTITION_TYPES_REC];
   /*! Cost for coding the partition for rectangular blocks in the middle of
    * 3-way partitions. */
   int partition_middle_rec_cost[PARTITION_CONTEXTS_REC][PARTITION_TYPES_REC];
+  /*! Cost for coding the partition for rectangular blocks when ext partitions
+   * are disabled. */
+  int partition_noext_rec_cost[PARTITION_CONTEXTS_REC][PARTITION_TYPES];
+  /*! Cost for coding the partition for rectangular blocks in the middle of
+   * 3-way partitions when ext partitions are disabled. */
+  int partition_middle_noext_rec_cost[PARTITION_CONTEXTS_REC]
+                                     [LIMITED_PARTITION_TYPES];
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   /**@}*/
 
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index feb3ae2..5bb528d 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -457,6 +457,11 @@
   }
   seq->enable_tip_hole_fill = seq->enable_tip;
 #endif  // CONFIG_TIP
+#if CONFIG_EXT_RECUR_PARTITIONS
+  seq->disable_3way_part_64xn = oxcf->part_cfg.disable_3way_part_64xn;
+  seq->disable_3way_part_32xn = oxcf->part_cfg.disable_3way_part_32xn;
+  seq->disable_3way_part_16xn = oxcf->part_cfg.disable_3way_part_16xn;
+#endif  // CONFIG_EXT_RECUR_PARTITIONS
   seq->enable_warped_motion = oxcf->motion_mode_cfg.enable_warped_motion;
   seq->enable_interintra_compound = tool_cfg->enable_interintra_comp;
   seq->enable_masked_compound = oxcf->comp_type_cfg.enable_masked_comp;
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index c530d8c..a977371 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -215,6 +215,18 @@
    * Flag to indicate the use of ml model for erp pruning.
    * */
   int use_ml_erp_pruning;
+  /*!
+   * Flag to indicate if ternary partitions are disabled in 64xN/Nx64(N<=64).
+   * */
+  unsigned int disable_3way_part_64xn;
+  /*!
+   * Flag to indicate if ternary partitions are disabled in 32xN/Nx32(N<=32).
+   * */
+  unsigned int disable_3way_part_32xn;
+  /*!
+   * Flag to indicate if ternary partitions are disabled in 16xN/Nx16(N<=16).
+   * */
+  unsigned int disable_3way_part_16xn;
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   /*!
    * Flag to indicate if rectanguar partitions should be enabled.
diff --git a/av1/encoder/partition_search.c b/av1/encoder/partition_search.c
index 99b01ca..9dd0bac 100644
--- a/av1/encoder/partition_search.c
+++ b/av1/encoder/partition_search.c
@@ -1626,6 +1626,7 @@
                                    int allow_update_cdf,
                                    const CommonModeInfoParams *const mi_params,
 #if CONFIG_EXT_RECUR_PARTITIONS
+                                   int disable_ext_part,
                                    PARTITION_TREE const *ptree,
                                    PARTITION_TREE const *ptree_luma,
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
@@ -1668,47 +1669,84 @@
                                 is_bsize_geq(bsize, BLOCK_8X8) &&
                                 is_bsize_geq(BLOCK_64X64, bsize);
   if (is_square_block(bsize)) {
-    if (limit_rect_split) {
-      const int dir_idx = (parent_partition == PARTITION_HORZ_3) ? 0 : 1;
-      const int symbol =
-          get_symbol_from_limited_partition(partition, parent_partition);
+    if (disable_ext_part) {
+      if (limit_rect_split) {
+        const int dir_idx = (parent_partition == PARTITION_HORZ_3) ? 0 : 1;
+        const int symbol = get_symbol_from_limited_partition_noext(
+            partition, parent_partition);
 
-#if CONFIG_ENTROPY_STATS
-      counts->limited_partition[plane_index][dir_idx][ctx][symbol]++;
-#endif  // CONFIG_ENTROPY_STATS
-      if (allow_update_cdf) {
-        update_cdf(fc->limited_partition_cdf[plane_index][dir_idx][ctx], symbol,
-                   limited_partition_cdf_length(bsize));
+        if (allow_update_cdf) {
+          update_cdf(fc->limited_partition_noext_cdf[plane_index][dir_idx][ctx],
+                     symbol, LIMITED_PARTITION_TYPES);
+        }
+      } else {
+        if (allow_update_cdf) {
+          update_cdf(fc->partition_noext_cdf[plane_index][ctx], partition,
+                     PARTITION_TYPES);
+        }
       }
     } else {
+      if (limit_rect_split) {
+        const int dir_idx = (parent_partition == PARTITION_HORZ_3) ? 0 : 1;
+        const int symbol =
+            get_symbol_from_limited_partition(partition, parent_partition);
+
 #if CONFIG_ENTROPY_STATS
-      counts->partition[plane_index][ctx][partition]++;
+        counts->limited_partition[plane_index][dir_idx][ctx][symbol]++;
 #endif  // CONFIG_ENTROPY_STATS
-      if (allow_update_cdf) {
-        update_cdf(fc->partition_cdf[plane_index][ctx], partition,
-                   partition_cdf_length(bsize));
+        if (allow_update_cdf) {
+          update_cdf(fc->limited_partition_cdf[plane_index][dir_idx][ctx],
+                     symbol, limited_partition_cdf_length(bsize));
+        }
+      } else {
+#if CONFIG_ENTROPY_STATS
+        counts->partition[plane_index][ctx][partition]++;
+#endif  // CONFIG_ENTROPY_STATS
+        if (allow_update_cdf) {
+          update_cdf(fc->partition_cdf[plane_index][ctx], partition,
+                     partition_cdf_length(bsize));
+        }
       }
     }
   } else {  // Rectangular blocks
-    const PARTITION_TYPE_REC p_rec =
-        get_symbol_from_partition_rec_block(bsize, partition);
-    if (limit_rect_split) {
-#if CONFIG_ENTROPY_STATS
-      counts->partition_middle_rec[ctx][p_rec]++;
-#endif  // CONFIG_ENTROPY_STATS
-
-      if (allow_update_cdf) {
-        update_cdf(fc->partition_middle_rec_cdf[ctx], p_rec,
-                   partition_middle_rec_cdf_length(bsize));
+    if (disable_ext_part) {
+      if (limit_rect_split) {
+        const PARTITION_TYPE_REC p_rec =
+            get_symbol_from_limited_partition_noext(partition,
+                                                    parent_partition);
+        if (allow_update_cdf) {
+          update_cdf(fc->partition_middle_noext_rec_cdf[ctx], p_rec,
+                     partition_middle_noext_rec_cdf_length(bsize));
+        }
+      } else {
+        const PARTITION_TYPE_REC p_rec =
+            get_symbol_from_partition_noext_rec_block(bsize, partition);
+        if (allow_update_cdf) {
+          update_cdf(fc->partition_noext_rec_cdf[ctx], p_rec,
+                     partition_noext_rec_cdf_length(bsize));
+        }
       }
     } else {
+      const PARTITION_TYPE_REC p_rec =
+          get_symbol_from_partition_rec_block(bsize, partition);
+      if (limit_rect_split) {
 #if CONFIG_ENTROPY_STATS
-      counts->partition_rec[ctx][p_rec]++;
+        counts->partition_middle_rec[ctx][p_rec]++;
 #endif  // CONFIG_ENTROPY_STATS
 
-      if (allow_update_cdf) {
-        update_cdf(fc->partition_rec_cdf[ctx], p_rec,
-                   partition_rec_cdf_length(bsize));
+        if (allow_update_cdf) {
+          update_cdf(fc->partition_middle_rec_cdf[ctx], p_rec,
+                     partition_middle_rec_cdf_length(bsize));
+        }
+      } else {
+#if CONFIG_ENTROPY_STATS
+        counts->partition_rec[ctx][p_rec]++;
+#endif  // CONFIG_ENTROPY_STATS
+
+        if (allow_update_cdf) {
+          update_cdf(fc->partition_rec_cdf[ctx], p_rec,
+                     partition_rec_cdf_length(bsize));
+        }
       }
     }
   }
@@ -1830,9 +1868,15 @@
                       : -1;
   const PARTITION_TYPE partition = pc_tree->partitioning;
   const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
-#if !CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXT_RECUR_PARTITIONS
+  const int max_1dsize = AOMMAX(block_size_wide[bsize], block_size_high[bsize]);
+  const bool disable_ext_part =
+      (max_1dsize == 64 && cm->seq_params.disable_3way_part_64xn) ||
+      (max_1dsize == 32 && cm->seq_params.disable_3way_part_32xn) ||
+      (max_1dsize == 16 && cm->seq_params.disable_3way_part_16xn);
+#else
   const BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
-#endif  // !CONFIG_EXT_RECUR_PARTITIONS
+#endif  // CONFIG_EXT_RECUR_PARTITIONS
 
   if (subsize == BLOCK_INVALID) return;
 #if CONFIG_EXT_RECUR_PARTITIONS
@@ -1846,7 +1890,7 @@
 #endif  // CONFIG_ENTROPY_STATS
                            tile_data->allow_update_cdf, mi_params,
 #if CONFIG_EXT_RECUR_PARTITIONS
-                           ptree, ptree_luma,
+                           disable_ext_part, ptree, ptree_luma,
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
                            partition, mi_row, mi_col, bsize, ctx);
 
@@ -2735,47 +2779,101 @@
   const bool limit_rect_split = is_middle_block &&
                                 is_bsize_geq(bsize, BLOCK_8X8) &&
                                 is_bsize_geq(BLOCK_64X64, bsize);
+  const int max_1dsize = AOMMAX(block_size_wide[bsize], block_size_high[bsize]);
+  const bool disable_ext_part =
+      (max_1dsize == 64 && cm->seq_params.disable_3way_part_64xn) ||
+      (max_1dsize == 32 && cm->seq_params.disable_3way_part_32xn) ||
+      (max_1dsize == 16 && cm->seq_params.disable_3way_part_16xn);
   const int pl = part_search_state->pl_ctx_idx;
   const int plane_index = xd->tree_type == CHROMA_PART;
   if (is_square_block(bsize)) {
-    if (limit_rect_split) {
-      const PARTITION_TYPE parent_part =
-          (pc_tree->parent->horizontal3[1] == pc_tree) ? PARTITION_HORZ_3
-                                                       : PARTITION_VERT_3;
-      const int dir = (parent_part == PARTITION_HORZ_3) ? 0 : 1;
-      for (PARTITION_TYPE p = PARTITION_NONE; p < EXT_PARTITION_TYPES; ++p) {
-        const int symbol = get_symbol_from_limited_partition(p, parent_part);
-        if (symbol == PARTITION_INVALID_REC) {
-          part_search_state->partition_cost_table[p] = INT_MAX;
-        } else {
-          part_search_state->partition_cost_table[p] =
-              mode_costs->limited_partition_cost[plane_index][dir][pl][symbol];
+    if (disable_ext_part) {
+      if (limit_rect_split) {
+        const PARTITION_TYPE parent_part =
+            (pc_tree->parent->horizontal3[1] == pc_tree) ? PARTITION_HORZ_3
+                                                         : PARTITION_VERT_3;
+        const int dir = (parent_part == PARTITION_HORZ_3) ? 0 : 1;
+        for (PARTITION_TYPE p = PARTITION_NONE; p < EXT_PARTITION_TYPES; ++p) {
+          const int symbol =
+              get_symbol_from_limited_partition_noext(p, parent_part);
+          if (symbol == PARTITION_INVALID_REC) {
+            part_search_state->partition_cost_table[p] = INT_MAX;
+          } else {
+            part_search_state->partition_cost_table[p] =
+                mode_costs->limited_partition_noext_cost[plane_index][dir][pl]
+                                                        [symbol];
+          }
+          part_search_state->partition_cost =
+              part_search_state->partition_cost_table;
         }
+      } else {
         part_search_state->partition_cost =
-            part_search_state->partition_cost_table;
+            mode_costs->partition_noext_cost[plane_index][pl];
       }
     } else {
-      part_search_state->partition_cost =
-          mode_costs->partition_cost[plane_index][pl];
+      if (limit_rect_split) {
+        const PARTITION_TYPE parent_part =
+            (pc_tree->parent->horizontal3[1] == pc_tree) ? PARTITION_HORZ_3
+                                                         : PARTITION_VERT_3;
+        const int dir = (parent_part == PARTITION_HORZ_3) ? 0 : 1;
+        for (PARTITION_TYPE p = PARTITION_NONE; p < EXT_PARTITION_TYPES; ++p) {
+          const int symbol = get_symbol_from_limited_partition(p, parent_part);
+          if (symbol == PARTITION_INVALID_REC) {
+            part_search_state->partition_cost_table[p] = INT_MAX;
+          } else {
+            part_search_state->partition_cost_table[p] =
+                mode_costs
+                    ->limited_partition_cost[plane_index][dir][pl][symbol];
+          }
+          part_search_state->partition_cost =
+              part_search_state->partition_cost_table;
+        }
+      } else {
+        part_search_state->partition_cost =
+            mode_costs->partition_cost[plane_index][pl];
+      }
     }
   } else {
     for (PARTITION_TYPE p = PARTITION_NONE; p < EXT_PARTITION_TYPES; ++p) {
-      PARTITION_TYPE_REC p_rec = get_symbol_from_partition_rec_block(bsize, p);
-      if (limit_rect_split) {
-        if ((pc_tree->parent->horizontal3[1] == pc_tree &&
-             p == PARTITION_HORZ) ||
-            (pc_tree->parent->vertical3[1] == pc_tree && p == PARTITION_VERT)) {
-          p_rec = PARTITION_INVALID_REC;
+      PARTITION_TYPE_REC p_rec = PARTITION_INVALID_REC;
+      if (disable_ext_part) {
+        if (limit_rect_split) {
+          const PARTITION_TYPE parent_part =
+              (pc_tree->parent->horizontal3[1] == pc_tree) ? PARTITION_HORZ_3
+                                                           : PARTITION_VERT_3;
+          p_rec = get_symbol_from_limited_partition_noext(p, parent_part);
+        } else {
+          p_rec = get_symbol_from_partition_noext_rec_block(bsize, p);
+        }
+      } else {
+        p_rec = get_symbol_from_partition_rec_block(bsize, p);
+        if (limit_rect_split) {
+          if ((pc_tree->parent->horizontal3[1] == pc_tree &&
+               p == PARTITION_HORZ) ||
+              (pc_tree->parent->vertical3[1] == pc_tree &&
+               p == PARTITION_VERT)) {
+            p_rec = PARTITION_INVALID_REC;
+          }
         }
       }
 
       if (p_rec != PARTITION_INVALID_REC) {
-        if (limit_rect_split) {
-          part_search_state->partition_cost_table[p] =
-              mode_costs->partition_middle_rec_cost[pl][p_rec];
+        if (disable_ext_part) {
+          if (limit_rect_split) {
+            part_search_state->partition_cost_table[p] =
+                mode_costs->partition_middle_noext_rec_cost[pl][p_rec];
+          } else {
+            part_search_state->partition_cost_table[p] =
+                mode_costs->partition_noext_rec_cost[pl][p_rec];
+          }
         } else {
-          part_search_state->partition_cost_table[p] =
-              mode_costs->partition_rec_cost[pl][p_rec];
+          if (limit_rect_split) {
+            part_search_state->partition_cost_table[p] =
+                mode_costs->partition_middle_rec_cost[pl][p_rec];
+          } else {
+            part_search_state->partition_cost_table[p] =
+                mode_costs->partition_rec_cost[pl][p_rec];
+          }
         }
       } else {
         part_search_state->partition_cost_table[p] = INT_MAX;
@@ -5074,9 +5172,13 @@
 #if CONFIG_EXT_RECUR_PARTITIONS
   const int ext_partition_allowed = !is_partition_implied_at_boundary(
       &cm->mi_params, mi_row, mi_col, bsize, NULL);
-  const int partition_3_allowed = ext_partition_allowed &&
-                                  bsize != BLOCK_128X128 &&
-                                  max_recursion_depth > 0;
+  const int max_1dsize = AOMMAX(block_size_wide[bsize], block_size_high[bsize]);
+  const int partition_3_allowed =
+      ext_partition_allowed && bsize != BLOCK_128X128 &&
+      max_recursion_depth > 0 &&
+      IMPLIES(max_1dsize == 64, !cpi->oxcf.part_cfg.disable_3way_part_64xn) &&
+      IMPLIES(max_1dsize == 32, !cpi->oxcf.part_cfg.disable_3way_part_32xn) &&
+      IMPLIES(max_1dsize == 16, !cpi->oxcf.part_cfg.disable_3way_part_16xn);
   const int is_wide_block = block_size_wide[bsize] > block_size_high[bsize];
   const int is_tall_block = block_size_wide[bsize] < block_size_high[bsize];
   const PARTITION_SPEED_FEATURES *part_sf = &cpi->sf.part_sf;
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 0e58a9f..e4407a8 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -100,12 +100,23 @@
     }
 #if CONFIG_EXT_RECUR_PARTITIONS
     for (i = 0; i < PARTITION_CONTEXTS; ++i) {
+      av1_cost_tokens_from_cdf(mode_costs->partition_noext_cost[plane_index][i],
+                               fc->partition_noext_cdf[plane_index][i], NULL);
+    }
+    for (i = 0; i < PARTITION_CONTEXTS; ++i) {
       for (int dir = 0; dir < NUM_LIMITED_PARTITION_PARENTS; dir++) {
         av1_cost_tokens_from_cdf(
             mode_costs->limited_partition_cost[plane_index][dir][i],
             fc->limited_partition_cdf[plane_index][dir][i], NULL);
       }
     }
+    for (i = 0; i < PARTITION_CONTEXTS; ++i) {
+      for (int dir = 0; dir < NUM_LIMITED_PARTITION_PARENTS; dir++) {
+        av1_cost_tokens_from_cdf(
+            mode_costs->limited_partition_noext_cost[plane_index][dir][i],
+            fc->limited_partition_noext_cdf[plane_index][dir][i], NULL);
+      }
+    }
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   }
 
@@ -115,6 +126,10 @@
                              fc->partition_rec_cdf[i], NULL);
     av1_cost_tokens_from_cdf(mode_costs->partition_middle_rec_cost[i],
                              fc->partition_middle_rec_cdf[i], NULL);
+    av1_cost_tokens_from_cdf(mode_costs->partition_noext_rec_cost[i],
+                             fc->partition_noext_rec_cdf[i], NULL);
+    av1_cost_tokens_from_cdf(mode_costs->partition_middle_noext_rec_cost[i],
+                             fc->partition_middle_noext_rec_cdf[i], NULL);
   }
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
 
diff --git a/common/args.c b/common/args.c
index 65d13c7..abe43db 100644
--- a/common/args.c
+++ b/common/args.c
@@ -86,6 +86,9 @@
 #if CONFIG_EXT_RECUR_PARTITIONS
     GET_PARAMS(erp_pruning_level);
     GET_PARAMS(use_ml_erp_pruning);
+    GET_PARAMS(disable_3way_part_64xn);
+    GET_PARAMS(disable_3way_part_32xn);
+    GET_PARAMS(disable_3way_part_16xn);
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
     GET_PARAMS(enable_sdp);
     GET_PARAMS(enable_mrls);