diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c
index 69015660d8..9d003b9ff5 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c
+++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c
@@ -125,34 +125,20 @@ static void nr_processULSegment(void *arg)
   PHY_VARS_gNB *phy_vars_gNB = rdata->gNB;
   NR_UL_gNB_HARQ_t *ulsch_harq = rdata->ulsch_harq;
   t_nrLDPC_dec_params *p_decoderParms = &rdata->decoderParms;
-  int length_dec;
-  int Kr;
-  int Kr_bytes;
-  int K_bits_F;
-  uint8_t crc_type;
-  int i;
-  int j;
-  int r = rdata->segment_r;
-  int A = rdata->A;
-  int E = rdata->E;
-  int Qm = rdata->Qm;
-  int rv_index = rdata->rv_index;
-  int r_offset = rdata->r_offset;
-  uint8_t kc = rdata->Kc;
+  const int Kr = ulsch_harq->K;
+  const int Kr_bytes = Kr >> 3;
+  const int K_bits_F = Kr - ulsch_harq->F;
+  const int r = rdata->segment_r;
+  const int A = rdata->A;
+  const int E = rdata->E;
+  const int Qm = rdata->Qm;
+  const int rv_index = rdata->rv_index;
+  const int r_offset = rdata->r_offset;
+  const uint8_t kc = rdata->Kc;
   short *ulsch_llr = rdata->ulsch_llr;
-  int max_ldpc_iterations = p_decoderParms->numMaxIter;
+  const int max_ldpc_iterations = p_decoderParms->numMaxIter;
   int8_t llrProcBuf[OAI_UL_LDPC_MAX_NUM_LLR] __attribute__((aligned(32)));
 
-  int16_t z[68 * 384 + 16] __attribute__((aligned(16)));
-  int8_t l[68 * 384 + 16] __attribute__((aligned(16)));
-
-  simde__m128i *pv = (simde__m128i *)&z;
-  simde__m128i *pl = (simde__m128i *)&l;
-
-  Kr = ulsch_harq->K;
-  Kr_bytes = Kr >> 3;
-  K_bits_F = Kr - ulsch_harq->F;
-
   t_nrLDPC_time_stats procTime = {0};
   t_nrLDPC_time_stats *p_procTime = &procTime;
 
@@ -211,28 +197,33 @@ static void nr_processULSegment(void *arg)
 
   if (ulsch_harq->C == 1) {
     if (A > 3824)
-      crc_type = CRC24_A;
+      p_decoderParms->crc_type = CRC24_A;
     else
-      crc_type = CRC16;
-
-    length_dec = ulsch_harq->B;
+      p_decoderParms->crc_type = CRC16;
+    p_decoderParms->block_length = ulsch_harq->B;
   } else {
-    crc_type = CRC24_B;
-    length_dec = (ulsch_harq->B + 24 * ulsch_harq->C) / ulsch_harq->C;
+    p_decoderParms->crc_type = CRC24_B;
+    p_decoderParms->block_length = (ulsch_harq->B + 24 * ulsch_harq->C) / ulsch_harq->C;
   }
 
   // start_meas(&phy_vars_gNB->ulsch_ldpc_decoding_stats);
 
   // set first 2*Z_c bits to zeros
-  memset(&z[0], 0, 2 * ulsch_harq->Z * sizeof(int16_t));
+
+  int16_t z[68 * 384 + 16] __attribute__((aligned(16)));
+
+  memset(z, 0, 2 * ulsch_harq->Z * sizeof(*z));
   // set Filler bits
-  memset((&z[0] + K_bits_F), 127, ulsch_harq->F * sizeof(int16_t));
+  memset(z + K_bits_F, 127, ulsch_harq->F * sizeof(*z));
   // Move coded bits before filler bits
-  memcpy((&z[0] + 2 * ulsch_harq->Z), ulsch_harq->d[r], (K_bits_F - 2 * ulsch_harq->Z) * sizeof(int16_t));
+  memcpy(z + 2 * ulsch_harq->Z, ulsch_harq->d[r], (K_bits_F - 2 * ulsch_harq->Z) * sizeof(*z));
   // skip filler bits
