diff --git a/aom_dsp/entdec.c b/aom_dsp/entdec.c
index 8cfb826..143e811 100644
--- a/aom_dsp/entdec.c
+++ b/aom_dsp/entdec.c
@@ -279,10 +279,11 @@
       dif -= vw;
       ret++;
     } else {
+      bit++;
       break;
     }
   }
-  return od_ec_dec_bypass_normalize(dec, dif, bit + 1, ret);
+  return od_ec_dec_bypass_normalize(dec, dif, bit, ret);
 }
 #endif  // CONFIG_BYPASS_IMPROVEMENT
 
diff --git a/av1/av1.cmake b/av1/av1.cmake
index 41976c2..30186d1 100644
--- a/av1/av1.cmake
+++ b/av1/av1.cmake
@@ -94,9 +94,11 @@
   "${AOM_ROOT}/av1/common/txb_common.c"
   "${AOM_ROOT}/av1/common/txb_common.h"
   "${AOM_ROOT}/av1/common/warped_motion.c"
-  "${AOM_ROOT}/av1/common/warped_motion.h")
-list(APPEND AOM_AV1_COMMON_SOURCES "${AOM_ROOT}/av1/common/pef.h")
-list(APPEND AOM_AV1_COMMON_SOURCES "${AOM_ROOT}/av1/common/pef.c")
+  "${AOM_ROOT}/av1/common/warped_motion.h"
+  "${AOM_ROOT}/av1/common/hr_coding.h"
+  "${AOM_ROOT}/av1/common/hr_coding.c")
+  list(APPEND AOM_AV1_COMMON_SOURCES "${AOM_ROOT}/av1/common/pef.h")
+  list(APPEND AOM_AV1_COMMON_SOURCES "${AOM_ROOT}/av1/common/pef.c")
 
 if(CONFIG_LPF_MASK)
   list(APPEND AOM_AV1_COMMON_SOURCES "${AOM_ROOT}/av1/common/loopfiltermask.c")
diff --git a/av1/common/entropy.h b/av1/common/entropy.h
index 440656d..5dc7649 100644
--- a/av1/common/entropy.h
+++ b/av1/common/entropy.h
@@ -83,8 +83,11 @@
 #define NUM_BASE_LEVELS 2
 
 #define BR_CDF_SIZE (4)
+#if CONFIG_ADAPTIVE_HR
+#define COEFF_BASE_RANGE (1 * (BR_CDF_SIZE - 1))
+#else
 #define COEFF_BASE_RANGE (4 * (BR_CDF_SIZE - 1))
-
+#endif  // CONFIG_ADAPTIVE_HR
 #define COEFF_CONTEXT_BITS 3
 #define COEFF_CONTEXT_MASK ((1 << COEFF_CONTEXT_BITS) - 1)
 #define MAX_BASE_BR_RANGE (COEFF_BASE_RANGE + NUM_BASE_LEVELS + 1)
diff --git a/av1/common/hr_coding.c b/av1/common/hr_coding.c
new file mode 100644
index 0000000..782e6e7
--- /dev/null
+++ b/av1/common/hr_coding.c
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2023, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 3-Clause Clear License
+ * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
+ * License was not distributed with this source code in the LICENSE file, you
+ * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/.  If the
+ * Alliance for Open Media Patent License 1.0 was not distributed with this
+ * source code in the PATENTS file, you can obtain it at
+ * aomedia.org/license/patent-license/.
+ */
+
+#include "av1/common/hr_coding.h"
+#include "aom/internal/aom_codec_internal.h"
+
+void write_exp_golomb(aom_writer *w, int level, int k) {
+  int x = level + (1 << k);
+  int length = 0;
+
+  length = get_msb(x) + 1;
+  assert(length > k);
+
+#if CONFIG_BYPASS_IMPROVEMENT
+  aom_write_literal(w, 0, length - 1 - k);
+  aom_write_literal(w, x, length);
+#else
+  for (i = 0; i < length - 1 - k; ++i) aom_write_bit(w, 0);
+  for (i = length - 1; i >= 0; --i) aom_write_bit(w, (x >> i) & 0x01);
+#endif  // CONFIG_BYPASS_IMPROVEMENT
+}
+
+int read_exp_golomb(MACROBLOCKD *xd, aom_reader *r, int k) {
+#if CONFIG_BYPASS_IMPROVEMENT
+  int length = aom_read_unary(r, 21, ACCT_INFO("hr"));
+  if (length > 20) {
+    aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
+                       "Invalid length in read_exp_golomb");
+  }
+  length += k;
+  int x = 1 << length;
+  x += aom_read_literal(r, length, ACCT_INFO("hr"));
+#else
+  int x = 1;
+  int length = 0;
+  int i = 0;
+  while (!i) {
+    i = aom_read_bit(r, ACCT_INFO("hr"));
+    ++length;
+    if (length > 20) {
+      aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
+                         "Invalid length in read_exp_golomb");
+      break;
+    }
+  }
+  length += k;
+  for (i = 0; i < length - 1; ++i) {
+    x <<= 1;
+    x += aom_read_bit(r, ACCT_INFO("hr"));
+  }
+#endif  // CONFIG_BYPASS_IMPROVEMENT
+
+  return x - (1 << k);
+}
+
+#if CONFIG_ADAPTIVE_HR
+
+typedef struct adaptive_table {
+  int *table;
+  int initial_param;
+  unsigned int table_size;
+} adaptive_table;
+
+int intra_table[] = { 10, 20, 40, 75, 135 };
+int inter_table[] = { 20, 35, 55, 95, 170 };
+int idtx_table[] = { 25, 50, 130 };
+
+adaptive_table tables[] = {
+  { .table = intra_table, .initial_param = 1, .table_size = 5 },  // Intra table
+  { .table = inter_table, .initial_param = 1, .table_size = 5 },  // Inter table
+  { .table = idtx_table,
+    .initial_param = 1,
+    .table_size = 3 },  // IDTX table (only for inter)
+};
+
+int get_adaptive_param(adaptive_hr_info *info) {
+  adaptive_table *adp_table;
+  adp_table = &tables[0];
+
+  int m = adp_table->initial_param;
+
+  for (unsigned int i = 0; i < adp_table->table_size; ++i) {
+    if (info->context < adp_table->table[i]) break;
+    ++m;
+  }
+
+  return m;
+}
+
+void write_truncated_rice(aom_writer *w, int level, int m, int k, int cmax) {
+  const int mask = (1 << m) - 1;
+  int q = level >> m;
+
+  if (q >= cmax) {
+    aom_write_literal(w, 0, cmax);
+    write_exp_golomb(w, level - (cmax << m), k);
+  } else {
+    aom_write_literal(w, 0, q);
+    aom_write_literal(w, 1, 1);
+    aom_write_literal(w, level & mask, m);
+  }
+}
+
+int read_truncated_rice(MACROBLOCKD *xd, aom_reader *r, int m, int k,
+                        int cmax) {
+  int q = aom_read_unary(r, cmax, ACCT_INFO("hr"));
+  if (q == cmax) return read_exp_golomb(xd, r, k) + (cmax << m);
+
+  int rem = aom_read_literal(r, m, ACCT_INFO("hr"));
+  return rem + (q << m);
+}
+
+int get_truncated_rice_length(int level, int m, int k, int cmax) {
+  int q = level >> m;
+
+  if (q >= cmax) return cmax + get_exp_golomb_length(level - (cmax << m), k);
+
+  return q + 1 + m;
+}
+
+int get_truncated_rice_length_diff(int level, int m, int k, int cmax,
+                                   int *diff) {
+  int q = level >> m;
+
+  if (q >= cmax) {
+    int lshifted = level - (cmax << m);
+    if (lshifted == 0) {
+      int golomb_len0 = k + 1;
+      *diff = golomb_len0 - m;
+      return cmax + golomb_len0;
+    }
+    return cmax + get_exp_golomb_length_diff(lshifted, k, diff);
+  }
+
+  if (level == 0) {
+    *diff = m + 1;
+    return m + 1;
+  }
+
+  *diff = level == (q << m);
+  return q + 1 + m;
+}
+
+void write_adaptive_hr(aom_writer *w, int level, adaptive_hr_info *info) {
+  int m = get_adaptive_param(info);
+  write_truncated_rice(w, level, m, m + 1, AOMMIN(m + 4, 6));
+}
+
+int read_adaptive_hr(MACROBLOCKD *xd, aom_reader *r, adaptive_hr_info *info) {
+  int m = get_adaptive_param(info);
+  return read_truncated_rice(xd, r, m, m + 1, AOMMIN(m + 4, 6));
+}
+
+int get_adaptive_hr_length(int level, adaptive_hr_info *info) {
+  int m = get_adaptive_param(info);
+  return get_truncated_rice_length(level, m, m + 1, AOMMIN(m + 4, 6));
+}
+
+int get_adaptive_hr_length_diff(int level, adaptive_hr_info *info, int *diff) {
+  int m = get_adaptive_param(info);
+  return get_truncated_rice_length_diff(level, m, m + 1, AOMMIN(m + 4, 6),
+                                        diff);
+}
+
+#endif  // CONFIG_ADAPTIVE_HR
diff --git a/av1/common/hr_coding.h b/av1/common/hr_coding.h
new file mode 100644
index 0000000..4b56c37
--- /dev/null
+++ b/av1/common/hr_coding.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2021, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 3-Clause Clear License
+ * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
+ * License was not distributed with this source code in the LICENSE file, you
+ * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/.  If the
+ * Alliance for Open Media Patent License 1.0 was not distributed with this
+ * source code in the PATENTS file, you can obtain it at
+ * aomedia.org/license/patent-license/.
+ */
+
+#ifndef AOM_AV1_COMMON_HR_CODING_H_
+#define AOM_AV1_COMMON_HR_CODING_H_
+
+#include "config/aom_config.h"
+
+#include "av1/common/blockd.h"
+#include "aom_dsp/bitwriter.h"
+#include "aom_dsp/bitreader.h"
+
+void write_exp_golomb(aom_writer *w, int level, int k);
+int read_exp_golomb(MACROBLOCKD *xd, aom_reader *r, int k);
+
+static INLINE int get_exp_golomb_length(int level, int k) {
+  return 2 * get_msb(level + (1 << k)) + 1 - k;
+}
+
+static INLINE int get_exp_golomb_length_diff(int level, int k, int *diff) {
+  if (level == 0) {
+    *diff = k + 1;
+    return k + 1;
+  }
+
+  int x = level + (1 << k);
+  *diff = (x & (x - 1)) == 0 ? 2 : 0;
+  return 2 * get_msb(x) + 1 - k;
+}
+
+#if CONFIG_ADAPTIVE_HR
+
+typedef struct adaptive_hr_info {
+  int context;
+  TX_SIZE tx_size;
+  TX_TYPE tx_type;
+  int qindex;
+  bool is_inter;
+  bool is_dc;
+  bool is_eob;
+} adaptive_hr_info;
+
+void write_truncated_rice(aom_writer *w, int level, int m, int k, int cmax);
+int read_truncated_rice(MACROBLOCKD *xd, aom_reader *r, int m, int k, int cmax);
+int get_truncated_rice_length(int level, int m, int k, int cmax);
+int get_truncated_rice_length_diff(int level, int m, int k, int cmax,
+                                   int *diff);
+
+void write_adaptive_hr(aom_writer *w, int level, adaptive_hr_info *info);
+int read_adaptive_hr(MACROBLOCKD *xd, aom_reader *r, adaptive_hr_info *info);
+int get_adaptive_hr_length(int level, adaptive_hr_info *info);
+int get_adaptive_hr_length_diff(int level, adaptive_hr_info *info, int *diff);
+
+#endif  // CONFIG_ADAPTIVE_HR
+
+#endif  // AOM_AV1_COMMON_HR_CODING_H_
diff --git a/av1/common/txb_common.h b/av1/common/txb_common.h
index cc1829e..c35cce4 100644
--- a/av1/common/txb_common.h
+++ b/av1/common/txb_common.h
@@ -269,6 +269,7 @@
                                           const TX_CLASS tx_class) {
   int mag;
   // Note: AOMMIN(level, 5) is useless for decoder since level < 5.
+
   mag = clip_max5[levels[1]];                         // { 0, 1 }
   mag += clip_max5[levels[(1 << bwl) + TX_PAD_HOR]];  // { 1, 0 }
   if (tx_class == TX_CLASS_2D) {
@@ -292,8 +293,8 @@
 static AOM_FORCE_INLINE int get_nz_mag(const uint8_t *const levels,
                                        const int bwl, const TX_CLASS tx_class) {
   int mag;
-
   // Note: AOMMIN(level, 3) is useless for decoder since level < 3.
+
   mag = clip_max3[levels[1]];                         // { 0, 1 }
   mag += clip_max3[levels[(1 << bwl) + TX_PAD_HOR]];  // { 1, 0 }
 
@@ -314,6 +315,27 @@
   return mag;
 }
 
+#if CONFIG_ADAPTIVE_HR
+static AOM_FORCE_INLINE int get_nz_mag_noclip(const uint8_t *const levels,
+                                              const int bwl,
+                                              const TX_CLASS tx_class) {
+  int mag;
+
+  mag = levels[1];                         // { 0, 1 }
+  mag += levels[(1 << bwl) + TX_PAD_HOR];  // { 1, 0 }
+
+  if (tx_class == TX_CLASS_2D) {
+    mag += levels[(1 << bwl) + TX_PAD_HOR + 1];  // { 1, 1 }
+  } else if (tx_class == TX_CLASS_VERT) {
+    mag += levels[(2 << bwl) + (2 << TX_PAD_HOR_LOG2)];  // { 2, 0 }
+  } else {
+    mag += levels[2];  // { 0, 2 }
+  }
+
+  return mag;
+}
+#endif  // CONFIG_ADAPTIVE_HR
+
 #define NZ_MAP_CTX_0 SIG_COEF_CONTEXTS_2D
 #define NZ_MAP_CTX_5 (NZ_MAP_CTX_0 + 5)
 #define NZ_MAP_CTX_10 (NZ_MAP_CTX_0 + 10)
@@ -621,6 +643,23 @@
   }
 }
 
