diff --git a/openair2/NR_PHY_INTERFACE/NR_IF_Module.c b/openair2/NR_PHY_INTERFACE/NR_IF_Module.c
index 57bb411dcc..b94b22282c 100644
--- a/openair2/NR_PHY_INTERFACE/NR_IF_Module.c
+++ b/openair2/NR_PHY_INTERFACE/NR_IF_Module.c
@@ -63,7 +63,7 @@ extern uint16_t sl_ahead;
 
 void handle_nr_rach(NR_UL_IND_t *UL_info)
 {
-  if(NFAPI_MODE == NFAPI_MODE_PNF) {
+  if (NFAPI_MODE == NFAPI_MODE_PNF) {
     if (UL_info->rach_ind.number_of_pdus > 0) {
       LOG_D(PHY,"UL_info->UL_info->rach_ind.number_of_pdus:%d SFN/Slot:%d.%d \n", UL_info->rach_ind.number_of_pdus, UL_info->rach_ind.sfn,UL_info->rach_ind.slot);
       oai_nfapi_nr_rach_indication(&UL_info->rach_ind);
@@ -71,69 +71,29 @@ void handle_nr_rach(NR_UL_IND_t *UL_info)
     }
     return;
   }
-  NR_UL_IND_t UL_INFO;
-  nfapi_nr_rach_indication_t *rach_ind = NULL;
-  if (get_softmodem_params()->emulate_l1)
-  {
-    if (gnb_rach_ind_queue.num_items == 0)
-      return; 
-    LOG_I(NR_MAC, "gnb_rach_ind_queue size = %zu\n", gnb_rach_ind_queue.num_items);
-    rach_ind = get_queue(&gnb_rach_ind_queue);
 
-    UL_INFO.rach_ind = *rach_ind;
-    UL_INFO.module_id = UL_info->module_id;
-    UL_INFO.CC_id = UL_info->CC_id;
-  }
-  else
-  {
-    UL_INFO.rach_ind = UL_info->rach_ind;
-    UL_INFO.module_id = UL_info->module_id;
-    UL_INFO.CC_id = UL_info->CC_id;
-  }
-
-  int frame_diff = UL_info->frame - UL_INFO.rach_ind.sfn;
-  if (frame_diff < 0)
-  {
+  int frame_diff = UL_info->frame - UL_info->rach_ind.sfn;
+  if (frame_diff < 0) {
     frame_diff += 1024;
   }
   bool in_timewindow = frame_diff == 0 || (frame_diff == 1 && UL_info->slot < 7);
 
-  if (UL_INFO.rach_ind.number_of_pdus>0 && in_timewindow) {
+  if (UL_info->rach_ind.number_of_pdus > 0 && in_timewindow) {
     LOG_A(MAC,"UL_info[Frame %d, Slot %d] Calling initiate_ra_proc RACH:SFN/SLOT:%d/%d\n",
-          UL_info->frame, UL_info->slot, UL_INFO.rach_ind.sfn, UL_INFO.rach_ind.slot);
-    int npdus = UL_INFO.rach_ind.number_of_pdus;
-    for(int i = 0; i < npdus; i++) {
-      UL_INFO.rach_ind.number_of_pdus--;
+          UL_info->frame, UL_info->slot, UL_info->rach_ind.sfn, UL_info->rach_ind.slot);
+    for (int i = 0; i < UL_info->rach_ind.number_of_pdus; i++) {
       UL_info->rach_ind.number_of_pdus--;
-      if (UL_INFO.rach_ind.pdu_list[i].num_preamble>0)
-      AssertFatal(UL_INFO.rach_ind.pdu_list[i].num_preamble==1,
-                  "More than 1 preamble not supported\n");
-    
-      nr_initiate_ra_proc(UL_INFO.module_id,
-                          UL_INFO.CC_id,
-                          UL_INFO.rach_ind.sfn,
-                          UL_INFO.rach_ind.slot,
-                          UL_INFO.rach_ind.pdu_list[i].preamble_list[0].preamble_index,
-                          UL_INFO.rach_ind.pdu_list[i].freq_index,
-                          UL_INFO.rach_ind.pdu_list[i].symbol_index,
-                          UL_INFO.rach_ind.pdu_list[i].preamble_list[0].timing_advance);
+      AssertFatal(UL_info->rach_ind.pdu_list[i].num_preamble == 1, "More than 1 preamble not supported\n");
+      nr_initiate_ra_proc(UL_info->module_id,
+                          UL_info->CC_id,
+                          UL_info->rach_ind.sfn,
+                          UL_info->rach_ind.slot,
+                          UL_info->rach_ind.pdu_list[i].preamble_list[0].preamble_index,
+                          UL_info->rach_ind.pdu_list[i].freq_index,
+                          UL_info->rach_ind.pdu_list[i].symbol_index,
+                          UL_info->rach_ind.pdu_list[i].preamble_list[0].timing_advance);
     }
   }
-  if (get_softmodem_params()->emulate_l1)
-  {
-    if (rach_ind && rach_ind->number_of_pdus > 0)
-    {
-      for(int i = 0; i < rach_ind->number_of_pdus; i++)
-      {
-        free(rach_ind->pdu_list[i].preamble_list);
-        rach_ind->pdu_list[i].preamble_list = NULL;
-      }
-      free(rach_ind->pdu_list);
-      rach_ind->pdu_list = NULL;
-    }
-    free(rach_ind);
-    rach_ind = NULL;
-  }
 }
 
 
@@ -148,26 +108,11 @@ void handle_nr_uci(NR_UL_IND_t *UL_info)
     return;
   }
 
-  NR_UL_IND_t UL_INFO;
-  nfapi_nr_uci_indication_t *uci_ind = NULL;
-  if (get_softmodem_params()->emulate_l1)
-  {
-    if (gnb_uci_ind_queue.num_items == 0)
-      return; 
-    LOG_I(NR_MAC, "gnb_uci_ind_queue size = %zu\n", gnb_uci_ind_queue.num_items);
-    uci_ind = get_queue(&gnb_uci_ind_queue);
-    UL_INFO.uci_ind = *uci_ind;
-  }
-  else
-  {
-    UL_INFO.uci_ind = UL_info->uci_ind;
-  }
-
   const module_id_t mod_id = UL_info->module_id;
-  const frame_t frame = UL_INFO.uci_ind.sfn;
-  const sub_frame_t slot = UL_INFO.uci_ind.slot;
-  int num_ucis = UL_INFO.uci_ind.num_ucis;
-  nfapi_nr_uci_t *uci_list = UL_INFO.uci_ind.uci_list;
+  const frame_t frame = UL_info->uci_ind.sfn;
+  const sub_frame_t slot = UL_info->uci_ind.slot;
+  int num_ucis = UL_info->uci_ind.num_ucis;
+  nfapi_nr_uci_t *uci_list = UL_info->uci_ind.uci_list;
 
   for (int i = 0; i < num_ucis; i++) {
     switch (uci_list[i].pdu_type) {
@@ -178,7 +123,7 @@ void handle_nr_uci(NR_UL_IND_t *UL_info)
       case NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE: {
         const nfapi_nr_uci_pucch_pdu_format_0_1_t *uci_pdu = &uci_list[i].pucch_pdu_format_0_1;
         LOG_D(NR_MAC, "The received uci has sfn slot %d %d, num_ucis %d and pdu_size %d\n",
-                UL_INFO.uci_ind.sfn, UL_INFO.uci_ind.slot, num_ucis, uci_list[i].pdu_size);
+                UL_info->uci_ind.sfn, UL_info->uci_ind.slot, num_ucis, uci_list[i].pdu_size);
         handle_nr_uci_pucch_0_1(mod_id, frame, slot, uci_pdu);
         break;
       }
@@ -192,39 +137,8 @@ void handle_nr_uci(NR_UL_IND_t *UL_info)
     }
   }
 
-  if (get_softmodem_params()->emulate_l1)
-  {
-    for (int i = 0; i < num_ucis; i++) {
-      switch (uci_list[i].pdu_type) {
-        case NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE:
-          if (uci_list[i].pucch_pdu_format_0_1.harq) {
-            free(uci_list[i].pucch_pdu_format_0_1.harq->harq_list);
-            uci_list[i].pucch_pdu_format_0_1.harq->harq_list = NULL;
-          }
-          free(uci_list[i].pucch_pdu_format_0_1.harq);
-          uci_list[i].pucch_pdu_format_0_1.harq = NULL;
-          free(uci_list[i].pucch_pdu_format_0_1.sr);
-          uci_list[i].pucch_pdu_format_0_1.sr = NULL;
-          break;
+  UL_info->uci_ind.num_ucis = 0;
 
-        case NFAPI_NR_UCI_FORMAT_2_3_4_PDU_TYPE:
-          free(uci_list[i].pucch_pdu_format_2_3_4.harq.harq_payload);
-          free(uci_list[i].pucch_pdu_format_2_3_4.csi_part1.csi_part1_payload);
-          free(uci_list[i].pucch_pdu_format_2_3_4.csi_part2.csi_part2_payload);
-          break;
-      }
-    }
-    if (uci_ind && num_ucis > 0) {
-      free(uci_list);
-      uci_list = NULL;
-    }
-    free(uci_ind);
-    uci_ind = NULL;
-  }
-  else
-  {
-    UL_info->uci_ind.num_ucis = 0;
-  }
 }
 
 static bool crc_sfn_slot_matcher(void *wanted, void *candidate)