-  memcpy((&z[0] + Kr), ulsch_harq->d[r] + (Kr - 2 * ulsch_harq->Z), (kc * ulsch_harq->Z - Kr) * sizeof(int16_t));
+  memcpy(z + Kr, ulsch_harq->d[r] + (Kr - 2 * ulsch_harq->Z), (kc * ulsch_harq->Z - Kr) * sizeof(*z));
   // Saturate coded bits before decoding into 8 bits values
-  for (i = 0, j = 0; j < ((kc * ulsch_harq->Z) >> 4) + 1; i += 2, j++) {
+  simde__m128i *pv = (simde__m128i *)&z;
+  int8_t l[68 * 384 + 16] __attribute__((aligned(16)));
+  simde__m128i *pl = (simde__m128i *)&l;
+  for (int i = 0, j = 0; j < ((kc * ulsch_harq->Z) >> 4) + 1; i += 2, j++) {
     pl[j] = simde_mm_packs_epi16(pv[i], pv[i + 1]);
   }
   //////////////////////////////////////////////////////////////////////////////////////////
@@ -242,73 +233,194 @@ static void nr_processULSegment(void *arg)
   //////////////////////////////////////////////////////////////////////////////////////////
 
   ////////////////////////////////// pl =====> llrProcBuf //////////////////////////////////
-  p_decoderParms->block_length = length_dec;
-  p_decoderParms->crc_type = crc_type;
-  rdata->decodeIterations = nrLDPC_decoder(p_decoderParms, (int8_t *)pl, llrProcBuf, p_procTime, &ulsch_harq->abort_decode);
+  rdata->decodeIterations = nrLDPC_decoder(p_decoderParms, l, llrProcBuf, p_procTime, &ulsch_harq->abort_decode);
 
   if (rdata->decodeIterations <= p_decoderParms->numMaxIter)
     memcpy(ulsch_harq->c[r],llrProcBuf,  Kr>>3);
   //stop_meas(&phy_vars_gNB->ulsch_ldpc_decoding_stats);
 }
 