+#if CONFIG_ADAPTIVE_HR
+static AOM_FORCE_INLINE int get_hr_ctx(const uint8_t *levels, int coeff_idx,
+                                       int bwl, int is_eob, TX_CLASS tx_class) {
+  if (is_eob) return 0;
+  return get_nz_mag_noclip(levels + get_padded_idx(coeff_idx, bwl), bwl,
+                           tx_class);
+}
+
+static AOM_FORCE_INLINE int get_hr_ctx_skip(const uint8_t *levels,
+                                            int coeff_idx, int bwl, int is_eob,
+                                            TX_CLASS tx_class) {
+  if (is_eob) return 0;
+  return get_nz_mag_noclip(levels + get_padded_idx_left(coeff_idx, bwl), bwl,
+                           tx_class);
+}
+#endif  // CONFIG_ADAPTIVE_HR
+
 static INLINE void set_dc_sign(int *cul_level, int dc_val) {
   if (dc_val < 0)
     *cul_level |= 1 << COEFF_CONTEXT_BITS;
diff --git a/av1/decoder/decodetxb.c b/av1/decoder/decodetxb.c
index 3959564..3313fb7 100644
--- a/av1/decoder/decodetxb.c
+++ b/av1/decoder/decodetxb.c
@@ -18,40 +18,9 @@
 #include "av1/common/scan.h"
 #include "av1/common/txb_common.h"
 #include "av1/common/reconintra.h"
+#include "av1/common/hr_coding.h"
 #include "av1/decoder/decodemv.h"
 
-static int read_golomb(MACROBLOCKD *xd, aom_reader *r) {
-  int x = 1;
-  int length = 0;
-
-#if CONFIG_BYPASS_IMPROVEMENT
-  length = aom_read_unary(r, 21, ACCT_INFO("length"));
-  if (length > 20) {
-    aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
-                       "Invalid length in read_golomb");
-  }
-  x = 1 << length;
-  x += aom_read_literal(r, length, ACCT_INFO());
-#else
-  int i = 0;
-  while (!i) {
-    i = aom_read_bit(r, ACCT_INFO());
-    ++length;
-    if (length > 20) {
-      aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
-                         "Invalid length in read_golomb");
-      break;
-    }
-  }
-  for (i = 0; i < length - 1; ++i) {
-    x <<= 1;
-    x += aom_read_bit(r, ACCT_INFO());
-  }
-#endif  // CONFIG_BYPASS_IMPROVEMENT
-
-  return x - 1;
-}
-
 static INLINE int rec_eob_pos(const int eob_token, const int extra) {
   int eob = av1_eob_group_start[eob_token];
   if (eob > 2) {
@@ -431,6 +400,16 @@
                       cm->features.reduced_tx_set_used);
   const qm_val_t *iqmatrix =
       av1_get_iqmatrix(&cm->quant_params, xd, plane, tx_size, tx_type);
+
+#if CONFIG_ADAPTIVE_HR
+  const TX_CLASS tx_class = tx_type_to_class[get_primary_tx_type(tx_type)];
+  adaptive_hr_info hr_info = { .tx_size = tx_size,
+                               .tx_type = tx_type,
+                               .qindex = xd->qindex[mbmi->segment_id],
+                               .is_inter =
+                                   is_inter_block(mbmi, xd->tree_type) };
+#endif  // CONFIG_ADAPTIVE_HR
+
 #if CONFIG_INSPECTION
   for (int c = 0; c < width * height; c++) {
     dequant_values[c] = get_dqv(dequant, c, iqmatrix);
@@ -480,7 +459,18 @@
                              ACCT_INFO("sign"));
       signs[get_padded_idx(pos, bwl)] = sign > 0 ? -1 : 1;
       if (level >= MAX_BASE_BR_RANGE) {
-        level += read_golomb(xd, r);
+#if CONFIG_ADAPTIVE_HR
+        bool is_eob = c == (eob_data->eob - 1);
+        hr_info.is_dc = (c == 0);
+        hr_info.is_eob = is_eob;
+        hr_info.context = get_hr_ctx_skip(levels, pos, bwl, is_eob, tx_class);
+        level += read_adaptive_hr(xd, r, &hr_info);
+
+        levels[get_padded_idx_left(pos, bwl)] =
+            (uint8_t)(AOMMIN(level, UINT8_MAX));
+#else
+        level += read_exp_golomb(xd, r, 0);
+#endif  // CONFIG_ADAPTIVE_HR
       }
       if (c == 0) dc_val = sign ? -level : level;
       // Bitmasking to clamp level to valid range:
@@ -589,6 +579,15 @@
   const TX_CLASS tx_class = tx_type_to_class[get_primary_tx_type(tx_type)];
   const qm_val_t *iqmatrix =
       av1_get_iqmatrix(&cm->quant_params, xd, plane, tx_size, tx_type);
+
+#if CONFIG_ADAPTIVE_HR
+  adaptive_hr_info hr_info = { .tx_size = tx_size,
+                               .tx_type = tx_type,
+                               .qindex = xd->qindex[mbmi->segment_id],
+                               .is_inter =
+                                   is_inter_block(mbmi, xd->tree_type) };
+#endif  // CONFIG_ADAPTIVE_HR
+
 #if CONFIG_INSPECTION
   for (int c = 0; c < width * height; c++) {
     dequant_values[c] = get_dqv(dequant, c, iqmatrix);
@@ -762,7 +761,19 @@
       }
       if (is_hidden && c == 0) {
         if (level >= (MAX_BASE_BR_RANGE << 1)) {
-          level += (read_golomb(xd, r) << 1);
+#if CONFIG_ADAPTIVE_HR
+          bool is_eob = c == (*eob - 1);
+          hr_info.is_dc = (c == 0);
+          hr_info.is_eob = is_eob;
+          // Use context divided by 2 since the coefficient is also divided by 2
+          hr_info.context = get_hr_ctx(levels, pos, bwl, is_eob, tx_class) >> 1;
+          level += (read_adaptive_hr(xd, r, &hr_info) << 1);
+
+          levels[get_padded_idx(pos, bwl)] =
+              (uint8_t)(AOMMIN(level, UINT8_MAX));
+#else
+          level += (read_exp_golomb(xd, r, 0) << 1);
+#endif  // CONFIG_ADAPTIVE_HR
         }
       } else {
         const int row = pos >> bwl;
@@ -770,11 +781,33 @@
         int limits = get_lf_limits(row, col, tx_class, plane);
         if (limits) {
           if (level >= LF_MAX_BASE_BR_RANGE) {
-            level += read_golomb(xd, r);
+#if CONFIG_ADAPTIVE_HR
+            bool is_eob = c == (*eob - 1);
+            hr_info.is_dc = (c == 0);
+            hr_info.is_eob = is_eob;
+            hr_info.context = get_hr_ctx(levels, pos, bwl, is_eob, tx_class);
+            level += read_adaptive_hr(xd, r, &hr_info);
+
+            levels[get_padded_idx(pos, bwl)] =
+                (uint8_t)(AOMMIN(level, UINT8_MAX));
+#else
+            level += read_exp_golomb(xd, r, 0);
+#endif  // CONFIG_ADAPTIVE_HR
           }
         } else {
           if (level >= MAX_BASE_BR_RANGE) {
-            level += read_golomb(xd, r);
+#if CONFIG_ADAPTIVE_HR
+            bool is_eob = c == (*eob - 1);
+            hr_info.is_dc = (c == 0);
+            hr_info.is_eob = is_eob;
+            hr_info.context = get_hr_ctx(levels, pos, bwl, is_eob, tx_class);
+            level += read_adaptive_hr(xd, r, &hr_info);
+
+            levels[get_padded_idx(pos, bwl)] =
+                (uint8_t)(AOMMIN(level, UINT8_MAX));
+#else
+            level += read_exp_golomb(xd, r, 0);
+#endif  // CONFIG_ADAPTIVE_HR
           }
         }
       }
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index 9bc2c04..e8a24cb 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c
@@ -18,6 +18,7 @@
 #include "av1/common/pred_common.h"
 #include "av1/common/scan.h"
 #include "av1/common/reconintra.h"
+#include "av1/common/hr_coding.h"
 #include "av1/encoder/bitstream.h"
 #include "av1/encoder/cost.h"
 #include "av1/encoder/encodeframe.h"
@@ -108,29 +109,6 @@
 
 void av1_free_txb_buf(AV1_COMP *cpi) { aom_free(cpi->coeff_buffer_base); }
 
-static void write_golomb(aom_writer *w, int level) {
-  int x = level + 1;
-  int length = 0;
-
-#if CONFIG_BYPASS_IMPROVEMENT
-  length = get_msb(x) + 1;
-  assert(length > 0);
-  aom_write_literal(w, 0, length - 1);
-  aom_write_literal(w, x, length);
-#else
-  int i = x;
-  while (i) {
-    i >>= 1;
-    ++length;
-  }
-  assert(length > 0);
-
-  for (i = 0; i < length - 1; ++i) aom_write_bit(w, 0);
-
-  for (i = length - 1; i >= 0; --i) aom_write_bit(w, (x >> i) & 0x01);
-#endif
-}
-
 static INLINE int64_t get_coeff_dist(tran_low_t tcoeff, tran_low_t dqcoeff,
                                      int shift) {
   const int64_t diff = (tcoeff - dqcoeff) * (1 << shift);
@@ -298,35 +276,93 @@
   return eob_cost;
 }
 
-static const int golomb_bits_cost[32] = {
+#if CONFIG_ADAPTIVE_HR
+static INLINE int get_br_cost(tran_low_t level, const int *coeff_lps,
+                              adaptive_hr_info *info) {
+  const int base_range = AOMMIN(level - 1 - NUM_BASE_LEVELS, COEFF_BASE_RANGE);
+  int cost = coeff_lps[base_range];
+
+  if (level >= 1 + NUM_BASE_LEVELS + COEFF_BASE_RANGE) {
+    const int r = level - COEFF_BASE_RANGE - NUM_BASE_LEVELS - 1;
+    cost += av1_cost_literal(get_adaptive_hr_length(r, info));
+  }
+  return cost;
+}
+
+static INLINE int get_br_lf_cost(tran_low_t level, const int *coeff_lps,
+                                 adaptive_hr_info *info) {
+  const int base_range =
+      AOMMIN(level - 1 - LF_NUM_BASE_LEVELS, COEFF_BASE_RANGE);
+  int cost = coeff_lps[base_range];
+
+  if (level >= 1 + LF_NUM_BASE_LEVELS + COEFF_BASE_RANGE) {
+    const int r = level - COEFF_BASE_RANGE - LF_NUM_BASE_LEVELS - 1;
+    cost += av1_cost_literal(get_adaptive_hr_length(r, info));
+  }
+  return cost;
+}
+
+static INLINE int get_br_cost_with_diff(tran_low_t level, const int *coeff_lps,
+                                        int *diff, adaptive_hr_info *info) {
+  const int base_range = AOMMIN(level - 1 - NUM_BASE_LEVELS, COEFF_BASE_RANGE);
+  int cost = coeff_lps[base_range];
+
+  if (level <= COEFF_BASE_RANGE + 1 + NUM_BASE_LEVELS)
+    *diff += coeff_lps[base_range + COEFF_BASE_RANGE + 1];
+
+  if (level >= COEFF_BASE_RANGE + 1 + NUM_BASE_LEVELS) {
+    const int r = level - COEFF_BASE_RANGE - NUM_BASE_LEVELS - 1;
+    int bits, diff_bits;
+    bits = get_adaptive_hr_length_diff(r, info, &diff_bits);
+    *diff += av1_cost_literal(diff_bits);
+    cost += av1_cost_literal(bits);
+  }
+
+  return cost;
+}
+
+static INLINE int get_br_lf_cost_with_diff(tran_low_t level,
+                                           const int *coeff_lps, int *diff,
+                                           adaptive_hr_info *info) {
+  const int base_range =
+      AOMMIN(level - 1 - LF_NUM_BASE_LEVELS, COEFF_BASE_RANGE);
+  int cost = coeff_lps[base_range];
+
+  if (level <= COEFF_BASE_RANGE + 1 + LF_NUM_BASE_LEVELS)
+    *diff += coeff_lps[base_range + COEFF_BASE_RANGE + 1];
+
+  if (level >= COEFF_BASE_RANGE + 1 + LF_NUM_BASE_LEVELS) {
+    const int r = level - COEFF_BASE_RANGE - LF_NUM_BASE_LEVELS - 1;
+    int bits, diff_bits;
+    bits = get_adaptive_hr_length_diff(r, info, &diff_bits);
+    *diff += av1_cost_literal(diff_bits);
+    cost += av1_cost_literal(bits);
+  }
+
+  return cost;
+}
+#else
+static const int exp_golomb0_bits_cost[32] = {
   0,       512,     512 * 3, 512 * 3, 512 * 5, 512 * 5, 512 * 5, 512 * 5,
   512 * 7, 512 * 7, 512 * 7, 512 * 7, 512 * 7, 512 * 7, 512 * 7, 512 * 7,
   512 * 9, 512 * 9, 512 * 9, 512 * 9, 512 * 9, 512 * 9, 512 * 9, 512 * 9,
   512 * 9, 512 * 9, 512 * 9, 512 * 9, 512 * 9, 512 * 9, 512 * 9, 512 * 9
 };
-static const int golomb_cost_diff[32] = {
+static const int exp_golomb0_cost_diff[32] = {
   0,       512, 512 * 2, 0, 512 * 2, 0, 0, 0, 512 * 2, 0, 0, 0, 0, 0, 0, 0,
   512 * 2, 0,   0,       0, 0,       0, 0, 0, 0,       0, 0, 0, 0, 0, 0, 0
 };
 
-static INLINE int get_golomb_cost(int abs_qc) {
-  if (abs_qc >= 1 + NUM_BASE_LEVELS + COEFF_BASE_RANGE) {
-    const int r = abs_qc - COEFF_BASE_RANGE - NUM_BASE_LEVELS;
-    const int length = get_msb(r) + 1;
-    return av1_cost_literal(2 * length - 1);
-  }
-  return 0;
-}
+static INLINE int get_br_cost(tran_low_t level, const int *coeff_lps) {
+  const int base_range = AOMMIN(level - 1 - NUM_BASE_LEVELS, COEFF_BASE_RANGE);
+  int cost = coeff_lps[base_range];
 
-// Golomb cost of coding bypass coded level values in the
-// low-frequency region.
-static INLINE int get_golomb_cost_lf(int abs_qc) {
-  if (abs_qc >= 1 + LF_NUM_BASE_LEVELS + COEFF_BASE_RANGE) {
-    const int r = abs_qc - COEFF_BASE_RANGE - LF_NUM_BASE_LEVELS;
-    const int length = get_msb(r) + 1;
-    return av1_cost_literal(2 * length - 1);
+  if (level >= 1 + NUM_BASE_LEVELS + COEFF_BASE_RANGE) {
+    const int r = level - COEFF_BASE_RANGE - NUM_BASE_LEVELS - 1;
+    cost += av1_cost_literal(get_exp_golomb_length(r, 0));
   }
-  return 0;
+
+  return cost;
 }
 
 // Base range cost of coding level values in the
@@ -334,7 +370,35 @@
 static INLINE int get_br_lf_cost(tran_low_t level, const int *coeff_lps) {
   const int base_range =
       AOMMIN(level - 1 - LF_NUM_BASE_LEVELS, COEFF_BASE_RANGE);
-  return coeff_lps[base_range] + get_golomb_cost_lf(level);
+  int cost = coeff_lps[base_range];
+
+  if (level >= 1 + LF_NUM_BASE_LEVELS + COEFF_BASE_RANGE) {
+    const int r = level - COEFF_BASE_RANGE - LF_NUM_BASE_LEVELS - 1;
+    cost += av1_cost_literal(get_exp_golomb_length(r, 0));
+  }
+
+  return cost;
+}
+
+static INLINE int get_br_cost_with_diff(tran_low_t level, const int *coeff_lps,
+                                        int *diff) {
+  const int base_range = AOMMIN(level - 1 - NUM_BASE_LEVELS, COEFF_BASE_RANGE);
+  int cost = coeff_lps[base_range];
+
+  if (level <= COEFF_BASE_RANGE + 1 + NUM_BASE_LEVELS)
+    *diff += coeff_lps[base_range + COEFF_BASE_RANGE + 1];
+
+  if (level >= COEFF_BASE_RANGE + 1 + NUM_BASE_LEVELS) {
+    int r = level - COEFF_BASE_RANGE - NUM_BASE_LEVELS;
+    if (r < 32) {
+      cost += exp_golomb0_bits_cost[r];
+      *diff += exp_golomb0_cost_diff[r];
+    } else {
+      cost += av1_cost_literal(get_exp_golomb_length(r - 1, 0));
+      *diff += (r & (r - 1)) == 0 ? 1024 : 0;
+    }
+  }
+  return cost;
 }
 
 // Calculates differential cost for base range coding in the low-frequency
@@ -343,47 +407,24 @@
                                            const int *coeff_lps, int *diff) {
   const int base_range =
       AOMMIN(level - 1 - LF_NUM_BASE_LEVELS, COEFF_BASE_RANGE);
-  int golomb_bits = 0;
+  int cost = coeff_lps[base_range];
+
   if (level <= COEFF_BASE_RANGE + 1 + LF_NUM_BASE_LEVELS)
     *diff += coeff_lps[base_range + COEFF_BASE_RANGE + 1];
+
   if (level >= COEFF_BASE_RANGE + 1 + LF_NUM_BASE_LEVELS) {
     int r = level - COEFF_BASE_RANGE - LF_NUM_BASE_LEVELS;
     if (r < 32) {
-      golomb_bits = golomb_bits_cost[r];
-      *diff += golomb_cost_diff[r];
+      cost += exp_golomb0_bits_cost[r];
+      *diff += exp_golomb0_cost_diff[r];
     } else {
-      golomb_bits = get_golomb_cost_lf(level);
+      cost += av1_cost_literal(get_exp_golomb_length(r - 1, 0));
       *diff += (r & (r - 1)) == 0 ? 1024 : 0;
     }
   }
-  return coeff_lps[base_range] + golomb_bits;
+  return cost;
 }
-
-static INLINE int get_br_cost_with_diff(tran_low_t level, const int *coeff_lps,
-                                        int *diff) {
-  const int base_range = AOMMIN(level - 1 - NUM_BASE_LEVELS, COEFF_BASE_RANGE);
-  int golomb_bits = 0;
-  if (level <= COEFF_BASE_RANGE + 1 + NUM_BASE_LEVELS)
-    *diff += coeff_lps[base_range + COEFF_BASE_RANGE + 1];
-
-  if (level >= COEFF_BASE_RANGE + 1 + NUM_BASE_LEVELS) {
-    int r = level - COEFF_BASE_RANGE - NUM_BASE_LEVELS;
-    if (r < 32) {
-      golomb_bits = golomb_bits_cost[r];
-      *diff += golomb_cost_diff[r];
-    } else {
-      golomb_bits = get_golomb_cost(level);
-      *diff += (r & (r - 1)) == 0 ? 1024 : 0;
-    }
-  }
-
-  return coeff_lps[base_range] + golomb_bits;
-}
-
-static INLINE int get_br_cost(tran_low_t level, const int *coeff_lps) {
-  const int base_range = AOMMIN(level - 1 - NUM_BASE_LEVELS, COEFF_BASE_RANGE);
-  return coeff_lps[base_range] + get_golomb_cost(level);
-}
+#endif  // CONFIG_ADAPTIVE_HR
 
 static INLINE int get_nz_map_ctx(const uint8_t *const levels,
                                  const int coeff_idx, const int bwl,
@@ -451,7 +492,7 @@
     }
     for (int j = 0; j < width; j++) {
       *si++ = (int8_t)(coeff[i * width + j] > 0) ? 1 : -1;
-      *ls++ = (uint8_t)clamp(abs(coeff[i * width + j]), 0, INT8_MAX);
+      *ls++ = (uint8_t)clamp(abs(coeff[i * width + j]), 0, UINT8_MAX);
     }
     // right 4 pad
     for (int j = 0; j < TX_PAD_RIGHT; j++) {
@@ -476,7 +517,7 @@
       *ls++ = 0;
     }
     for (int j = 0; j < width; j++) {
-      *ls++ = (uint8_t)clamp(abs(coeff[i * width + j]), 0, INT8_MAX);
+      *ls++ = (uint8_t)clamp(abs(coeff[i * width + j]), 0, UINT8_MAX);
     }
   }
 }
@@ -491,7 +532,7 @@
 
   for (int i = 0; i < height; i++) {
     for (int j = 0; j < width; j++) {
-      *ls++ = (uint8_t)clamp(abs(coeff[i * width + j]), 0, INT8_MAX);
+      *ls++ = (uint8_t)clamp(abs(coeff[i * width + j]), 0, UINT8_MAX);
     }
     for (int j = 0; j < TX_PAD_HOR; j++) {
       *ls++ = 0;
@@ -705,6 +746,16 @@
   const int16_t *const scan = scan_order->scan;
   const int bwl = get_txb_bwl(tx_size);
 
+#if CONFIG_ADAPTIVE_HR
+  const TX_CLASS tx_class = tx_type_to_class[get_primary_tx_type(tx_type)];
+  const MB_MODE_INFO *mbmi = xd->mi[0];
+  adaptive_hr_info hr_info = { .tx_size = tx_size,
+                               .tx_type = tx_type,
+                               .qindex = xd->qindex[mbmi->segment_id],
+                               .is_inter =
+                                   is_inter_block(mbmi, xd->tree_type) };
+#endif  // CONFIG_ADAPTIVE_HR
+
   DECLARE_ALIGNED(16, int8_t, coeff_contexts[MAX_TX_SQUARE]);
   const int txb_offset =
       x->mbmi_ext_frame->cb_offset[plane] / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
@@ -747,8 +798,18 @@
     if (level) {
       int idtx_sign_ctx = get_sign_ctx_skip(signs, levels, pos, bwl);
       aom_write_symbol(w, sign, ec_ctx->idtx_sign_cdf[idtx_sign_ctx], 2);
-      if (level > COEFF_BASE_RANGE + NUM_BASE_LEVELS)
-        write_golomb(w, level - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS);
+      if (level > COEFF_BASE_RANGE + NUM_BASE_LEVELS) {
+#if CONFIG_ADAPTIVE_HR
+        bool is_eob = c == (eob - 1);
+        hr_info.is_dc = (c == 0);
+        hr_info.is_eob = is_eob;
+        hr_info.context = get_hr_ctx_skip(levels, pos, bwl, is_eob, tx_class);
+        write_adaptive_hr(w, level - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS,
+                          &hr_info);
+#else
+        write_exp_golomb(w, level - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS, 0);
+#endif  // CONFIG_ADAPTIVE_HR
+      }
     }
   }
 }
@@ -843,6 +904,15 @@
 
   const int bwl = get_txb_bwl(tx_size);
 
+#if CONFIG_ADAPTIVE_HR
+  const MB_MODE_INFO *mbmi = xd->mi[0];
+  adaptive_hr_info hr_info = { .tx_size = tx_size,
+                               .tx_type = tx_type,
+                               .qindex = xd->qindex[mbmi->segment_id],
+                               .is_inter =
+                                   is_inter_block(mbmi, xd->tree_type) };
+#endif  // CONFIG_ADAPTIVE_HR
+
   bool enable_parity_hiding = cm->features.allow_parity_hiding &&
                               !xd->lossless[xd->mi[0]->segment_id] &&
                               plane == PLANE_TYPE_Y &&
@@ -1039,19 +1109,54 @@
       }
       if (is_hidden && c == 0) {
         int q_index = level >> 1;
-        if (q_index > COEFF_BASE_RANGE + NUM_BASE_LEVELS)
-          write_golomb(w, q_index - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS);
+        if (q_index > COEFF_BASE_RANGE + NUM_BASE_LEVELS) {
+#if CONFIG_ADAPTIVE_HR
+          bool is_eob = c == (eob - 1);
+          hr_info.is_dc = (c == 0);
+          hr_info.is_eob = is_eob;
+          // Use context divided by 2 since the coefficient is also divided by 2
+          hr_info.context =
+              get_hr_ctx(levels, scan[0], bwl, is_eob, tx_class) >> 1;
+          write_adaptive_hr(w, q_index - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS,
+                            &hr_info);
+#else
+          write_exp_golomb(w, q_index - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS,
+                           0);
+#endif  // CONFIG_ADAPTIVE_HR
+        }
       } else {
         const int pos = scan[c];
         const int row = pos >> bwl;
         const int col = pos - (row << bwl);
         int limits = get_lf_limits(row, col, tx_class, plane);
         if (limits) {
-          if (level > COEFF_BASE_RANGE + LF_NUM_BASE_LEVELS)
-            write_golomb(w, level - COEFF_BASE_RANGE - 1 - LF_NUM_BASE_LEVELS);
+          if (level > COEFF_BASE_RANGE + LF_NUM_BASE_LEVELS) {
+#if CONFIG_ADAPTIVE_HR
+            bool is_eob = c == (eob - 1);
+            hr_info.is_dc = (c == 0);
+            hr_info.is_eob = is_eob;
+            hr_info.context = get_hr_ctx(levels, pos, bwl, is_eob, tx_class);
+            write_adaptive_hr(
+                w, level - COEFF_BASE_RANGE - 1 - LF_NUM_BASE_LEVELS, &hr_info);
+#else
+            write_exp_golomb(
+                w, level - COEFF_BASE_RANGE - 1 - LF_NUM_BASE_LEVELS, 0);
+#endif  // CONFIG_ADAPTIVE_HR
+          }
         } else {
-          if (level > COEFF_BASE_RANGE + NUM_BASE_LEVELS)
-            write_golomb(w, level - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS);
+          if (level > COEFF_BASE_RANGE + NUM_BASE_LEVELS) {
+#if CONFIG_ADAPTIVE_HR
+            bool is_eob = c == (eob - 1);
+            hr_info.is_dc = (c == 0);
+            hr_info.is_eob = is_eob;
+            hr_info.context = get_hr_ctx(levels, pos, bwl, is_eob, tx_class);
+            write_adaptive_hr(w, level - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS,
+                              &hr_info);
+#else
+            write_exp_golomb(w, level - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS,
+                             0);
+#endif  // CONFIG_ADAPTIVE_HR
+          }
         }
       }
     }
