diff --git a/av1/common/cfl.c b/av1/common/cfl.c
index ccc59b4..99410be 100644
--- a/av1/common/cfl.c
+++ b/av1/common/cfl.c
@@ -158,16 +158,6 @@
   }
 }
 
-// Null function used for invalid tx_sizes
-void cfl_predict_lbd_null(const int16_t *ac_buf_q3, uint8_t *dst,
-                          int dst_stride, int alpha_q3) {
-  (void)ac_buf_q3;
-  (void)dst;
-  (void)dst_stride;
-  (void)alpha_q3;
-  assert(0);
-}
-
 CFL_PREDICT_FN(c, lbd)
 
 void cfl_predict_hbd_c(const int16_t *ac_buf_q3, uint16_t *dst, int dst_stride,
@@ -182,17 +172,6 @@
   }
 }
 
-// Null function used for invalid tx_sizes
-void cfl_predict_hbd_null(const int16_t *ac_buf_q3, uint16_t *dst,
-                          int dst_stride, int alpha_q3, int bd) {
-  (void)ac_buf_q3;
-  (void)dst;
-  (void)dst_stride;
-  (void)alpha_q3;
-  (void)bd;
-  assert(0);
-}
-
 CFL_PREDICT_FN(c, hbd)
 
 static void cfl_compute_parameters(MACROBLOCKD *const xd, TX_SIZE tx_size) {
@@ -226,24 +205,6 @@
   get_predict_lbd_fn(tx_size)(cfl->ac_buf_q3, dst, dst_stride, alpha_q3);
 }
 
-// Null function used for invalid tx_sizes
-void cfl_subsample_lbd_null(const uint8_t *input, int input_stride,
-                            uint16_t *output_q3) {
-  (void)input;
-  (void)input_stride;
-  (void)output_q3;
-  assert(0);
-}
-
-// Null function used for invalid tx_sizes
-void cfl_subsample_hbd_null(const uint16_t *input, int input_stride,
-                            uint16_t *output_q3) {
-  (void)input;
-  (void)input_stride;
-  (void)output_q3;
-  assert(0);
-}
-
 static void cfl_luma_subsampling_420_lbd_c(const uint8_t *input,
                                            int input_stride,
                                            uint16_t *output_q3, int width,
diff --git a/av1/common/cfl.h b/av1/common/cfl.h
index d627891..3b91d85 100644
--- a/av1/common/cfl.h
+++ b/av1/common/cfl.h
@@ -80,14 +80,6 @@
 void cfl_load_dc_pred(MACROBLOCKD *const xd, uint8_t *dst, int dst_stride,
                       TX_SIZE tx_size, CFL_PRED_TYPE pred_plane);
 
-// Null function used for invalid tx_sizes
-void cfl_subsample_lbd_null(const uint8_t *input, int input_stride,
-                            uint16_t *output_q3);
-
-// Null function used for invalid tx_sizes
-void cfl_subsample_hbd_null(const uint16_t *input, int input_stride,
-                            uint16_t *output_q3);
-
 // Allows the CFL_SUBSAMPLE function to switch types depending on the bitdepth.
 #define CFL_lbd_TYPE uint8_t *cfl_type
 #define CFL_hbd_TYPE uint16_t *cfl_type
@@ -133,21 +125,21 @@
     subsample_##bd##_##sub##_8x8_##arch,   /* 8x8 */                      \
     subsample_##bd##_##sub##_16x16_##arch, /* 16x16 */                    \
     subsample_##bd##_##sub##_32x32_##arch, /* 32x32 */                    \
-    cfl_subsample_##bd##_null,             /* 64x64 (invalid CFL size) */ \
+    NULL,                                  /* 64x64 (invalid CFL size) */ \
     subsample_##bd##_##sub##_4x8_##arch,   /* 4x8 */                      \
     subsample_##bd##_##sub##_8x4_##arch,   /* 8x4 */                      \
     subsample_##bd##_##sub##_8x16_##arch,  /* 8x16 */                     \
     subsample_##bd##_##sub##_16x8_##arch,  /* 16x8 */                     \
     subsample_##bd##_##sub##_16x32_##arch, /* 16x32 */                    \
     subsample_##bd##_##sub##_32x16_##arch, /* 32x16 */                    \
-    cfl_subsample_##bd##_null,             /* 32x64 (invalid CFL size) */ \
-    cfl_subsample_##bd##_null,             /* 64x32 (invalid CFL size) */ \
+    NULL,                                  /* 32x64 (invalid CFL size) */ \
+    NULL,                                  /* 64x32 (invalid CFL size) */ \
     subsample_##bd##_##sub##_4x16_##arch,  /* 4x16  */                    \
     subsample_##bd##_##sub##_16x4_##arch,  /* 16x4  */                    \
     subsample_##bd##_##sub##_8x32_##arch,  /* 8x32  */                    \
     subsample_##bd##_##sub##_32x8_##arch,  /* 32x8  */                    \
-    cfl_subsample_##bd##_null,             /* 16x64 (invalid CFL size) */ \
-    cfl_subsample_##bd##_null,             /* 64x16 (invalid CFL size) */ \
+    NULL,                                  /* 16x64 (invalid CFL size) */ \
+    NULL,                                  /* 64x16 (invalid CFL size) */ \
   };
 
 // The RTCD script does not support passing in an array, so we wrap it in this