-int nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
-                        uint8_t ULSCH_id,
-                        short *ulsch_llr,
-                        NR_DL_FRAME_PARMS *frame_parms,
-                        nfapi_nr_pusch_pdu_t *pusch_pdu,
-                        uint32_t frame,
-                        uint8_t nr_tti_rx,
-                        uint8_t harq_pid,
-                        uint32_t G)
-  {
-    if (!ulsch_llr) {
-      LOG_E(PHY, "ulsch_decoding.c: NULL ulsch_llr pointer\n");
-      return -1;
-    }
+int decode_offload(PHY_VARS_gNB *phy_vars_gNB,
+                   uint8_t ULSCH_id,
+                   short *ulsch_llr,
+                   nfapi_nr_pusch_pdu_t *pusch_pdu,
+                   t_nrLDPC_dec_params *decParams,
+                   uint8_t harq_pid,
+                   uint32_t G)
+{
+  NR_gNB_ULSCH_t *ulsch = &phy_vars_gNB->ulsch[ULSCH_id];
+  NR_UL_gNB_HARQ_t *harq_process = ulsch->harq_process;
+  int8_t llrProcBuf[22 * 384] __attribute__((aligned(32)));
+  int16_t z_ol[68 * 384] __attribute__((aligned(32)));
+  int8_t l_ol[68 * 384] __attribute__((aligned(32)));
+  int crc_type;
+  int length_dec;
+  uint8_t Qm = pusch_pdu->qam_mod_order;
+  uint8_t n_layers = pusch_pdu->nrOfLayers;
+  const int Kr = harq_process->K;
+  const int Kr_bytes = Kr >> 3;
+  const int kc = decParams->BG == 2 ? 52 : 68;
+  const uint32_t A = (harq_process->TBS) << 3;
 
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_ULSCH_DECODING, 1);
+  if (harq_process->C == 1) {
+    if (A > 3824)
+      crc_type = CRC24_A;
+    else
+      crc_type = CRC16;
 
-    NR_gNB_ULSCH_t *ulsch = &phy_vars_gNB->ulsch[ULSCH_id];
-    NR_gNB_PUSCH *pusch = &phy_vars_gNB->pusch_vars[ULSCH_id];
-    NR_UL_gNB_HARQ_t *harq_process = ulsch->harq_process;
-
-    if (!harq_process) {
-      LOG_E(PHY, "ulsch_decoding.c: NULL harq_process pointer\n");
-      return -1;
+    length_dec = harq_process->B;
+  } else {
+    crc_type = CRC24_B;
+    length_dec = (harq_process->B + 24 * harq_process->C) / harq_process->C;
   }
-  uint8_t dtx_det = 0;
+  int decodeIterations = 2;
+  int dtx_det = 0;
+  int r_offset = 0, offset = 0;
+  for (int r = 0; r < harq_process->C; r++) {
+    int E = nr_get_E(G, harq_process->C, Qm, n_layers, r);
+    memset(harq_process->c[r], 0, Kr_bytes);
 
-  int Kr;
-  int Kr_bytes;
+    decParams->R = nr_get_R_ldpc_decoder(pusch_pdu->pusch_data.rv_index,
+                                         E,
+                                         decParams->BG,
+                                         decParams->Z,
+                                         &harq_process->llrLen,
+                                         harq_process->round);
+
+    if ((dtx_det == 0) && (pusch_pdu->pusch_data.rv_index == 0)) {
+      memcpy(z_ol, ulsch_llr + r_offset, E * sizeof(short));
+      simde__m128i *pv_ol128 = (simde__m128i *)&z_ol;
+      simde__m128i *pl_ol128 = (simde__m128i *)&l_ol;
+      for (int i = 0, j = 0; j < ((kc * harq_process->Z) >> 4) + 1; i += 2, j++) {
+        pl_ol128[j] = simde_mm_packs_epi16(pv_ol128[i], pv_ol128[i + 1]);
+      }
+
+      int ret = nrLDPC_decoder_offload(decParams,
+                                       harq_pid,
+                                       ULSCH_id,
+                                       r,
+                                       pusch_pdu->pusch_data.rv_index,
+                                       harq_process->F,
+                                       E,
+                                       Qm,
+                                       (int8_t *)&pl_ol128[0],
+                                       llrProcBuf,
+                                       1);
+      if (ret < 0) {
+        LOG_E(PHY, "ulsch_decoding.c: Problem in LDPC decoder offload\n");
+
+        decodeIterations = ulsch->max_ldpc_iterations + 1;
+        return -1;
+      }
+      for (int m = 0; m < Kr >> 3; m++) {
+        harq_process->c[r][m] = (uint8_t)llrProcBuf[m];
+      }
+
+      if (check_crc((uint8_t *)llrProcBuf, length_dec, crc_type)) {
+        PRINT_CRC_CHECK(LOG_I(PHY, "Segment %d CRC OK\n", r));
+        decodeIterations = 2;
+      } else {
+        PRINT_CRC_CHECK(LOG_I(PHY, "segment %d CRC NOK\n", r));
+        decodeIterations = ulsch->max_ldpc_iterations + 1;
+      }
+      //}
+
+      r_offset += E;
+
+      /*for (int k=0;k<8;k++)
+  {
+  printf("output decoder [%d] =  0x%02x \n", k, harq_process->c[r][k]);
+  printf("llrprocbuf [%d] =  %x adr %p\n", k, llrProcBuf[k], llrProcBuf+k);
+  }
+      */
+    } else {
+      dtx_det = 0;
+      decodeIterations = ulsch->max_ldpc_iterations + 1;
+    }
+    bool decodeSuccess = (decodeIterations <= ulsch->max_ldpc_iterations);
+    if (decodeSuccess) {
+      memcpy(harq_process->b + offset, harq_process->c[r], Kr_bytes - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
+      offset += (Kr_bytes - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
+      harq_process->processedSegments++;
+    } else {
+      LOG_D(PHY, "uplink segment error %d/%d\n", r, harq_process->C);
+      LOG_D(PHY, "ULSCH %d in error\n", ULSCH_id);
+      break; // don't even attempt to decode other segments
+    }
+  }
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_ULSCH_DECODING, 0);
+
+  if (harq_process->processedSegments == harq_process->C) {
+    LOG_D(PHY, "ULSCH: Setting ACK for slot %d TBS %d\n", ulsch->slot, harq_process->TBS);
+    ulsch->active = false;
+    harq_process->round = 0;
+
+    LOG_D(PHY, "ULSCH received ok \n");
+    nr_fill_indication(phy_vars_gNB, ulsch->frame, ulsch->slot, ULSCH_id, harq_pid, 0, 0);
+
+  } else {
+    LOG_D(PHY,
+          "[gNB %d] ULSCH: Setting NAK for SFN/SF %d/%d (pid %d, status %d, round %d, TBS %d)\n",
+          phy_vars_gNB->Mod_id,
+          ulsch->frame,
+          ulsch->slot,
+          harq_pid,
+          ulsch->active,
+          harq_process->round,
+          harq_process->TBS);
+    ulsch->handled = 1;
+    decodeIterations = ulsch->max_ldpc_iterations + 1;
+    LOG_D(PHY, "ULSCH %d in error\n", ULSCH_id);
+    nr_fill_indication(phy_vars_gNB, ulsch->frame, ulsch->slot, ULSCH_id, harq_pid, 1, 0);
+  }
+  ulsch->last_iteration_cnt = decodeIterations;
+  return 0;
+}
+
+int nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
+                      uint8_t ULSCH_id,
+                      short *ulsch_llr,
+                      NR_DL_FRAME_PARMS *frame_parms,
+                      nfapi_nr_pusch_pdu_t *pusch_pdu,
+                      uint32_t frame,
+                      uint8_t nr_tti_rx,
+                      uint8_t harq_pid,
+                      uint32_t G)
+{
+  if (!ulsch_llr) {
+    LOG_E(PHY, "ulsch_decoding.c: NULL ulsch_llr pointer\n");
+    return -1;
+  }
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_ULSCH_DECODING, 1);
+
+  NR_gNB_ULSCH_t *ulsch = &phy_vars_gNB->ulsch[ULSCH_id];
+  NR_gNB_PUSCH *pusch = &phy_vars_gNB->pusch_vars[ULSCH_id];
+  NR_UL_gNB_HARQ_t *harq_process = ulsch->harq_process;
+
+  if (!harq_process) {
+    LOG_E(PHY, "ulsch_decoding.c: NULL harq_process pointer\n");
+    return -1;
+  }
+
+  // ------------------------------------------------------------------
+  const uint16_t nb_rb = pusch_pdu->rb_size;
+  const uint8_t Qm = pusch_pdu->qam_mod_order;
+  const uint8_t mcs = pusch_pdu->mcs_index;
+  const uint8_t n_layers = pusch_pdu->nrOfLayers;
+  // ------------------------------------------------------------------
 
   harq_process->processedSegments = 0;
-  
-  // ------------------------------------------------------------------
-  uint16_t nb_rb          = pusch_pdu->rb_size;
-  uint8_t Qm              = pusch_pdu->qam_mod_order;
-  uint8_t mcs             = pusch_pdu->mcs_index;
-  uint8_t n_layers        = pusch_pdu->nrOfLayers;
-  // ------------------------------------------------------------------
-
   harq_process->TBS = pusch_pdu->pusch_data.tb_size;
 
-  dtx_det = 0;
-
-  uint32_t A = (harq_process->TBS) << 3;
-
-  // target_code_rate is in 0.1 units
-  float Coderate = (float) pusch_pdu->target_code_rate / 10240.0f;
-
-  LOG_D(PHY,"ULSCH Decoding, harq_pid %d rnti %x TBS %d G %d mcs %d Nl %d nb_rb %d, Qm %d, Coderate %f RV %d round %d new RX %d\n",
-        harq_pid, ulsch->rnti, A, G, mcs, n_layers, nb_rb, Qm, Coderate, pusch_pdu->pusch_data.rv_index, harq_process->round, harq_process->harq_to_be_cleared);
   t_nrLDPC_dec_params decParams = {0};
   decParams.BG = pusch_pdu->maintenance_parms_v3.ldpcBaseGraph;
-  int kc;
-  if (decParams.BG == 2) {
-    kc = 52;
-  } else {
-    kc = 68;
-  }
+  const uint32_t A = (harq_process->TBS) << 3;
+  if (A > 3824)
+    harq_process->B = A + 24;
+  else
+    harq_process->B = A + 16;
 
   NR_gNB_PHY_STATS_t *stats = get_phy_stats(phy_vars_gNB, ulsch->rnti);
   if (stats) {
@@ -324,10 +436,21 @@ int nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
       stats->ulsch_stats.total_bytes_tx += harq_process->TBS;
     }
   }