@@ -1308,6 +1413,7 @@
   int8_t signs_buf[TX_PAD_2D];
   int8_t *const signs = set_signs(signs_buf, width);
   av1_txb_init_levels_signs(qcoeff, width, height, levels_buf, signs_buf);
+
   const int bob_code = p->bobs[block];
   const int bob = av1_get_max_eob(tx_size) - bob_code;
 #if !CONFIG_TX_SKIP_FLAG_MODE_DEP_CTX
@@ -1319,6 +1425,15 @@
   cost += get_tx_type_cost(x, xd, plane, tx_size, tx_type, reduced_tx_set_used,
                            eob, bob_code, is_fsc);
 
+#if CONFIG_ADAPTIVE_HR
+  const TX_CLASS tx_class = tx_type_to_class[get_primary_tx_type(tx_type)];
+  adaptive_hr_info hr_info = { .tx_size = tx_size,
+                               .tx_type = tx_type,
+                               .qindex = xd->qindex[mbmi->segment_id],
+                               .is_inter =
+                                   is_inter_block(mbmi, xd->tree_type) };
+#endif  // CONFIG_ADAPTIVE_HR
+
   const int eob_multi_size = txsize_log2_minus4[tx_size];
   const LV_MAP_EOB_COST *const eob_costs =
       &x->coeff_costs.eob_costs[eob_multi_size][PLANE_TYPE_Y];