@@ -264,173 +178,226 @@ void handle_nr_ulsch(NR_UL_IND_t *UL_info)
     return;
   }
 
-  NR_UL_IND_t UL_INFO;
-  nfapi_nr_rx_data_indication_t *rx_ind = NULL;
-  nfapi_nr_crc_indication_t *crc_ind = NULL;
-  if (get_softmodem_params()->emulate_l1)
-  {
-    rx_ind = get_queue(&gnb_rx_ind_queue);
-    if (!rx_ind)
-    {
-      LOG_D(NR_PHY, "No rx data indication (empty gnb_rx_ind_queue)\n");
-      return;
+  if (UL_info->rx_ind.number_of_pdus > 0 && UL_info->crc_ind.number_crcs > 0) {
+    AssertFatal(UL_info->rx_ind.number_of_pdus == UL_info->crc_ind.number_crcs,
+                "number_of_pdus %d, number_crcs %d\n",
+                UL_info->rx_ind.number_of_pdus, UL_info->crc_ind.number_crcs);
+    for (int i = 0; i < UL_info->rx_ind.number_of_pdus; i++) {
+      const nfapi_nr_rx_data_pdu_t *rx = &UL_info->rx_ind.pdu_list[i];
+      const nfapi_nr_crc_t *crc = &UL_info->crc_ind.crc_list[i];
+      LOG_I(NR_PHY, "UL_info->crc_ind.pdu_list[%d].rnti:%04x "
+                    "UL_info->rx_ind.pdu_list[%d].rnti:%04x\n",
+                    i, crc->rnti, i, rx->rnti);
+
+      AssertFatal(crc->rnti == rx->rnti, "mis-match between CRC RNTI %04x and RX RNTI %04x\n",
+                  crc->rnti, rx->rnti);
+
+      LOG_D(NR_MAC,
+            "%4d.%2d Calling rx_sdu (CRC %s/tb_crc_status %d)\n",
+            UL_info->frame,
+            UL_info->slot,
+            crc->tb_crc_status ? "error" : "ok",
+            crc->tb_crc_status);
+
+      /* if CRC passes, pass PDU, otherwise pass NULL as error indication */
+      nr_rx_sdu(UL_info->module_id,
+                UL_info->CC_id,
+                UL_info->rx_ind.sfn,
+                UL_info->rx_ind.slot,
+                rx->rnti,
+                crc->tb_crc_status ? NULL : rx->pdu,
+                rx->pdu_length,
+                rx->timing_advance,
+                rx->ul_cqi,
+                rx->rssi);
+      handle_nr_ul_harq(UL_info->CC_id, UL_info->module_id, UL_info->frame, UL_info->slot, crc);
     }
-
-    int sfn_slot = NFAPI_SFNSLOT2HEX(rx_ind->sfn, rx_ind->slot); 
-    
-    crc_ind = unqueue_matching(&gnb_crc_ind_queue,
-                               MAX_QUEUE_SIZE,
-                               crc_sfn_slot_matcher,
-                               &sfn_slot);
-    if (!crc_ind)
-    {
-      LOG_D(NR_PHY, "No crc indication with the same SFN SLOT of rx indication %u %u\n", rx_ind->sfn, rx_ind->slot);
-      put_queue(&gnb_rx_ind_queue, rx_ind);
-      return;
-    }
-
-    UL_INFO.rx_ind = *rx_ind;
-    UL_INFO.crc_ind = *crc_ind;
-    UL_INFO.module_id = UL_info->module_id;
-    UL_INFO.CC_id = UL_info->CC_id;
   }
-  else
+  UL_info->rx_ind.number_of_pdus = 0;
+  UL_info->crc_ind.number_crcs = 0;
+}
+
+static void free_unqueued_nfapi_indications(nfapi_nr_rach_indication_t *rach_ind,
+                                            nfapi_nr_uci_indication_t *uci_ind,
+                                            nfapi_nr_rx_data_indication_t *rx_ind,
+                                            nfapi_nr_crc_indication_t *crc_ind) {
+  if (rach_ind && rach_ind->number_of_pdus > 0)
   {
-    UL_INFO.rx_ind = UL_info->rx_ind;
-    UL_INFO.crc_ind = UL_info->crc_ind;
-    UL_INFO.module_id = UL_info->module_id;
-    UL_INFO.CC_id = UL_info->CC_id;
+    for(int i = 0; i < rach_ind->number_of_pdus; i++)
+    {
+      free(rach_ind->pdu_list[i].preamble_list);
+      rach_ind->pdu_list[i].preamble_list = NULL;
+    }
+    free(rach_ind->pdu_list);
+    rach_ind->pdu_list = NULL;
+    free(rach_ind);
+    rach_ind = NULL;
   }
+  if (uci_ind && uci_ind->num_ucis > 0)
+  {
+    for (int i = 0; i < uci_ind->num_ucis; i++) {
+      switch (uci_ind->uci_list[i].pdu_type) {
+        case NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE:
+          if (uci_ind->uci_list[i].pucch_pdu_format_0_1.harq) {
+            free(uci_ind->uci_list[i].pucch_pdu_format_0_1.harq->harq_list);
+            uci_ind->uci_list[i].pucch_pdu_format_0_1.harq->harq_list = NULL;
+          }
+          free(uci_ind->uci_list[i].pucch_pdu_format_0_1.harq);
+          uci_ind->uci_list[i].pucch_pdu_format_0_1.harq = NULL;
+          free(uci_ind->uci_list[i].pucch_pdu_format_0_1.sr);
+          uci_ind->uci_list[i].pucch_pdu_format_0_1.sr = NULL;
+          break;
 
-  UL_INFO.frame = UL_INFO.rx_ind.sfn;
-  UL_INFO.slot = UL_INFO.rx_ind.slot;
-  UL_INFO.module_id = UL_info->module_id;
-  UL_INFO.CC_id = UL_info->CC_id;
-  LOG_D(NR_MAC, " UL_info frame slot vs rx_ind frame slot vs crc_ind slot frame slot = %u %u vs %u %u vs %u %u\n",
-                  UL_info->frame, UL_info->slot,
-                  UL_INFO.rx_ind.sfn, UL_INFO.rx_ind.slot,
-                  UL_INFO.crc_ind.sfn, UL_INFO.crc_ind.slot
-                  );
+        case NFAPI_NR_UCI_FORMAT_2_3_4_PDU_TYPE:
+          free(uci_ind->uci_list[i].pucch_pdu_format_2_3_4.harq.harq_payload);
+          free(uci_ind->uci_list[i].pucch_pdu_format_2_3_4.csi_part1.csi_part1_payload);
+          free(uci_ind->uci_list[i].pucch_pdu_format_2_3_4.csi_part2.csi_part2_payload);
+          break;
+      }
+    }
+    free(uci_ind->uci_list);
+    uci_ind->uci_list = NULL;
+    free(uci_ind);
+    uci_ind = NULL;
+  }
+  if (rx_ind && rx_ind->number_of_pdus > 0)
+  {
+    free(rx_ind->pdu_list);
+    rx_ind->pdu_list = NULL;
+    free(rx_ind);
+    rx_ind = NULL;
+  }
+  if (crc_ind && crc_ind->number_crcs > 0)
+  {
+    free(crc_ind->crc_list);
+    crc_ind->crc_list = NULL;
+    free(crc_ind);
+    crc_ind = NULL;
+  }
+}
 
-  if (UL_INFO.rx_ind.number_of_pdus > 0 && UL_INFO.crc_ind.number_crcs > 0) {
-    for (int i = 0; i < UL_INFO.rx_ind.number_of_pdus; i++) {
-      int j;
-      for (j = 0; j < UL_INFO.crc_ind.number_crcs; j++) {
-        // find crc_indication j corresponding rx_indication i
-        const nfapi_nr_rx_data_pdu_t *rx = &UL_INFO.rx_ind.pdu_list[i];
-        const nfapi_nr_crc_t *crc = &UL_INFO.crc_ind.crc_list[j];
-        LOG_D(NR_PHY,
-              "UL_INFO.crc_ind.pdu_list[%d].rnti:%04x "
-              "UL_INFO.rx_ind.pdu_list[%d].rnti:%04x\n",
-              j,
-              crc->rnti,
-              i,
-              rx->rnti);
+static void remove_crc_pdu(nfapi_nr_crc_indication_t *crc_ind, int index) {
+  AssertFatal(index >= 0, "Invalid index %d\n", index);
+  AssertFatal(index < crc_ind->number_crcs, "Invalid index %d\n", index);
+  AssertFatal(crc_ind->number_crcs > 0, "Invalid crc_ind->number_crcs %d\n", crc_ind->number_crcs);
 
-        if (crc->rnti != rx->rnti)
-        {
-          LOG_D(NR_MAC, "mis-match between CRC rnti %04x and RX rnit %04x\n",  crc->rnti,  rx->rnti);
-          continue;
-        }
+  memmove(crc_ind->crc_list + index,
+          crc_ind->crc_list + index + 1,
+          sizeof(*crc_ind->crc_list) * (crc_ind->number_crcs - index - 1));
+  crc_ind->number_crcs--;
+}
 
-        LOG_D(NR_MAC,
-              "%4d.%2d Calling rx_sdu (CRC %s/tb_crc_status %d)\n",
-              UL_INFO.frame,
-              UL_INFO.slot,
-              crc->tb_crc_status ? "error" : "ok",
-              crc->tb_crc_status);
+static void remove_rx_pdu(nfapi_nr_rx_data_indication_t *rx_ind, int index) {
+  AssertFatal(index >= 0, "Invalid index %d\n", index);
+  AssertFatal(index < rx_ind->number_of_pdus, "Invalid index %d\n", index);
+  AssertFatal(rx_ind->number_of_pdus > 0, "Invalid rx_ind->number_of_pdus %d\n", rx_ind->number_of_pdus);
 
-        /* if CRC passes, pass PDU, otherwise pass NULL as error indication */
-        nr_rx_sdu(UL_INFO.module_id,
-                  UL_INFO.CC_id,
-                  UL_INFO.rx_ind.sfn,
-                  UL_INFO.rx_ind.slot,
-                  rx->rnti,
-                  crc->tb_crc_status ? NULL : rx->pdu,
-                  rx->pdu_length,
-                  rx->timing_advance,
-                  rx->ul_cqi,
-                  rx->rssi);
-        handle_nr_ul_harq(UL_INFO.CC_id, UL_INFO.module_id, UL_INFO.frame, UL_INFO.slot, crc);
+  memmove(rx_ind->pdu_list + index,
+          rx_ind->pdu_list + index + 1,
+          sizeof(*rx_ind->pdu_list) * (rx_ind->number_of_pdus - index - 1));
+  rx_ind->number_of_pdus--;
+}
+
+static bool crc_ind_has_rnti(nfapi_nr_crc_indication_t *crc_ind, uint16_t rnti) {
+  for (int i = 0; i < crc_ind->number_crcs; i++) {
+    if (rnti == crc_ind->crc_list[i].rnti) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static bool rx_ind_has_rnti(nfapi_nr_rx_data_indication_t *rx_ind, uint16_t rnti) {
+  for (int i = 0; i < rx_ind->number_of_pdus; i++) {
+    if (rnti == rx_ind->pdu_list[i].rnti) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static void match_crc_rx_pdu(nfapi_nr_rx_data_indication_t *rx_ind, nfapi_nr_crc_indication_t *crc_ind) {
+  AssertFatal(crc_ind->number_crcs > 0 &&  rx_ind->number_of_pdus > 0,
+              "Invalid number of crc_ind->number_crcs %d or rx_ind->number_of_pdus %d\n",
+              crc_ind->number_crcs, rx_ind->number_of_pdus);
+  if (crc_ind->number_crcs > rx_ind->number_of_pdus) {
+    nfapi_nr_crc_indication_t *crc_ind_unmatched = calloc(1, sizeof(*crc_ind_unmatched));
+    crc_ind_unmatched->header = crc_ind->header;
+    crc_ind_unmatched->sfn = crc_ind->sfn;
+    crc_ind_unmatched->slot = crc_ind->slot;
+    crc_ind_unmatched->number_crcs = 0;
+    crc_ind_unmatched->crc_list = NULL;
+    for (int i = 0; i < crc_ind->number_crcs; i++) {
+      if (!rx_ind_has_rnti(rx_ind, crc_ind->crc_list[i].rnti)) {
+          LOG_I(NR_MAC, "crc_ind->crc_list[%d].rnti %x does not match any rx_ind pdu rnti\n",
+                i, crc_ind->crc_list[i].rnti);
+          crc_ind_unmatched->number_crcs++;
+          if (crc_ind_unmatched->crc_list == NULL) {
+            crc_ind_unmatched->crc_list = malloc(sizeof(nfapi_nr_crc_t));
+          }
+          else {
+            crc_ind_unmatched->crc_list = realloc(crc_ind_unmatched->crc_list,
+                                                  sizeof(nfapi_nr_crc_t) * crc_ind_unmatched->number_crcs);
+          }
+          crc_ind_unmatched->crc_list[crc_ind_unmatched->number_crcs - 1] = crc_ind->crc_list[i];
+          remove_crc_pdu(crc_ind, i);
+      }
+      if (crc_ind->number_crcs == rx_ind->number_of_pdus) {
         break;
-      } //    for (j=0;j<UL_INFO.crc_ind.number_crcs;j++)
-      if (get_softmodem_params()->emulate_l1)
-      {
-        int last = UL_INFO.crc_ind.number_crcs - 1;
-        if (j < last)
-        {
-          crc_ind->crc_list[j] = crc_ind->crc_list[last];
-          UL_INFO.crc_ind.number_crcs--;
-        }
-        else if (j == last)
-        {
-          UL_INFO.crc_ind.number_crcs--;
-        }
-
-        last = UL_INFO.rx_ind.number_of_pdus - 1;
-        if (i < last)
-        {
-          rx_ind->pdu_list[i] = rx_ind->pdu_list[last];
-          UL_INFO.rx_ind.number_of_pdus--;
-          i--;
-        }
-        else if (i == last)
-        {
-          UL_INFO.rx_ind.number_of_pdus--;
-        }
-      }
-    } //   for (i=0;i<UL_INFO.rx_ind.number_of_pdus;i++)
-    if (get_softmodem_params()->emulate_l1)
-    {
-      if (UL_INFO.crc_ind.number_crcs > 0)
-      {
-        crc_ind->number_crcs = UL_INFO.crc_ind.number_crcs;
-        requeue(&gnb_crc_ind_queue, crc_ind);
-      }
-
-      if (UL_INFO.rx_ind.number_of_pdus > 0)
-      {
-        rx_ind->number_of_pdus = UL_INFO.rx_ind.number_of_pdus;
-        requeue(&gnb_rx_ind_queue, rx_ind);
-      }
-
-      if (UL_INFO.crc_ind.number_crcs == 0)
-      {
-        free(crc_ind->crc_list);
-        crc_ind->crc_list = NULL;
-        free(crc_ind);
-        crc_ind = NULL;
-      }
-      if (UL_INFO.rx_ind.number_of_pdus == 0)
-      {
-        free(rx_ind->pdu_list);
-        rx_ind->pdu_list = NULL;
-        free(rx_ind);
-        rx_ind = NULL;
       }
     }
-    else
+    AssertFatal(crc_ind_unmatched->number_crcs > 0, "The nubmer of unmatched crc_ind pdus %d <= 0\n",
+                crc_ind_unmatched->number_crcs);
+    if (!requeue(&gnb_crc_ind_queue, crc_ind_unmatched))
     {
-      UL_info->crc_ind.number_crcs = 0;
-      UL_info->rx_ind.number_of_pdus = 0;
+      LOG_E(NR_PHY, "requeue failed for crc_ind_unmatched.\n");
+      free(crc_ind_unmatched);
+      crc_ind_unmatched = NULL;
     }
-  } else if ((UL_INFO.rx_ind.number_of_pdus != 0)
-             || (UL_INFO.crc_ind.number_crcs != 0)) {
-     LOG_E(NR_PHY,
-          "hoping not to have mis-match between CRC ind and RX ind - "
-          "hopefully the missing message is coming shortly "
-          "rx_ind:%d(SFN/SL:%d/%d) crc_ind:%d(SFN/SL:%d/%d) \n",
-          UL_INFO.rx_ind.number_of_pdus,
-          UL_INFO.rx_ind.sfn,
-          UL_INFO.rx_ind.slot,
-          UL_INFO.crc_ind.number_crcs,
-          UL_INFO.crc_ind.sfn,
-          UL_INFO.crc_ind.slot);
+  }
+  else if (crc_ind->number_crcs < rx_ind->number_of_pdus) {
+    nfapi_nr_rx_data_indication_t *rx_ind_unmatched = calloc(1, sizeof(*rx_ind_unmatched));
+    rx_ind_unmatched->header = rx_ind->header;
+    rx_ind_unmatched->sfn = rx_ind->sfn;
+    rx_ind_unmatched->slot = rx_ind->slot;
+    rx_ind_unmatched->number_of_pdus = 0;
+    rx_ind_unmatched->pdu_list = NULL;
+    for (int i = 0; i < rx_ind->number_of_pdus; i++) {
+      if (!crc_ind_has_rnti(crc_ind, rx_ind->pdu_list[i].rnti)) {
+        LOG_I(NR_MAC, "rx_ind->pdu_list[%d].rnti %d does not match any crc_ind pdu rnti\n",
+              i, rx_ind->pdu_list[i].rnti);
+        rx_ind_unmatched->number_of_pdus++;
+        if (rx_ind_unmatched->pdu_list == NULL) {
+          rx_ind_unmatched->pdu_list = malloc(sizeof(nfapi_nr_rx_data_pdu_t));
+        }
+        else {
+          rx_ind_unmatched->pdu_list = realloc(rx_ind_unmatched->pdu_list,
+                                             sizeof(nfapi_nr_rx_data_pdu_t) * rx_ind_unmatched->number_of_pdus);
+        }
+        rx_ind_unmatched->pdu_list[rx_ind_unmatched->number_of_pdus - 1] = rx_ind->pdu_list[i];
+        remove_rx_pdu(rx_ind, i);
+      }
+      if (rx_ind->number_of_pdus == crc_ind->number_crcs) {
+        break;
+      }
+    }
+    AssertFatal(rx_ind_unmatched->number_of_pdus > 0, "The nubmer of unmatched rx_ind pdus %d <= 0\n",
+                rx_ind_unmatched->number_of_pdus);
+    if (!requeue(&gnb_rx_ind_queue, rx_ind_unmatched))
+    {
+      LOG_E(NR_PHY, "requeue failed for rx_ind_unmatched.\n");
+      free(rx_ind_unmatched);
+      rx_ind_unmatched = NULL;
+    }
+  }
+  else {
+    LOG_E(NR_MAC, "The number of crc pdus %d = the number of rx pdus %d\n",
+          crc_ind->number_crcs, rx_ind->number_of_pdus);
   }
 }
 
 void NR_UL_indication(NR_UL_IND_t *UL_info) {
-  AssertFatal(UL_info!=NULL,"UL_INFO is null\n");
+  AssertFatal(UL_info!=NULL,"UL_info is null\n");
 #ifdef DUMP_FAPI
   dump_ul(UL_info);
 #endif
@@ -440,17 +407,60 @@ void NR_UL_indication(NR_UL_IND_t *UL_info) {
   NR_IF_Module_t   *ifi        = nr_if_inst[module_id];
   gNB_MAC_INST     *mac        = RC.nrmac[module_id];
   LOG_D(NR_PHY,"SFN/SLOT:%d.%d module_id:%d CC_id:%d UL_info[rach_pdus:%zu rx_ind:%zu crcs:%zu]\n",
-        UL_info->frame,UL_info->slot,
-        module_id,CC_id, gnb_rach_ind_queue.num_items,
-        gnb_rx_ind_queue.num_items, gnb_crc_ind_queue.num_items);
+        UL_info->frame, UL_info->slot,
+        module_id, CC_id,
+        gnb_rach_ind_queue.num_items,
+        gnb_rx_ind_queue.num_items,
+        gnb_crc_ind_queue.num_items);
+
+  nfapi_nr_rach_indication_t *rach_ind = NULL;
+  nfapi_nr_uci_indication_t *uci_ind = NULL;
+  nfapi_nr_rx_data_indication_t *rx_ind = NULL;
+  nfapi_nr_crc_indication_t *crc_ind = NULL;
+  if (get_softmodem_params()->emulate_l1)
+  {
+    if (gnb_rach_ind_queue.num_items > 0) {
+      LOG_I(NR_MAC, "gnb_rach_ind_queue size = %zu\n", gnb_rach_ind_queue.num_items);
+      rach_ind = get_queue(&gnb_rach_ind_queue);
+      UL_info->rach_ind = *rach_ind;
+    }
+    if (gnb_uci_ind_queue.num_items > 0) {
+      LOG_I(NR_MAC, "gnb_uci_ind_queue size = %zu\n", gnb_uci_ind_queue.num_items);
+      uci_ind = get_queue(&gnb_uci_ind_queue);
+      UL_info->uci_ind = *uci_ind;
+    }
+    if (gnb_rx_ind_queue.num_items > 0 && gnb_crc_ind_queue.num_items > 0) {
+      LOG_I(NR_MAC, "gnb_rx_ind_queue size = %zu and gnb_crc_ind_queue size = %zu\n",
+            gnb_rx_ind_queue.num_items, gnb_crc_ind_queue.num_items);
+      rx_ind = get_queue(&gnb_rx_ind_queue);
+      int sfn_slot = NFAPI_SFNSLOT2HEX(rx_ind->sfn, rx_ind->slot);
+      crc_ind = unqueue_matching(&gnb_crc_ind_queue,
+                                 MAX_QUEUE_SIZE,
+                                 crc_sfn_slot_matcher,
+                                 &sfn_slot);
+      if (!crc_ind) {
+        LOG_I(NR_PHY, "No crc indication with the same SFN SLOT of rx indication %u %u\n", rx_ind->sfn, rx_ind->slot);
+        requeue(&gnb_rx_ind_queue, rx_ind);
+      }
+      else {
+        UL_info->rx_ind = *rx_ind;
+        UL_info->crc_ind = *crc_ind;
+        if (crc_ind->number_crcs != rx_ind->number_of_pdus) {
+          match_crc_rx_pdu(&UL_info->rx_ind, &UL_info->crc_ind);
+        }
+      }
+    }
+  }
 
   handle_nr_rach(UL_info);
-  
   handle_nr_uci(UL_info);
   // clear UL DCI prior to handling ULSCH
   mac->UL_dci_req[CC_id].numPdus = 0;
   handle_nr_ulsch(UL_info);
 
+  if (get_softmodem_params()->emulate_l1) {
+    free_unqueued_nfapi_indications(rach_ind, uci_ind, rx_ind, crc_ind);
+  }
   if (NFAPI_MODE != NFAPI_MODE_PNF) {
 
     if (ifi->CC_mask==0) {