-  if (A > 3824)
-    harq_process->B = A+24;
-  else
-    harq_process->B = A+16;
+
+  LOG_D(PHY,
+        "ULSCH Decoding, harq_pid %d rnti %x TBS %d G %d mcs %d Nl %d nb_rb %d, Qm %d, Coderate %f RV %d round %d new RX %d\n",
+        harq_pid,
+        ulsch->rnti,
+        A,
+        G,
+        mcs,
+        n_layers,
+        nb_rb,
+        Qm,
+        pusch_pdu->target_code_rate / 10240.0f,
+        pusch_pdu->pusch_data.rv_index,
+        harq_process->round,
+        harq_process->harq_to_be_cleared);
 
   // [hna] Perform nr_segmenation with input and output set to NULL to calculate only (B, C, K, Z, F)
   nr_segmentation(NULL,
@@ -339,204 +462,75 @@ int nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
                   &harq_process->F,
                   decParams.BG);
 
-  if (harq_process->C>MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*n_layers) {
+  uint16_t a_segments = MAX_NUM_NR_ULSCH_SEGMENTS_PER_LAYER * n_layers; // number of segments to be allocated
+  if (harq_process->C > a_segments) {
     LOG_E(PHY,"nr_segmentation.c: too many segments %d, B %d\n",harq_process->C,harq_process->B);
     return(-1);
   }
-
-
-#ifdef DEBUG_ULSCH_DECODING
-  printf("ulsch decoding nr segmentation Z %d\n", harq_process->Z);
-  if (!frame%100)
-    printf("K %d C %d Z %d \n", harq_process->K, harq_process->C, harq_process->Z);
-#endif
-  decParams.Z = harq_process->Z;
-
-  decParams.numMaxIter = ulsch->max_ldpc_iterations;
-  decParams.outMode = 0;
-
-  uint32_t r_offset = 0;
-
-  uint16_t a_segments = MAX_NUM_NR_ULSCH_SEGMENTS_PER_LAYER*n_layers;  //number of segments to be allocated
-
   if (nb_rb != 273) {
     a_segments = a_segments*nb_rb;
     a_segments = a_segments/273 +1;
   }
-
   if (harq_process->C > a_segments) {
     LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,a_segments);
     return -1;
   }