@@ -1350,7 +1465,15 @@
     if (v) {
       if (level > NUM_BASE_LEVELS) {
         const int ctx = get_br_ctx_skip(levels, pos, bwl);
+#if CONFIG_ADAPTIVE_HR
+        bool is_eob = c == (eob - 1);
+        hr_info.is_dc = (c == 0);
+        hr_info.is_eob = is_eob;
+        hr_info.context = get_hr_ctx_skip(levels, pos, bwl, is_eob, tx_class);
+        cost += get_br_cost(level, lps_cost[ctx], &hr_info);
+#else
         cost += get_br_cost(level, lps_cost[ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
       }
     }
   }
@@ -1415,6 +1538,15 @@
   int cost = coeff_costs->txb_skip_cost[txb_skip_ctx][0];
 #endif  // CONFIG_CONTEXT_DERIVATION
 
+#if CONFIG_ADAPTIVE_HR
+  const MB_MODE_INFO *mbmi = xd->mi[0];
+  adaptive_hr_info hr_info = { .tx_size = tx_size,
+                               .tx_type = tx_type,
+                               .qindex = xd->qindex[mbmi->segment_id],
+                               .is_inter =
+                                   is_inter_block(mbmi, xd->tree_type) };
+#endif  // CONFIG_ADAPTIVE_HR
+
   av1_txb_init_levels(qcoeff, width, height, levels);
 
   const int bob_code = p->bobs[block];
@@ -1463,12 +1595,28 @@
       if (limits) {
         if (level > LF_NUM_BASE_LEVELS) {
           const int ctx = get_br_ctx_lf_eob(pos, tx_class);
+#if CONFIG_ADAPTIVE_HR
+          bool is_eob = c == (eob - 1);
+          hr_info.is_dc = (c == 0);
+          hr_info.is_eob = is_eob;
+          hr_info.context = get_hr_ctx(levels, pos, bwl, is_eob, tx_class);
+          cost += get_br_lf_cost(level, lps_lf_cost[ctx], &hr_info);
+#else
           cost += get_br_lf_cost(level, lps_lf_cost[ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
         }
       } else {
         if (level > NUM_BASE_LEVELS) {
           const int ctx = 7; /* get_lf_ctx_eob */
+#if CONFIG_ADAPTIVE_HR
+          bool is_eob = c == (eob - 1);
+          hr_info.is_dc = (c == 0);
+          hr_info.is_eob = is_eob;
+          hr_info.context = get_hr_ctx(levels, pos, bwl, is_eob, tx_class);
+          cost += get_br_cost(level, lps_cost[ctx], &hr_info);
+#else
           cost += get_br_cost(level, lps_cost[ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
         }
       }
       if (c) {
@@ -1530,12 +1678,28 @@
       if (limits) {
         if (level > LF_NUM_BASE_LEVELS) {
           const int ctx = get_br_lf_ctx(levels, pos, bwl, tx_class);
+#if CONFIG_ADAPTIVE_HR
+          bool is_eob = c == (eob - 1);
+          hr_info.is_dc = (c == 0);
+          hr_info.is_eob = is_eob;
+          hr_info.context = get_hr_ctx(levels, pos, bwl, is_eob, tx_class);
+          cost += get_br_lf_cost(level, lps_lf_cost[ctx], &hr_info);
+#else
           cost += get_br_lf_cost(level, lps_lf_cost[ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
         }
       } else {
         if (level > NUM_BASE_LEVELS) {
           const int ctx = get_br_ctx(levels, pos, bwl, tx_class);
+#if CONFIG_ADAPTIVE_HR
+          bool is_eob = c == (eob - 1);
+          hr_info.is_dc = (c == 0);
+          hr_info.is_eob = is_eob;
+          hr_info.context = get_hr_ctx(levels, pos, bwl, is_eob, tx_class);
+          cost += get_br_cost(level, lps_cost[ctx], &hr_info);
+#else
           cost += get_br_cost(level, lps_cost[ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
         }
       }
     }
@@ -1560,7 +1724,17 @@
 
       if (q_index > NUM_BASE_LEVELS) {
         const int ctx = get_par_br_ctx(levels, pos, bwl, tx_class);
+#if CONFIG_ADAPTIVE_HR
+        bool is_eob = c == (eob - 1);
+        hr_info.is_dc = (c == 0);
+        hr_info.is_eob = is_eob;
+        // Use context divided by 2 since the coefficient is also divided by 2
+        hr_info.context = get_hr_ctx(levels, pos, bwl, is_eob, tx_class) >> 1;
+        cost +=
+            get_br_cost(q_index, coeff_costs_ph->lps_ph_cost[ctx], &hr_info);
+#else
         cost += get_br_cost(q_index, coeff_costs_ph->lps_ph_cost[ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
       }
     }
     return cost;
@@ -1597,12 +1771,28 @@
       if (limits) {
         if (level > LF_NUM_BASE_LEVELS) {
           const int ctx = get_br_lf_ctx(levels, pos, bwl, tx_class);
+#if CONFIG_ADAPTIVE_HR
+          bool is_eob = c == (eob - 1);
+          hr_info.is_dc = (c == 0);
+          hr_info.is_eob = is_eob;
+          hr_info.context = get_hr_ctx(levels, pos, bwl, is_eob, tx_class);
+          cost += get_br_lf_cost(level, lps_lf_cost[ctx], &hr_info);
+#else
           cost += get_br_lf_cost(level, lps_lf_cost[ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
         }
       } else {
         if (level > NUM_BASE_LEVELS) {
           const int ctx = get_br_ctx(levels, pos, bwl, tx_class);
+#if CONFIG_ADAPTIVE_HR
+          bool is_eob = c == (eob - 1);
+          hr_info.is_dc = (c == 0);
+          hr_info.is_eob = is_eob;
+          hr_info.context = get_hr_ctx(levels, pos, bwl, is_eob, tx_class);
+          cost += get_br_cost(level, lps_cost[ctx], &hr_info);
+#else
           cost += get_br_cost(level, lps_cost[ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
         }
       }
     }
@@ -1866,7 +2056,12 @@
 static AOM_FORCE_INLINE int get_two_coeff_cost_simple(
     int plane, int ci, tran_low_t abs_qc, int coeff_ctx,
     const LV_MAP_COEFF_COST *txb_costs, int bwl, TX_CLASS tx_class,
-    const uint8_t *levels, int *cost_low) {
+    const uint8_t *levels, int *cost_low
+#if CONFIG_ADAPTIVE_HR
+    ,
+    adaptive_hr_info *hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+) {
   // this simple version assumes the coeff's scan_idx is not DC (scan_idx != 0)
   // and not the last (scan_idx != eob - 1)
   assert(ci > 0);
@@ -1925,16 +2120,32 @@
       if (abs_qc > LF_NUM_BASE_LEVELS) {
         const int br_ctx = get_br_lf_ctx(levels, ci, bwl, tx_class);
         int brcost_diff = 0;
+#if CONFIG_ADAPTIVE_HR
+        hr_info->is_dc = false;
+        hr_info->is_eob = false;
+        hr_info->context = get_hr_ctx(levels, ci, bwl, false, tx_class);
+        cost += get_br_lf_cost_with_diff(abs_qc, txb_costs->lps_lf_cost[br_ctx],
+                                         &brcost_diff, hr_info);
+#else
         cost += get_br_lf_cost_with_diff(abs_qc, txb_costs->lps_lf_cost[br_ctx],
                                          &brcost_diff);
+#endif  // CONFIG_ADAPTIVE_HR
         diff += brcost_diff;
       }
     } else {
       if (abs_qc > NUM_BASE_LEVELS) {
         const int br_ctx = get_br_ctx(levels, ci, bwl, tx_class);
         int brcost_diff = 0;
+#if CONFIG_ADAPTIVE_HR
+        hr_info->is_dc = false;
+        hr_info->is_eob = false;
+        hr_info->context = get_hr_ctx(levels, ci, bwl, false, tx_class);
+        cost += get_br_cost_with_diff(abs_qc, txb_costs->lps_cost[br_ctx],
+                                      &brcost_diff, hr_info);
+#else
         cost += get_br_cost_with_diff(abs_qc, txb_costs->lps_cost[br_ctx],
                                       &brcost_diff);
+#endif  // CONFIG_ADAPTIVE_HR
         diff += brcost_diff;
       }
     }
@@ -1953,7 +2164,13 @@
                                      int32_t *tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
                                      ,
-                                     int plane) {
+                                     int plane
+#if CONFIG_ADAPTIVE_HR
+                                     ,
+                                     const uint8_t *levels,
+                                     adaptive_hr_info *hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+) {
   int cost = 0;
   const int row = ci >> bwl;
   const int col = ci - (row << bwl);
@@ -1987,14 +2204,27 @@
     }
     if (limits) {
       if (abs_qc > LF_NUM_BASE_LEVELS) {
-        int br_ctx;
-        br_ctx = get_br_ctx_lf_eob(ci, tx_class);
+        int br_ctx = get_br_ctx_lf_eob(ci, tx_class);
+#if CONFIG_ADAPTIVE_HR
+        hr_info->is_eob = true;
+        hr_info->is_dc = (ci == 0);
+        hr_info->context = get_hr_ctx(levels, ci, bwl, true, tx_class);
+        cost += get_br_lf_cost(abs_qc, txb_costs->lps_lf_cost[br_ctx], hr_info);
+#else
         cost += get_br_lf_cost(abs_qc, txb_costs->lps_lf_cost[br_ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
       }
     } else {
       if (abs_qc > NUM_BASE_LEVELS) {
         int br_ctx = 7; /* get_br_ctx_eob */
+#if CONFIG_ADAPTIVE_HR
+        hr_info->is_eob = true;
+        hr_info->is_dc = (ci == 0);
+        hr_info->context = get_hr_ctx(levels, ci, bwl, true, tx_class);
+        cost += get_br_cost(abs_qc, txb_costs->lps_cost[br_ctx], hr_info);
+#else
         cost += get_br_cost(abs_qc, txb_costs->lps_cost[br_ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
       }
     }
   }
@@ -2012,7 +2242,12 @@
                                          int32_t *tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
                                          ,
-                                         int plane) {
+                                         int plane
+#if CONFIG_ADAPTIVE_HR
+                                         ,
+                                         adaptive_hr_info *hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+) {
   int cost = 0;
   if (is_last) {
     const int row = ci >> bwl;
@@ -2067,7 +2302,15 @@
           br_ctx = get_br_ctx_lf_eob(ci, tx_class);
         else
           br_ctx = get_br_lf_ctx(levels, ci, bwl, tx_class);
+
+#if CONFIG_ADAPTIVE_HR
+        hr_info->is_dc = (ci == 0);
+        hr_info->is_eob = is_last;
+        hr_info->context = get_hr_ctx(levels, ci, bwl, is_last, tx_class);
+        cost += get_br_lf_cost(abs_qc, txb_costs->lps_lf_cost[br_ctx], hr_info);
+#else
         cost += get_br_lf_cost(abs_qc, txb_costs->lps_lf_cost[br_ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
       }
     } else {
       if (abs_qc > NUM_BASE_LEVELS) {
@@ -2076,7 +2319,15 @@
           br_ctx = 0; /*get_br_ctx_eob*/
         else
           br_ctx = get_br_ctx(levels, ci, bwl, tx_class);
+
+#if CONFIG_ADAPTIVE_HR
+        hr_info->is_dc = (ci == 0);
+        hr_info->is_eob = is_last;
+        hr_info->context = get_hr_ctx(levels, ci, bwl, is_last, tx_class);
+        cost += get_br_cost(abs_qc, txb_costs->lps_cost[br_ctx], hr_info);
+#else
         cost += get_br_cost(abs_qc, txb_costs->lps_cost[br_ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
       }
     }
   }
@@ -2111,7 +2362,12 @@
     int32_t *tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
     ,
-    int plane, coeff_info *coef_info, bool enable_parity_hiding) {
+    int plane, coeff_info *coef_info, bool enable_parity_hiding
+#if CONFIG_ADAPTIVE_HR
+    ,
+    adaptive_hr_info *hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+) {
   const int dqv = get_dqv(dequant, scan[si], iqmatrix);
   const int ci = scan[si];
   const tran_low_t qc = qcoeff[ci];
@@ -2142,7 +2398,12 @@
                                tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
                                ,
-                               plane);
+                               plane
+#if CONFIG_ADAPTIVE_HR
+                               ,
+                               hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+        );
     const int64_t rd = RDCOST(rdmult, rate, dist);
 
     tran_low_t qc_low, dqc_low;
@@ -2172,14 +2433,19 @@
                                  tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
                                  ,
-                                 plane);
+                                 plane
+#if CONFIG_ADAPTIVE_HR
+                                 ,
+                                 hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+          );
     }
 
     rd_low = RDCOST(rdmult, rate_low, dist_low);
     if (rd_low < rd) {
       qcoeff[ci] = qc_low;
       dqcoeff[ci] = dqc_low;
-      levels[get_padded_idx(ci, bwl)] = AOMMIN(abs_qc_low, INT8_MAX);
+      levels[get_padded_idx(ci, bwl)] = AOMMIN(abs_qc_low, UINT8_MAX);
       *accu_rate += rate_low;
       *accu_dist += dist_low - dist0;
       if (enable_parity_hiding)
@@ -2201,7 +2467,12 @@
     const LV_MAP_COEFF_COST *txb_costs, const tran_low_t *tcoeff,
     tran_low_t *qcoeff, tran_low_t *dqcoeff, uint8_t *levels,
     const qm_val_t *iqmatrix, coeff_info *coef_info, bool enable_parity_hiding,
-    int plane) {
+    int plane
+#if CONFIG_ADAPTIVE_HR
+    ,
+    adaptive_hr_info *hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+) {
   const int dqv = get_dqv(dequant, scan[si], iqmatrix);
   (void)eob;
   // this simple version assumes the coeff's scan_idx is not DC (scan_idx != 0)
@@ -2238,7 +2509,13 @@
     int rate_low = 0;
     const int rate =
         get_two_coeff_cost_simple(plane, ci, abs_qc, coeff_ctx, txb_costs, bwl,
-                                  tx_class, levels, &rate_low);
+                                  tx_class, levels, &rate_low
+#if CONFIG_ADAPTIVE_HR
+                                  ,
+                                  hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+        );
+
     if (abs_dqc < abs_tqc) {
       *accu_rate += rate;
       return;
@@ -2263,7 +2540,7 @@
                        rate, false, coef_info, si);
       qcoeff[ci] = qc_low;
       dqcoeff[ci] = dqc_low;
-      levels[get_padded_idx(ci, bwl)] = AOMMIN(abs_qc_low, INT8_MAX);
+      levels[get_padded_idx(ci, bwl)] = AOMMIN(abs_qc_low, UINT8_MAX);
       *accu_rate += rate_low;
     } else {
       *accu_rate += rate;
@@ -2292,7 +2569,12 @@
     int32_t *tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
     ,
-    int plane, coeff_info *coef_info, bool enable_parity_hiding) {
+    int plane, coeff_info *coef_info, bool enable_parity_hiding
+#if CONFIG_ADAPTIVE_HR
+    ,
+    adaptive_hr_info *hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+) {
   const int bwl = get_txb_bwl(tx_size);
   const int height = get_txb_high(tx_size);
   const int dqv = get_dqv(dequant, scan[si], iqmatrix);
@@ -2337,7 +2619,12 @@
                                tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
                                ,
-                               plane);
+                               plane
+#if CONFIG_ADAPTIVE_HR
+                               ,
+                               hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+        );
     int64_t rd = RDCOST(rdmult, *accu_rate + rate, *accu_dist + dist);
 
     tran_low_t qc_low, dqc_low;
@@ -2366,7 +2653,12 @@
                                  tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
                                  ,
-                                 plane);
+                                 plane
+#if CONFIG_ADAPTIVE_HR
+                                 ,
+                                 hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+          );
       rd_low = RDCOST(rdmult, *accu_rate + rate_low, *accu_dist + dist_low);
     }
     int rate_up_backup = rate;
@@ -2388,7 +2680,12 @@
                                           tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
                                           ,
-                                          plane);
+                                          plane
+#if CONFIG_ADAPTIVE_HR
+                                          ,
+                                          levels, hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+                       );
     int64_t dist_new_eob = dist;
     int64_t rd_new_eob = RDCOST(rdmult, rate_coeff_eob, dist_new_eob);
     int rateeobup = rate_coeff_eob;
@@ -2403,7 +2700,12 @@
                                             tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
                                             ,
-                                            plane);
+                                            plane
+#if CONFIG_ADAPTIVE_HR
+                                            ,
+                                            levels, hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+                         );
       const int64_t dist_new_eob_low = dist_low;
       const int64_t rd_new_eob_low =
           RDCOST(rdmult, rate_coeff_eob_low, dist_new_eob_low);
@@ -2451,7 +2753,7 @@
     if (lower_level) {
       qcoeff[ci] = qc_low;
       dqcoeff[ci] = dqc_low;
-      levels[get_padded_idx(ci, bwl)] = AOMMIN(abs_qc_low, INT8_MAX);
+      levels[get_padded_idx(ci, bwl)] = AOMMIN(abs_qc_low, UINT8_MAX);
     }
     if (qcoeff[ci]) {
       nz_ci[*nz_num] = ci;
@@ -2491,6 +2793,10 @@
                                       ,
                                       int plane
 #endif  // CONFIG_CHROMA_TX_COEFF_CODING
+#if CONFIG_ADAPTIVE_HR
+                                      ,
+                                      adaptive_hr_info *hr_info
+#endif  // CONFIG_ADAPTIVE_HR
 ) {
   tran_low_t abslevel = abs(level), q_index = abslevel >> 1;
   int sign = level < 0;
@@ -2515,14 +2821,25 @@
                                  0
 #endif  // CONFIG_CONTEXT_DERIVATION
                                  ,
-                                 0);
+                                 0
+#if CONFIG_ADAPTIVE_HR
+                                 ,
+                                 hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+  );
 
   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) {
-    rate_ph += get_br_cost(
-        q_index,
-        txb_costs_ph->lps_ph_cost[get_par_br_ctx(levels, pos, bwl, tx_class)]);
+    int br_ctx = get_par_br_ctx(levels, pos, bwl, tx_class);
+#if CONFIG_ADAPTIVE_HR
+    hr_info->is_eob = false;
+    hr_info->is_dc = (pos == 0);
+    hr_info->context = get_hr_ctx(levels, pos, bwl, false, tx_class);
+    rate_ph += get_br_cost(q_index, txb_costs_ph->lps_ph_cost[br_ctx], hr_info);
+#else
+    rate_ph += get_br_cost(q_index, txb_costs_ph->lps_ph_cost[br_ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
   }
   if (abslevel) rate_ph += txb_costs->dc_sign_cost[dc_sign_ctx][sign];
   return rate_ph - *rate;
@@ -2544,7 +2861,12 @@
     const LV_MAP_COEFF_COST *txb_costs_ph, int dc_sign_ctx, TX_CLASS tx_class,
     uint8_t *levels, const int bwl, const int64_t rdmult,
     const int32_t *dequant, const qm_val_t *iqmatrix, tune_cand *t_cand,
-    int rate_cur) {
+    int rate_cur
+#if CONFIG_ADAPTIVE_HR
+    ,
+    adaptive_hr_info *hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+) {
   const int dqv = get_dqv(dequant, pos, iqmatrix);
   tran_low_t abslevel = abs(qcoeff), abstqc = abs(tcoeff);
   int64_t dist = get_coeff_dist(tcoeff, dqcoeff, shift);
@@ -2564,9 +2886,16 @@
   if (abslevel_cand) {
     rate_cand += txb_costs->dc_sign_cost[dc_sign_ctx][tcoeff < 0];
     if (q_index > NUM_BASE_LEVELS) {
+      int br_ctx = get_par_br_ctx(levels, pos, bwl, tx_class);
+#if CONFIG_ADAPTIVE_HR
+      hr_info->is_eob = false;
+      hr_info->is_dc = (pos == 0);
+      hr_info->context = get_hr_ctx(levels, pos, bwl, 0, tx_class);
       rate_cand +=
-          get_br_cost(q_index, txb_costs_ph->lps_ph_cost[get_par_br_ctx(
-                                   levels, pos, bwl, tx_class)]);
+          get_br_cost(q_index, txb_costs_ph->lps_ph_cost[br_ctx], hr_info);
+#else
+      rate_cand += get_br_cost(q_index, txb_costs_ph->lps_ph_cost[br_ctx]);
+#endif  // CONFIG_ADAPTIVE_HR
     }
   }
   int64_t cost_cand = RDCOST(rdmult, rate_cand, dist_cand);
@@ -2704,6 +3033,10 @@
     ,
     int plane
 #endif  // CONFIG_CHROMA_TX_COEFF_CODING
+#if CONFIG_ADAPTIVE_HR
+    ,
+    adaptive_hr_info *hr_info
+#endif  // CONFIG_ADAPTIVE_HR
 ) {
   int nzsbb = 0, sum_abs1 = 0;
   for (int scan_idx = eob - 1; scan_idx > 0; --scan_idx) {
@@ -2728,6 +3061,10 @@
                 ,
                 plane
 #endif  // CONFIG_CHROMA_TX_COEFF_CODING
+#if CONFIG_ADAPTIVE_HR
+                ,
+                hr_info
+#endif  // CONFIG_ADAPTIVE_HR
       );
 
   if (!needtune && nzsbb >= PHTHRESH) {
@@ -2742,7 +3079,12 @@
   if (nzsbb >= PHTHRESH) {
     cost_hide_par(qcoeff[hidepos], dqcoeff[hidepos], tcoeff[hidepos], shift,
                   txb_costs, hidepos, txb_costs_ph, dc_sign_ctx, tx_class,
-                  levels, bwl, rdmult, dequant, iqmatrix, &t_cand_dc, rate_cur);
+                  levels, bwl, rdmult, dequant, iqmatrix, &t_cand_dc, rate_cur
+#if CONFIG_ADAPTIVE_HR
+                  ,
+                  hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+    );
   }
 
   // we change the level candidates to check the cost change.
@@ -2768,7 +3110,8 @@
     qcoeff[tune_pos] = best->qcoeff;
     dqcoeff[tune_pos] = best->dqcoeff;
     *accu_rate += best->rate;
-    levels[get_padded_idx(tune_pos, bwl)] = AOMMIN(abs(best->qcoeff), INT8_MAX);
+    levels[get_padded_idx(tune_pos, bwl)] =
+        AOMMIN(abs(best->qcoeff), UINT8_MAX);
 
     return true;
   }
@@ -2828,6 +3171,14 @@
     coef_info[scan_idx].upround = false;
   }
 
+#if CONFIG_ADAPTIVE_HR
+  adaptive_hr_info hr_info = { .tx_size = tx_size,
+                               .tx_type = tx_type,
+                               .qindex = xd->qindex[mbmi->segment_id],
+                               .is_inter =
+                                   is_inter_block(mbmi, xd->tree_type) };
+#endif  // CONFIG_ADAPTIVE_HR
+
   const int rshift =
       (sharpness +
        (cpi->oxcf.q_cfg.aq_mode == VARIANCE_AQ && mbmi->segment_id < 4
@@ -2899,7 +3250,12 @@
                          xd->tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
                          ,
-                         plane, coef_info, enable_parity_hiding);
+                         plane, coef_info, enable_parity_hiding
+#if CONFIG_ADAPTIVE_HR
+                         ,
+                         &hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+    );
     --si;
   } else {
     assert(abs_qc == 1);
@@ -2912,7 +3268,12 @@
                            xd->tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
                            ,
-                           plane);
+                           plane
+#if CONFIG_ADAPTIVE_HR
+                           ,
+                           levels, &hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+        );
     const tran_low_t tqc = tcoeff[ci];
     const tran_low_t dqc = dqcoeff[ci];
     const int64_t dist = get_coeff_dist(tqc, dqc, shift);