@@ -160,14 +152,6 @@
   CFL_SUBSAMPLE_FUNCTIONS(arch, 422, hbd) \
   CFL_SUBSAMPLE_FUNCTIONS(arch, 444, hbd)
 
-// Null function used for invalid tx_sizes
-static INLINE void cfl_subtract_average_null(const uint16_t *src,
-                                             int16_t *dst) {
-  (void)dst;
-  (void)src;
-  assert(0);
-}
-
 // Declare a size-specific wrapper for the size-generic function. The compiler
 // will inline the size generic function in here, the advantage is that the size
 // will be constant allowing for loop unrolling and other constant propagated
@@ -201,21 +185,21 @@
       subtract_average_8x8_##arch,   /* 8x8 */                              \
       subtract_average_16x16_##arch, /* 16x16 */                            \
       subtract_average_32x32_##arch, /* 32x32 */                            \
-      cfl_subtract_average_null,     /* 64x64 (invalid CFL size) */         \
+      NULL,                          /* 64x64 (invalid CFL size) */         \
       subtract_average_4x8_##arch,   /* 4x8 */                              \
       subtract_average_8x4_##arch,   /* 8x4 */                              \
       subtract_average_8x16_##arch,  /* 8x16 */                             \
       subtract_average_16x8_##arch,  /* 16x8 */                             \
       subtract_average_16x32_##arch, /* 16x32 */                            \
       subtract_average_32x16_##arch, /* 32x16 */                            \
-      cfl_subtract_average_null,     /* 32x64 (invalid CFL size) */         \
-      cfl_subtract_average_null,     /* 64x32 (invalid CFL size) */         \
+      NULL,                          /* 32x64 (invalid CFL size) */         \
+      NULL,                          /* 64x32 (invalid CFL size) */         \
       subtract_average_4x16_##arch,  /* 4x16 (invalid CFL size) */          \
       subtract_average_16x4_##arch,  /* 16x4 (invalid CFL size) */          \
       subtract_average_8x32_##arch,  /* 8x32 (invalid CFL size) */          \
       subtract_average_32x8_##arch,  /* 32x8 (invalid CFL size) */          \
-      cfl_subtract_average_null,     /* 16x64 (invalid CFL size) */         \
-      cfl_subtract_average_null,     /* 64x16 (invalid CFL size) */         \
+      NULL,                          /* 16x64 (invalid CFL size) */         \
+      NULL,                          /* 64x16 (invalid CFL size) */         \
     };                                                                      \
     /* Modulo TX_SIZES_ALL to ensure that an attacker won't be able to */   \
     /* index the function pointer array out of bounds. */                   \
@@ -249,14 +233,6 @@
 #define CFL_PREDICT_X(arch, width, height, bd) \
   CFL_PREDICT_##bd(arch, width, height)
 