+
 #ifdef DEBUG_ULSCH_DECODING
+  printf("ulsch decoding nr segmentation Z %d\n", harq_process->Z);
+  if (!frame % 100)
+    printf("K %d C %d Z %d \n", harq_process->K, harq_process->C, harq_process->Z);
   printf("Segmentation: C %d, K %d\n",harq_process->C,harq_process->K);
 #endif
 
+  decParams.Z = harq_process->Z;
+  decParams.numMaxIter = ulsch->max_ldpc_iterations;
+  decParams.outMode = 0;
+
   if (harq_process->harq_to_be_cleared) {
     for (int r = 0; r < harq_process->C; r++)
       harq_process->d_to_be_cleared[r] = true;
     harq_process->harq_to_be_cleared = false;
   }
 
-  Kr = harq_process->K;
-  Kr_bytes = Kr >> 3;
+  if (phy_vars_gNB->ldpc_offload_flag && mcs > 9)
+    return decode_offload(phy_vars_gNB, ULSCH_id, ulsch_llr, pusch_pdu, &decParams, harq_pid, G);
 
-  uint32_t offset = 0;
-  if (phy_vars_gNB->ldpc_offload_flag && mcs > 9) {
-    int8_t llrProcBuf[22 * 384];
-    //  if (dtx_det==0) {
-    int16_t z_ol[68 * 384];
-    int8_t l_ol[68 * 384];
-    int crc_type;
-    int length_dec;
-
-    if (harq_process->C == 1) {
-      if (A > 3824)
-        crc_type = CRC24_A;
-      else
-        crc_type = CRC16;
-
-      length_dec = harq_process->B;
-    } else {
-      crc_type = CRC24_B;
-      length_dec = (harq_process->B + 24 * harq_process->C) / harq_process->C;
-    }
-    int decodeIterations = 2;
-    for (int r = 0; r < harq_process->C; r++) {
-      int E = nr_get_E(G, harq_process->C, Qm, n_layers, r);
-      memset(harq_process->c[r], 0, Kr_bytes);
-
-      decParams.R = nr_get_R_ldpc_decoder(pusch_pdu->pusch_data.rv_index, E, decParams.BG, decParams.Z, &harq_process->llrLen, harq_process->round);
-
-      if ((dtx_det == 0) && (pusch_pdu->pusch_data.rv_index == 0)) {
-        // if (dtx_det==0){
-          memcpy((&z_ol[0]), ulsch_llr + r_offset, E * sizeof(short));
-          simde__m128i *pv_ol128 = (simde__m128i *)&z_ol;
-          simde__m128i *pl_ol128 = (simde__m128i *)&l_ol;
-          for (int i = 0, j = 0; j < ((kc * harq_process->Z) >> 4) + 1; i += 2, j++) {
-            pl_ol128[j] = simde_mm_packs_epi16(pv_ol128[i], pv_ol128[i + 1]);
-          }
-
-          int ret = nrLDPC_decoder_offload(&decParams, harq_pid, ULSCH_id, r, pusch_pdu->pusch_data.rv_index, harq_process->F, E, Qm, (int8_t *)&pl_ol128[0], llrProcBuf, 1);
-          if (ret < 0) {
-            LOG_E(PHY, "ulsch_decoding.c: Problem in LDPC decoder offload\n");
-
-            decodeIterations = ulsch->max_ldpc_iterations + 1;
-            return -1;
-          }
-        for (int m = 0; m < Kr >> 3; m++) {
-          harq_process->c[r][m] = (uint8_t)llrProcBuf[m];
-        }
-
-        if (check_crc((uint8_t *)llrProcBuf, length_dec, crc_type)) {
-          PRINT_CRC_CHECK(LOG_I(PHY, "Segment %d CRC OK\n", r));
-          decodeIterations = 2;
-        } else {
-          PRINT_CRC_CHECK(LOG_I(PHY, "segment %d CRC NOK\n", r));
-          decodeIterations = ulsch->max_ldpc_iterations + 1;
-        }
-        //}
-
-        r_offset += E;
-
-        /*for (int k=0;k<8;k++)
-          {
-          printf("output decoder [%d] =  0x%02x \n", k, harq_process->c[r][k]);
-          printf("llrprocbuf [%d] =  %x adr %p\n", k, llrProcBuf[k], llrProcBuf+k);
-          }
-        */
-      } else {
-        dtx_det = 0;
-        decodeIterations = ulsch->max_ldpc_iterations + 1;
-      }
-      bool decodeSuccess = (decodeIterations <= ulsch->max_ldpc_iterations);
-      if (decodeSuccess) {
-        memcpy(harq_process->b + offset, harq_process->c[r], Kr_bytes - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
-        offset += (Kr_bytes - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
-        harq_process->processedSegments++;
-      } else {
-        LOG_D(PHY, "uplink segment error %d/%d\n", r, harq_process->C);
-        LOG_D(PHY, "ULSCH %d in error\n", ULSCH_id);
-        break; // don't even attempt to decode other segments
-      }
-    }
-
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_ULSCH_DECODING, 0);
-
-    bool crc_valid = false;
-    if (harq_process->processedSegments == harq_process->C) {
-      // When the number of code blocks is 1 (C = 1) and ulsch_harq->processedSegments = 1, we can assume a good TB because of the
-      // CRC check made by the LDPC for early termination, so, no need to perform CRC check twice for a single code block
-      crc_valid = true;
-      if (harq_process->C > 1) {
-        // Check ULSCH transport block CRC
-        crc_type = CRC16;
-        if (A > 3824) {
-          crc_type = CRC24_A;
-        }
-        crc_valid = check_crc(harq_process->b, harq_process->B, crc_type);
-      }
-    }
-
-    if (crc_valid) {
-      LOG_D(PHY, "[gNB %d] ULSCH: Setting ACK for slot %d TBS %d\n", phy_vars_gNB->Mod_id, ulsch->slot, harq_process->TBS);
-      ulsch->active = false;
-      harq_process->round = 0;
-
-      LOG_D(PHY, "ULSCH received ok \n");
-      nr_fill_indication(phy_vars_gNB, ulsch->frame, ulsch->slot, ULSCH_id, harq_pid, 0, 0);
-
-    } else {
-      LOG_D(PHY,
-            "[gNB %d] ULSCH: Setting NAK for SFN/SF %d/%d (pid %d, status %d, round %d, TBS %d)\n",
-            phy_vars_gNB->Mod_id,
-            ulsch->frame,
-            ulsch->slot,
-            harq_pid,
-            ulsch->active,
-            harq_process->round,
-            harq_process->TBS);
-      ulsch->handled = 1;
-      decodeIterations = ulsch->max_ldpc_iterations + 1;
-      LOG_D(PHY, "ULSCH %d in error\n", ULSCH_id);
-      nr_fill_indication(phy_vars_gNB, ulsch->frame, ulsch->slot, ULSCH_id, harq_pid, 1, 0);
-    }
-    ulsch->last_iteration_cnt = decodeIterations;
-  }
-
-  else {
-    dtx_det = 0;
-    set_abort(&harq_process->abort_decode, false);
-    for (int r = 0; r < harq_process->C; r++) {
-      int E = nr_get_E(G, harq_process->C, Qm, n_layers, r);
-      union ldpcReqUnion id = {.s = {ulsch->rnti, frame, nr_tti_rx, 0, 0}};
-      notifiedFIFO_elt_t *req = newNotifiedFIFO_elt(sizeof(ldpcDecode_t), id.p, &phy_vars_gNB->respDecode, &nr_processULSegment);
-      ldpcDecode_t *rdata = (ldpcDecode_t *)NotifiedFifoData(req);
-      decParams.R = nr_get_R_ldpc_decoder(pusch_pdu->pusch_data.rv_index, E, decParams.BG, decParams.Z, &harq_process->llrLen, harq_process->round);
-      rdata->gNB = phy_vars_gNB;
-      rdata->ulsch_harq = harq_process;
-      rdata->decoderParms = decParams;
-      rdata->ulsch_llr = ulsch_llr;
-      rdata->Kc = kc;
-      rdata->harq_pid = harq_pid;
-      rdata->segment_r = r;
-      rdata->nbSegments = harq_process->C;
-      rdata->E = E;
-      rdata->A = A;
-      rdata->Qm = Qm;
-      rdata->r_offset = r_offset;
-      rdata->Kr_bytes = Kr_bytes;
-      rdata->rv_index = pusch_pdu->pusch_data.rv_index;
-      rdata->offset = offset;
-      rdata->ulsch = ulsch;
-      rdata->ulsch_id = ULSCH_id;
-      rdata->tbslbrm = pusch_pdu->maintenance_parms_v3.tbSizeLbrmBytes;
-      pushTpool(&phy_vars_gNB->threadPool, req);
-      LOG_D(PHY, "Added a block to decode, in pipe: %d\n", r);
-      r_offset += E;
-      offset += (Kr_bytes - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
-      //////////////////////////////////////////////////////////////////////////////////////////
-    }
+  uint32_t offset = 0, r_offset = 0;
+  set_abort(&harq_process->abort_decode, false);
+  for (int r = 0; r < harq_process->C; r++) {
+    int E = nr_get_E(G, harq_process->C, Qm, n_layers, r);
+    union ldpcReqUnion id = {.s = {ulsch->rnti, frame, nr_tti_rx, 0, 0}};
+    notifiedFIFO_elt_t *req = newNotifiedFIFO_elt(sizeof(ldpcDecode_t), id.p, &phy_vars_gNB->respDecode, &nr_processULSegment);
+    ldpcDecode_t *rdata = (ldpcDecode_t *)NotifiedFifoData(req);
+    decParams.R = nr_get_R_ldpc_decoder(pusch_pdu->pusch_data.rv_index,
+                                        E,
+                                        decParams.BG,
+                                        decParams.Z,
+                                        &harq_process->llrLen,
+                                        harq_process->round);
+    rdata->gNB = phy_vars_gNB;
+    rdata->ulsch_harq = harq_process;
+    rdata->decoderParms = decParams;
+    rdata->ulsch_llr = ulsch_llr;
+    rdata->Kc = decParams.BG == 2 ? 52 : 68;
+    rdata->harq_pid = harq_pid;
+    rdata->segment_r = r;
+    rdata->nbSegments = harq_process->C;
+    rdata->E = E;
+    rdata->A = A;
+    rdata->Qm = Qm;
+    rdata->r_offset = r_offset;
+    rdata->Kr_bytes = harq_process->K >> 3;
+    rdata->rv_index = pusch_pdu->pusch_data.rv_index;
+    rdata->offset = offset;
+    rdata->ulsch = ulsch;
+    rdata->ulsch_id = ULSCH_id;
+    rdata->tbslbrm = pusch_pdu->maintenance_parms_v3.tbSizeLbrmBytes;
+    pushTpool(&phy_vars_gNB->threadPool, req);
+    LOG_D(PHY, "Added a block to decode, in pipe: %d\n", r);
+    r_offset += E;
+    offset += ((harq_process->K >> 3) - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
   }
   return harq_process->C;
 }
diff --git a/openair1/SCHED_NR/phy_procedures_nr_gNB.c b/openair1/SCHED_NR/phy_procedures_nr_gNB.c
index 184e3ec63b..6ad14f1836 100644
--- a/openair1/SCHED_NR/phy_procedures_nr_gNB.c
+++ b/openair1/SCHED_NR/phy_procedures_nr_gNB.c
@@ -953,7 +953,6 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
       VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_ULSCH_PROCEDURES_RX, 0);
     }
   }
-  if (totalDecode > 0 && gNB->ldpc_offload_flag == 0) {
     while (totalDecode > 0) {
       notifiedFIFO_elt_t *req = pullTpool(&gNB->respDecode, &gNB->threadPool);
       if (req == NULL)
@@ -962,7 +961,6 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
       delNotifiedFIFO_elt(req);
       totalDecode--;
     }
-  }
   for (int i = 0; i < gNB->max_nb_srs; i++) {
     NR_gNB_SRS_t *srs = &gNB->srs[i];
     if (srs) {