@@ -2933,7 +3294,12 @@
                      xd->tmp_sign
 #endif
                      ,
-                     plane, coef_info, enable_parity_hiding);
+                     plane, coef_info, enable_parity_hiding
+#if CONFIG_ADAPTIVE_HR
+                     ,
+                     &hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+    );
   }
   if (si == -1 && nz_num <= max_nz_num) {
     update_skip(&accu_rate, accu_dist, &eob, nz_num, nz_ci, rdmult, skip_cost,
@@ -2943,8 +3309,12 @@
   for (; si >= 1; --si) {
     update_coeff_simple(&accu_rate, si, eob, tx_class, bwl, rdmult, shift,
                         dequant, scan, txb_costs, tcoeff, qcoeff, dqcoeff,
-                        levels, iqmatrix, coef_info, enable_parity_hiding,
-                        plane);
+                        levels, iqmatrix, coef_info, enable_parity_hiding, plane
+#if CONFIG_ADAPTIVE_HR
+                        ,
+                        &hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+    );
   }
 
   // DC position
@@ -2960,7 +3330,12 @@
                          xd->tmp_sign
 #endif  // CONFIG_CONTEXT_DERIVATION
                          ,
-                         plane, coef_info, enable_parity_hiding);
+                         plane, coef_info, enable_parity_hiding
+#if CONFIG_ADAPTIVE_HR
+                         ,
+                         &hr_info
+#endif  // CONFIG_ADAPTIVE_HR
+    );
   }
 
   if (enable_parity_hiding) {
@@ -2971,6 +3346,10 @@
                    ,
                    plane
 #endif  // CONFIG_CHROMA_TX_COEFF_CODING
+#if CONFIG_ADAPTIVE_HR
+                   ,
+                   &hr_info
+#endif  // CONFIG_ADAPTIVE_HR
     );
   }
 