-// Null function used for invalid tx_sizes
-void cfl_predict_lbd_null(const int16_t *pred_buf_q3, uint8_t *dst,
-                          int dst_stride, int alpha_q3);
-
-// Null function used for invalid tx_sizes
-void cfl_predict_hbd_null(const int16_t *pred_buf_q3, uint16_t *dst,
-                          int dst_stride, int alpha_q3, int bd);
-
 #define CFL_PREDICT_FN(arch, bd)                                          \
   CFL_PREDICT_X(arch, 4, 4, bd)                                           \
   CFL_PREDICT_X(arch, 4, 8, bd)                                           \
@@ -278,21 +254,21 @@
       predict_##bd##_8x8_##arch,   /* 8x8 */                              \
       predict_##bd##_16x16_##arch, /* 16x16 */                            \
       predict_##bd##_32x32_##arch, /* 32x32 */                            \
-      cfl_predict_##bd##_null,     /* 64x64 (invalid CFL size) */         \
+      NULL,                        /* 64x64 (invalid CFL size) */         \
       predict_##bd##_4x8_##arch,   /* 4x8 */                              \
       predict_##bd##_8x4_##arch,   /* 8x4 */                              \
       predict_##bd##_8x16_##arch,  /* 8x16 */                             \
       predict_##bd##_16x8_##arch,  /* 16x8 */                             \
       predict_##bd##_16x32_##arch, /* 16x32 */                            \
       predict_##bd##_32x16_##arch, /* 32x16 */                            \
-      cfl_predict_##bd##_null,     /* 32x64 (invalid CFL size) */         \
-      cfl_predict_##bd##_null,     /* 64x32 (invalid CFL size) */         \
+      NULL,                        /* 32x64 (invalid CFL size) */         \
+      NULL,                        /* 64x32 (invalid CFL size) */         \
       predict_##bd##_4x16_##arch,  /* 4x16  */                            \
       predict_##bd##_16x4_##arch,  /* 16x4  */                            \
       predict_##bd##_8x32_##arch,  /* 8x32  */                            \
       predict_##bd##_32x8_##arch,  /* 32x8  */                            \
-      cfl_predict_##bd##_null,     /* 16x64 (invalid CFL size) */         \
-      cfl_predict_##bd##_null,     /* 64x16 (invalid CFL size) */         \
+      NULL,                        /* 16x64 (invalid CFL size) */         \
+      NULL,                        /* 64x16 (invalid CFL size) */         \
     };                                                                    \
     /* Modulo TX_SIZES_ALL to ensure that an attacker won't be able to */ \
     /* index the function pointer array out of bounds. */                 \
diff --git a/av1/common/ppc/cfl_ppc.c b/av1/common/ppc/cfl_ppc.c
index 026a078..61d8dc1 100644
--- a/av1/common/ppc/cfl_ppc.c
+++ b/av1/common/ppc/cfl_ppc.c
@@ -130,21 +130,21 @@
     subtract_average_8x8_vsx,   /* 8x8 */
     subtract_average_16x16_vsx, /* 16x16 */
     subtract_average_32x32_vsx, /* 32x32 */
-    cfl_subtract_average_null,  /* 64x64 (invalid CFL size) */
+    NULL,                       /* 64x64 (invalid CFL size) */
     subtract_average_4x8_c,     /* 4x8 */
     subtract_average_8x4_vsx,   /* 8x4 */
     subtract_average_8x16_vsx,  /* 8x16 */
     subtract_average_16x8_vsx,  /* 16x8 */
     subtract_average_16x32_vsx, /* 16x32 */
     subtract_average_32x16_vsx, /* 32x16 */
-    cfl_subtract_average_null,  /* 32x64 (invalid CFL size) */
-    cfl_subtract_average_null,  /* 64x32 (invalid CFL size) */
+    NULL,                       /* 32x64 (invalid CFL size) */
+    NULL,                       /* 64x32 (invalid CFL size) */
     subtract_average_4x16_c,    /* 4x16 */
     subtract_average_16x4_vsx,  /* 16x4 */
     subtract_average_8x32_vsx,  /* 8x32 */
     subtract_average_32x8_vsx,  /* 32x8 */
-    cfl_subtract_average_null,  /* 16x64 (invalid CFL size) */
-    cfl_subtract_average_null,  /* 64x16 (invalid CFL size) */
+    NULL,                       /* 16x64 (invalid CFL size) */
+    NULL,                       /* 64x16 (invalid CFL size) */
   };
   // Modulo TX_SIZES_ALL to ensure that an attacker won't be able to
   // index the function pointer array out of bounds.
diff --git a/av1/common/x86/cfl_avx2.c b/av1/common/x86/cfl_avx2.c
index a8bfdcc..d9bdf60 100644
--- a/av1/common/x86/cfl_avx2.c
+++ b/av1/common/x86/cfl_avx2.c
@@ -27,21 +27,21 @@
       subsample_##bd##_##sub##_8x8_ssse3,   /* 8x8 */                      \
       subsample_##bd##_##sub##_16x16_ssse3, /* 16x16 */                    \
       subsample_##bd##_##sub##_32x32_avx2,  /* 32x32 */                    \
-      cfl_subsample_##bd##_null,            /* 64x64 (invalid CFL size) */ \
+      NULL,                                 /* 64x64 (invalid CFL size) */ \
       subsample_##bd##_##sub##_4x8_ssse3,   /* 4x8 */                      \
       subsample_##bd##_##sub##_8x4_ssse3,   /* 8x4 */                      \
       subsample_##bd##_##sub##_8x16_ssse3,  /* 8x16 */                     \
       subsample_##bd##_##sub##_16x8_ssse3,  /* 16x8 */                     \
       subsample_##bd##_##sub##_16x32_ssse3, /* 16x32 */                    \
       subsample_##bd##_##sub##_32x16_avx2,  /* 32x16 */                    \
-      cfl_subsample_##bd##_null,            /* 32x64 (invalid CFL size) */ \
-      cfl_subsample_##bd##_null,            /* 64x32 (invalid CFL size) */ \
+      NULL,                                 /* 32x64 (invalid CFL size) */ \
+      NULL,                                 /* 64x32 (invalid CFL size) */ \
       subsample_##bd##_##sub##_4x16_ssse3,  /* 4x16  */                    \
       subsample_##bd##_##sub##_16x4_ssse3,  /* 16x4  */                    \
       subsample_##bd##_##sub##_8x32_ssse3,  /* 8x32  */                    \
       subsample_##bd##_##sub##_32x8_avx2,   /* 32x8  */                    \
-      cfl_subsample_##bd##_null,            /* 16x64 (invalid CFL size) */ \
-      cfl_subsample_##bd##_null,            /* 64x16 (invalid CFL size) */ \
+      NULL,                                 /* 16x64 (invalid CFL size) */ \
+      NULL,                                 /* 64x16 (invalid CFL size) */ \
     };                                                                     \
     return subfn_##sub[tx_size];                                           \
   }
@@ -279,21 +279,21 @@
     predict_lbd_8x8_ssse3,   /* 8x8 */
     predict_lbd_16x16_ssse3, /* 16x16 */
     predict_lbd_32x32_avx2,  /* 32x32 */
-    cfl_predict_lbd_null,    /* 64x64 (invalid CFL size) */
+    NULL,                    /* 64x64 (invalid CFL size) */
     predict_lbd_4x8_ssse3,   /* 4x8 */
     predict_lbd_8x4_ssse3,   /* 8x4 */
     predict_lbd_8x16_ssse3,  /* 8x16 */
     predict_lbd_16x8_ssse3,  /* 16x8 */
     predict_lbd_16x32_ssse3, /* 16x32 */
     predict_lbd_32x16_avx2,  /* 32x16 */
-    cfl_predict_lbd_null,    /* 32x64 (invalid CFL size) */
-    cfl_predict_lbd_null,    /* 64x32 (invalid CFL size) */
+    NULL,                    /* 32x64 (invalid CFL size) */
+    NULL,                    /* 64x32 (invalid CFL size) */
     predict_lbd_4x16_ssse3,  /* 4x16  */
     predict_lbd_16x4_ssse3,  /* 16x4  */
     predict_lbd_8x32_ssse3,  /* 8x32  */
     predict_lbd_32x8_avx2,   /* 32x8  */