diff --git a/av1/encoder/x86/encodetxb_avx2.c b/av1/encoder/x86/encodetxb_avx2.c
index 44174c0..b241437 100644
--- a/av1/encoder/x86/encodetxb_avx2.c
+++ b/av1/encoder/x86/encodetxb_avx2.c
@@ -170,7 +170,7 @@
       const __m256i c1 = yy_loadu_256(cf + 8);
       const __m256i c0c1 = _mm256_packs_epi32(c0, c1);
       const __m256i abs01 = _mm256_abs_epi16(c0c1);
-      const __m256i abs01_8 = _mm256_packs_epi16(y_zeros, abs01);
+      const __m256i abs01_8 = _mm256_packus_epi16(y_zeros, abs01);
       const __m256i sig01 = _mm256_sign_epi16(one16, c0c1);
       const __m256i sig01_8 = _mm256_packs_epi16(sig01, y_zeros);
       const __m256i res_ = _mm256_shuffle_epi32(abs01_8, 0xd8);
@@ -194,7 +194,7 @@
       const __m256i coeffCD = _mm256_packs_epi32(coeffC, coeffD);
       const __m256i absAB = _mm256_abs_epi16(coeffAB);
       const __m256i absCD = _mm256_abs_epi16(coeffCD);
-      const __m256i absABCD = _mm256_packs_epi16(absAB, absCD);
+      const __m256i absABCD = _mm256_packus_epi16(absAB, absCD);
       const __m256i res_ = _mm256_permute4x64_epi64(absABCD, 0xd8);
       const __m256i res = _mm256_shuffle_epi32(res_, 0xd8);
       const __m128i res0 = _mm256_castsi256_si128(res);