-    cfl_predict_lbd_null,    /* 16x64 (invalid CFL size) */
-    cfl_predict_lbd_null,    /* 64x16 (invalid CFL size) */
+    NULL,                    /* 16x64 (invalid CFL size) */
+    NULL,                    /* 64x16 (invalid CFL size) */
   };
   // Modulo TX_SIZES_ALL to ensure that an attacker won't be able to index the
   // function pointer array out of bounds.
@@ -352,21 +352,21 @@
     predict_hbd_8x8_ssse3,  /* 8x8 */
     predict_hbd_16x16_avx2, /* 16x16 */
     predict_hbd_32x32_avx2, /* 32x32 */
-    cfl_predict_hbd_null,   /* 64x64 (invalid CFL size) */
+    NULL,                   /* 64x64 (invalid CFL size) */
     predict_hbd_4x8_ssse3,  /* 4x8 */
     predict_hbd_8x4_ssse3,  /* 8x4 */
     predict_hbd_8x16_ssse3, /* 8x16 */
     predict_hbd_16x8_avx2,  /* 16x8 */
     predict_hbd_16x32_avx2, /* 16x32 */
     predict_hbd_32x16_avx2, /* 32x16 */
-    cfl_predict_hbd_null,   /* 32x64 (invalid CFL size) */
-    cfl_predict_hbd_null,   /* 64x32 (invalid CFL size) */
+    NULL,                   /* 32x64 (invalid CFL size) */
+    NULL,                   /* 64x32 (invalid CFL size) */
     predict_hbd_4x16_ssse3, /* 4x16  */
     predict_hbd_16x4_avx2,  /* 16x4  */
     predict_hbd_8x32_ssse3, /* 8x32  */
     predict_hbd_32x8_avx2,  /* 32x8  */
-    cfl_predict_hbd_null,   /* 16x64 (invalid CFL size) */
-    cfl_predict_hbd_null,   /* 64x16 (invalid CFL size) */
+    NULL,                   /* 16x64 (invalid CFL size) */
+    NULL,                   /* 64x16 (invalid CFL size) */
   };
   // Modulo TX_SIZES_ALL to ensure that an attacker won't be able to index the
   // function pointer array out of bounds.
@@ -469,21 +469,21 @@
     subtract_average_8x8_sse2,   /* 8x8 */
     subtract_average_16x16_avx2, /* 16x16 */
     subtract_average_32x32_avx2, /* 32x32 */
-    cfl_subtract_average_null,   /* 64x64 (invalid CFL size) */
+    NULL,                        /* 64x64 (invalid CFL size) */
     subtract_average_4x8_sse2,   /* 4x8 */
     subtract_average_8x4_sse2,   /* 8x4 */
     subtract_average_8x16_sse2,  /* 8x16 */
     subtract_average_16x8_avx2,  /* 16x8 */
     subtract_average_16x32_avx2, /* 16x32 */
     subtract_average_32x16_avx2, /* 32x16 */
-    cfl_subtract_average_null,   /* 32x64 (invalid CFL size) */
-    cfl_subtract_average_null,   /* 64x32 (invalid CFL size) */
+    NULL,                        /* 32x64 (invalid CFL size) */
+    NULL,                        /* 64x32 (invalid CFL size) */
     subtract_average_4x16_sse2,  /* 4x16 */
     subtract_average_16x4_avx2,  /* 16x4 */
     subtract_average_8x32_sse2,  /* 8x32 */
     subtract_average_32x8_avx2,  /* 32x8 */
-    cfl_subtract_average_null,   /* 16x64 (invalid CFL size) */
-    cfl_subtract_average_null,   /* 64x16 (invalid CFL size) */
+    NULL,                        /* 16x64 (invalid CFL size) */
+    NULL,                        /* 64x16 (invalid CFL size) */
   };
   // Modulo TX_SIZES_ALL to ensure that an attacker won't be able to
   // index the function pointer array out of bounds.