@@ -237,7 +237,7 @@
       const __m256i coeffCD = _mm256_packs_epi32(coeffC, coeffD);
       const __m256i absAB = _mm256_abs_epi16(coeffAB);
       const __m256i absCD = _mm256_abs_epi16(coeffCD);
-      const __m256i absABCD = _mm256_packs_epi16(absAB, absCD);
+      const __m256i absABCD = _mm256_packus_epi16(absAB, absCD);
       const __m256i res_ = _mm256_permute4x64_epi64(absABCD, 0xd8);
       const __m256i res = _mm256_shuffle_epi32(res_, 0xd8);
       const __m256i sigAB = _mm256_sign_epi16(one16, coeffAB);
@@ -269,7 +269,7 @@
       const __m256i coeffCD = _mm256_packs_epi32(coeffC, coeffD);
       const __m256i absAB = _mm256_abs_epi16(coeffAB);
       const __m256i absCD = _mm256_abs_epi16(coeffCD);
-      const __m256i absABCD = _mm256_packs_epi16(absAB, absCD);
+      const __m256i absABCD = _mm256_packus_epi16(absAB, absCD);
       const __m256i res_ = _mm256_permute4x64_epi64(absABCD, 0xd8);
       const __m256i res = _mm256_shuffle_epi32(res_, 0xd8);
       const __m256i sigAB = _mm256_sign_epi16(one16, coeffAB);
@@ -311,7 +311,7 @@
       const __m256i c0 = yy_loadu_256(cf);
       const __m256i c1 = yy_loadu_256(cf + 8);
       const __m256i abs01 = _mm256_abs_epi16(_mm256_packs_epi32(c0, c1));
-      const __m256i abs01_8 = _mm256_packs_epi16(abs01, y_zeros);
+      const __m256i abs01_8 = _mm256_packus_epi16(abs01, y_zeros);
       const __m256i res_ = _mm256_shuffle_epi32(abs01_8, 0xd8);
       const __m256i res = _mm256_permute4x64_epi64(res_, 0xd8);
       yy_storeu_256(ls, res);
@@ -329,7 +329,7 @@
       const __m256i coeffCD = _mm256_packs_epi32(coeffC, coeffD);
       const __m256i absAB = _mm256_abs_epi16(coeffAB);
       const __m256i absCD = _mm256_abs_epi16(coeffCD);
-      const __m256i absABCD = _mm256_packs_epi16(absAB, absCD);
+      const __m256i absABCD = _mm256_packus_epi16(absAB, absCD);
       const __m256i res_ = _mm256_permute4x64_epi64(absABCD, 0xd8);
       const __m256i res = _mm256_shuffle_epi32(res_, 0xd8);
       const __m128i res0 = _mm256_castsi256_si128(res);
@@ -356,7 +356,7 @@
       const __m256i coeffCD = _mm256_packs_epi32(coeffC, coeffD);
       const __m256i absAB = _mm256_abs_epi16(coeffAB);
       const __m256i absCD = _mm256_abs_epi16(coeffCD);
-      const __m256i absABCD = _mm256_packs_epi16(absAB, absCD);
+      const __m256i absABCD = _mm256_packus_epi16(absAB, absCD);
       const __m256i res_ = _mm256_permute4x64_epi64(absABCD, 0xd8);
       const __m256i res = _mm256_shuffle_epi32(res_, 0xd8);
       xx_storeu_128(ls, _mm256_castsi256_si128(res));
@@ -377,7 +377,7 @@
       const __m256i coeffCD = _mm256_packs_epi32(coeffC, coeffD);
       const __m256i absAB = _mm256_abs_epi16(coeffAB);
       const __m256i absCD = _mm256_abs_epi16(coeffCD);
-      const __m256i absABCD = _mm256_packs_epi16(absAB, absCD);
+      const __m256i absABCD = _mm256_packus_epi16(absAB, absCD);
       const __m256i res_ = _mm256_permute4x64_epi64(absABCD, 0xd8);
       const __m256i res = _mm256_shuffle_epi32(res_, 0xd8);
       yy_storeu_256(ls, res);
diff --git a/av1/encoder/x86/encodetxb_sse4.c b/av1/encoder/x86/encodetxb_sse4.c
index d1b2dfe..8a7efcb 100644
--- a/av1/encoder/x86/encodetxb_sse4.c
+++ b/av1/encoder/x86/encodetxb_sse4.c
@@ -61,7 +61,7 @@
       const __m128i absZA = _mm_abs_epi16(coeffZA);
       const __m128i coeffZB = _mm_packs_epi32(zeros, coeffB);
       const __m128i absZB = _mm_abs_epi16(coeffZB);
-      const __m128i coeffAB = _mm_packs_epi16(absZA, absZB);
+      const __m128i coeffAB = _mm_packus_epi16(absZA, absZB);
       xx_storeu_128(ls, coeffAB);
       ls += ((stride) << 1);
       cf += (width << 1);
@@ -75,7 +75,7 @@
       const __m128i coeffB = xx_loadu_128(cf + 4);
       const __m128i coeffAB = _mm_packs_epi32(coeffA, coeffB);
       const __m128i absAB = _mm_abs_epi16(coeffAB);
-      const __m128i absAB8 = _mm_packs_epi16(absAB, zeros);
+      const __m128i absAB8 = _mm_packus_epi16(absAB, zeros);
       xx_storeu_128(ls, absAB8);
       ls += stride - TX_PAD_LEFT;
       cf += width;
@@ -95,7 +95,7 @@
         const __m128i coeffCD = _mm_packs_epi32(coeffC, coeffD);
         const __m128i absAB = _mm_abs_epi16(coeffAB);
         const __m128i absCD = _mm_abs_epi16(coeffCD);
-        const __m128i absABCD = _mm_packs_epi16(absAB, absCD);
+        const __m128i absABCD = _mm_packus_epi16(absAB, absCD);
         xx_storeu_128(ls + j, absABCD);
         j += 16;
         cf += 16;
@@ -148,7 +148,7 @@
       const __m128i coeffB = xx_loadu_128(cf + 4);
       const __m128i absZA = _mm_abs_epi16(_mm_packs_epi32(zeros, coeffA));
       const __m128i absZB = _mm_abs_epi16(_mm_packs_epi32(zeros, coeffB));
-      const __m128i coeffAB = _mm_packs_epi16(absZA, absZB);
+      const __m128i coeffAB = _mm_packus_epi16(absZA, absZB);
       const __m128i signZA =
           _mm_sign_epi16(one16, _mm_packs_epi32(coeffA, zeros));
       const __m128i signZB =
@@ -167,7 +167,7 @@
       const __m128i coeffB = xx_loadu_128(cf + 4);
       const __m128i coeffAB = _mm_packs_epi32(coeffA, coeffB);
       const __m128i absAB = _mm_abs_epi16(coeffAB);
-      const __m128i absAB8 = _mm_packs_epi16(absAB, zeros);
+      const __m128i absAB8 = _mm_packus_epi16(absAB, zeros);
       const __m128i signAB = _mm_sign_epi16(one16, coeffAB);
       const __m128i signAB8 = _mm_packs_epi16(signAB, zeros);
       xx_storeu_128(ls, zeros);
@@ -193,7 +193,7 @@
         const __m128i coeffCD = _mm_packs_epi32(coeffC, coeffD);
         const __m128i absAB = _mm_abs_epi16(coeffAB);
         const __m128i absCD = _mm_abs_epi16(coeffCD);
-        const __m128i absABCD = _mm_packs_epi16(absAB, absCD);
+        const __m128i absABCD = _mm_packus_epi16(absAB, absCD);
         const __m128i signAB = _mm_sign_epi16(one16, coeffAB);
         const __m128i signCD = _mm_sign_epi16(one16, coeffCD);
         const __m128i signABCD = _mm_packs_epi16(signAB, signCD);
@@ -233,7 +233,7 @@
       const __m128i coeffB = xx_loadu_128(cf + 4);
       const __m128i coeffAB = _mm_packs_epi32(coeffA, coeffB);
       const __m128i absAB = _mm_abs_epi16(coeffAB);
-      const __m128i absAB8 = _mm_packs_epi16(absAB, zeros);
+      const __m128i absAB8 = _mm_packus_epi16(absAB, zeros);
       const __m128i lsAB = _mm_unpacklo_epi32(absAB8, zeros);
       xx_storeu_128(ls, lsAB);
       ls += (stride << 1);
@@ -246,7 +246,7 @@
       const __m128i coeffB = xx_loadu_128(cf + 4);
       const __m128i coeffAB = _mm_packs_epi32(coeffA, coeffB);
       const __m128i absAB = _mm_abs_epi16(coeffAB);
-      const __m128i absAB8 = _mm_packs_epi16(absAB, zeros);
+      const __m128i absAB8 = _mm_packus_epi16(absAB, zeros);
       xx_storeu_128(ls, absAB8);
       ls += stride;
       cf += width;
@@ -264,7 +264,7 @@
         const __m128i coeffCD = _mm_packs_epi32(coeffC, coeffD);
         const __m128i absAB = _mm_abs_epi16(coeffAB);
         const __m128i absCD = _mm_abs_epi16(coeffCD);
-        const __m128i absABCD = _mm_packs_epi16(absAB, absCD);
+        const __m128i absABCD = _mm_packus_epi16(absAB, absCD);
         xx_storeu_128(ls + j, absABCD);
         j += 16;
         cf += 16;
diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake
index 659c356..3d308c3 100644
--- a/build/cmake/aom_config_defaults.cmake
+++ b/build/cmake/aom_config_defaults.cmake
@@ -339,6 +339,7 @@
                    "Keep optical flow refined MVs in TMVP list.")
 set_aom_config_var(CONFIG_AFFINE_REFINEMENT 1
                    "Decoder side affine motion refinement.")
+set_aom_config_var(CONFIG_ADAPTIVE_HR 1 "AV2 new adaptive HR coefficient level coding.")
 #
 # Variables in this section control optional features of the build system.
 #