diff --git a/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c b/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c
index 2e91274156..d0b174404e 100644
--- a/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c
+++ b/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c
@@ -145,7 +145,7 @@ static void save_nr_measurement_info(nfapi_nr_dl_tti_request_t *dl_tti_request)
         nfapi_nr_dl_tti_request_pdu_t *pdu_list = &dl_tti_request->dl_tti_request_body.dl_tti_pdu_list[i];
         if (pdu_list->PDUType == NFAPI_NR_DL_TTI_SSB_PDU_TYPE)
         {
-            LOG_I(NR_PHY, "Cell_id: %d, the ssb_block_idx %d, sc_offset: %d and payload %d\n",
+            LOG_D(NR_PHY, "Cell_id: %d, the ssb_block_idx %d, sc_offset: %d and payload %d\n",
                 pdu_list->ssb_pdu.ssb_pdu_rel15.PhysCellId,
                 pdu_list->ssb_pdu.ssb_pdu_rel15.SsbBlockIndex,
                 pdu_list->ssb_pdu.ssb_pdu_rel15.SsbSubcarrierOffset,
@@ -163,8 +163,8 @@ static void save_nr_measurement_info(nfapi_nr_dl_tti_request_t *dl_tti_request)
     {
         LOG_E(NR_PHY, "%s: Error packing nr p7 message.\n", __FUNCTION__);
     }
-    LOG_I(NR_RRC, "Calling nsa_sendmsg_to_lte_ue to send a NR_UE_RRC_MEASUREMENT\n");
     nsa_sendmsg_to_lte_ue(buffer, pack_len, NR_UE_RRC_MEASUREMENT);
+    LOG_A(NR_RRC, "Populated NR_UE_RRC_MEASUREMENT information and sent to LTE UE\n");
 }
 
 void *nrue_standalone_pnf_task(void *context)
@@ -228,10 +228,10 @@ void *nrue_standalone_pnf_task(void *context)
             save_nr_measurement_info(&dl_tti_request);
             break;
           case NFAPI_NR_PHY_MSG_TYPE_TX_DATA_REQUEST:
-            LOG_I(NR_PHY, "Received an NFAPI_NR_PHY_MSG_TYPE_TX_DATA_REQUEST message. \n");
+            LOG_D(NR_PHY, "Received an NFAPI_NR_PHY_MSG_TYPE_TX_DATA_REQUEST message. \n");
             break;
           case NFAPI_NR_PHY_MSG_TYPE_UL_DCI_REQUEST:
-            LOG_I(NR_PHY, "Received an NFAPI_NR_PHY_MSG_TYPE_UL_DCI_REQUEST message. \n");
+            LOG_D(NR_PHY, "Received an NFAPI_NR_PHY_MSG_TYPE_UL_DCI_REQUEST message. \n");
             break;
           case NFAPI_NR_PHY_MSG_TYPE_UL_TTI_REQUEST:
             LOG_D(NR_PHY, "Received an NFAPI_NR_PHY_MSG_TYPE_UL_TTI_REQUEST message. \n");
diff --git a/openair2/RRC/LTE/MESSAGES/asn1_msg.c b/openair2/RRC/LTE/MESSAGES/asn1_msg.c
index 9ecc9fe265..3d8160b2ea 100644
--- a/openair2/RRC/LTE/MESSAGES/asn1_msg.c
+++ b/openair2/RRC/LTE/MESSAGES/asn1_msg.c
@@ -2415,8 +2415,6 @@ do_RRCConnectionReconfigurationComplete(
 )
 //------------------------------------------------------------------------------
 {
-  LOG_I(RRC, "Melissa, entered do_RRCConnectionReconfigurationComplete \n");
-
   asn_enc_rval_t enc_rval;
   LTE_UL_DCCH_Message_t ul_dcch_msg;
   LTE_RRCConnectionReconfigurationComplete_t *rrcConnectionReconfigurationComplete;
@@ -2429,7 +2427,7 @@ do_RRCConnectionReconfigurationComplete(
     LTE_RRCConnectionReconfigurationComplete__criticalExtensions_PR_rrcConnectionReconfigurationComplete_r8;
   if (str != NULL) {
     assign_scg_ConfigResponseNR_r15(rrcConnectionReconfigurationComplete, str);
-    LOG_I(RRC, "Melissa we finished assign_scg_ConfigResponseNR_r15\n");
+    LOG_D(RRC, "Successfully assigned scg_ConfigResponseNR_r15\n");
   }
   else {
     rrcConnectionReconfigurationComplete->criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.nonCriticalExtension=NULL;
diff --git a/openair2/RRC/LTE/rrc_UE.c b/openair2/RRC/LTE/rrc_UE.c
index 6b13c6d578..0504a7b68a 100644
--- a/openair2/RRC/LTE/rrc_UE.c
+++ b/openair2/RRC/LTE/rrc_UE.c
@@ -98,6 +98,8 @@ static int from_nr_ue_fd = -1;
 static int to_nr_ue_fd = -1;
 int slrb_id;
 int send_ue_information = 0;
+/* Melissa, this is a hack. Just created a ctxt global. Need to pass to process_nr_nsa_msg(). */
+protocol_ctxt_t ctxt_g;
 
 // for malloc_clear
 #include "PHY/defs_UE.h"
@@ -571,7 +573,6 @@ void rrc_ue_generate_RRCConnectionReconfigurationComplete(const protocol_ctxt_t
                                                           const uint8_t Transaction_id,
                                                           OCTET_STRING_t *str) {
   uint8_t buffer[RRC_BUF_SIZE];
-  LOG_I(RRC, "Melissa, calling do_RRCConnectionReconfigurationComplete \n");
   size_t size = do_RRCConnectionReconfigurationComplete(ctxt_pP, buffer, sizeof(buffer), Transaction_id, str);
   LOG_I(RRC,PROTOCOL_RRC_CTXT_UE_FMT" Logical Channel UL-DCCH (SRB1), Generating RRCConnectionReconfigurationComplete (bytes %zu, eNB_index %d)\n",
         PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP), size, eNB_index);
@@ -847,8 +848,9 @@ rrc_ue_process_measConfig(
                                                             sizeof(buffer));
             AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %zu)!\n",
                           enc_rval.failed_type->name, enc_rval.encoded);
-            LOG_I(RRC, "Calling nsa_sendmsg_to_nr_ue to send a RRC_MEASUREMENT_PROCEDURE\n");
             nsa_sendmsg_to_nrue(buffer, (enc_rval.encoded + 7)/8, RRC_MEASUREMENT_PROCEDURE);
+            LOG_A(RRC, "Encoded measurement object %zu bits (%zu bytes) and sent to NR UE\n",
+                  enc_rval.encoded, (enc_rval.encoded + 7)/8);
           }
           LOG_D(RRC, "Adding measurement object [%d][%ld]\n", eNB_index, ind);
           ue->MeasObj[eNB_index][ind-1]=measObj;
@@ -1952,9 +1954,9 @@ rrc_ue_process_rrcConnectionReconfiguration(
                       nr_RadioBearer->size,
                       nr_SecondaryCellGroup->size);
 
-          LOG_I(RRC, "Calling nsa_sendmsg_to_nr_ue to send an RRC_CONFIG_COMPLETE_REQ\n");
           nsa_sendmsg_to_nrue(&msg, sizeof(msg), RRC_CONFIG_COMPLETE_REQ);
-          #if 0
+          LOG_A(RRC, "Sent RRC_CONFIG_COMPLETE_REQ to the NR UE\n");
+          #if 0 //Melissa, this is a hack. We need the transaction_id from latest dl_dcch_msg the LTE UE received. (Ln 6658)
           LTE_RRCConnectionReconfiguration_t *rrc = &UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].dl_dcch_msg->message.
                                                     choice.c1.choice.rrcConnectionReconfiguration;
           if (rrc != NULL) {
@@ -2485,6 +2487,8 @@ rrc_ue_decode_dcch(
                                       nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->
                                       nonCriticalExtension->requestedFreqBandsNR_MRDC_r15;
                 nsa_sendmsg_to_nrue(requestedFreqBandsNR->buf, requestedFreqBandsNR->size, NRUE_CAPABILITY_ENQUIRY);
+                LOG_A(RRC, "Second ueCapabilityEnquiry (request for NR capabilities) sent to NR UE with size %zu\n",
+                      requestedFreqBandsNR->size);
                 // Save ueCapabilityEnquiry so we can use in nsa mode after nrUE response is received
                 UE_RRC_INFO *info = &UE_rrc_inst[ctxt_pP->module_id].Info[eNB_indexP];
                 if (info->dl_dcch_msg != NULL) {
@@ -2499,6 +2503,7 @@ rrc_ue_decode_dcch(
                                     nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->
                                     nonCriticalExtension->requestedFreqBandsNR_MRDC_r15;
               nsa_sendmsg_to_nrue(requestedFreqBandsNR->buf, requestedFreqBandsNR->size, UE_CAPABILITY_ENQUIRY);
+              LOG_A(RRC, "Initial ueCapabilityEnquiry sent to NR UE with size %zu\n", requestedFreqBandsNR->size);
               // Save ueCapabilityEnquiry so we can use in nsa mode after nrUE response is received
               UE_RRC_INFO *info = &UE_rrc_inst[ctxt_pP->module_id].Info[eNB_indexP];
               if (info->dl_dcch_msg != NULL) {
@@ -4864,6 +4869,7 @@ void *rrc_ue_task( void *args_p ) {
     itti_receive_msg (TASK_RRC_UE, &msg_p);
     instance = ITTI_MSG_DESTINATION_INSTANCE (msg_p);
     ue_mod_id = UE_INSTANCE_TO_MODULE_ID(instance);
+    ctxt_g = ctxt;
 
     /* TODO: Add case to handle nr-UE messages we want from nrUE RRC layer */
     switch (ITTI_MSG_ID(msg_p)) {
@@ -6541,8 +6547,6 @@ void process_nr_nsa_msg(nsa_msg_t *msg, int msg_len)
     uint8_t *const msg_buffer = msg->msg_buffer;
     msg_len -= sizeof(msg->msg_type);
     bool received_nr_msg = true;
-    protocol_ctxt_t ctxt;
-    memset(&ctxt, 0, sizeof(ctxt));
 
     switch (msg_type)
     {
@@ -6557,7 +6561,7 @@ void process_nr_nsa_msg(nsa_msg_t *msg, int msg_len)
             AssertFatal(msg_len <= sizeof(nrue_cap_buf->mesg), "msg_len = %d\n", msg_len);
             memcpy(nrue_cap_buf->mesg, msg_buffer, msg_len);
             nrue_cap_buf->mesg_len = msg_len;
-            UE_RRC_INFO *info = &UE_rrc_inst[ctxt.module_id].Info[0];
+            UE_RRC_INFO *info = &UE_rrc_inst[ctxt_g.module_id].Info[0];
             nrue_cap_buf->dl_dcch_msg = info->dl_dcch_msg;
             info->dl_dcch_msg = NULL;
             message_p = itti_alloc_new_message (TASK_RRC_UE, 0, RRC_NRUE_CAP_INFO_IND);
@@ -6587,7 +6591,7 @@ void process_nr_nsa_msg(nsa_msg_t *msg, int msg_len)
             rrc_dcch_data_copy_t *dl_dcch_buffer = itti_malloc (TASK_RRC_NSA_UE,
                                                                 TASK_RRC_UE,
                                                                 sizeof(rrc_dcch_data_copy_t));
-            UE_RRC_INFO *info = &UE_rrc_inst[ctxt.module_id].Info[0];
+            UE_RRC_INFO *info = &UE_rrc_inst[ctxt_g.module_id].Info[0];
             dl_dcch_buffer->dl_dcch_msg = info->dl_dcch_msg;
             info->dl_dcch_msg = NULL;
             message_p = itti_alloc_new_message (TASK_RRC_UE, 0, RRC_DCCH_DATA_COPY_IND);
@@ -6650,13 +6654,13 @@ void process_nr_nsa_msg(nsa_msg_t *msg, int msg_len)
             OCTET_STRING_fromBuf(&rrcConfigurationComplete,
                                 (const char *)msg_buffer,
                                 msg_len);
-            #if 0
+            #if 0 //Melissa, this is a hack. We need the transaction_id from latest dl_dcch_msg the LTE UE received. (Ln 6658)
             LTE_RRCConnectionReconfiguration_t *rrc_saved = &UE_rrc_inst[ctxt.module_id].Info[0].dl_dcch_msg->message.
                                                             choice.c1.choice.rrcConnectionReconfiguration;
             uint8_t t_id = rrc_saved->rrc_TransactionIdentifier;
             rrc_saved = NULL;
             #endif
-            rrc_ue_generate_RRCConnectionReconfigurationComplete(&ctxt, ctxt.eNB_index, 0, &rrcConfigurationComplete);
+            rrc_ue_generate_RRCConnectionReconfigurationComplete(&ctxt_g, ctxt_g.eNB_index, 0, &rrcConfigurationComplete);
             break;
         }
         default:
diff --git a/openair2/RRC/LTE/rrc_eNB.c b/openair2/RRC/LTE/rrc_eNB.c
index 0bf7b081e8..cbbdc37684 100644
--- a/openair2/RRC/LTE/rrc_eNB.c
+++ b/openair2/RRC/LTE/rrc_eNB.c
@@ -1339,7 +1339,7 @@ rrc_eNB_generate_NR_UECapabilityEnquiry(
            rrc_eNB_get_next_transaction_identifier(ctxt_pP->module_id),
            eutra_band,
            nr_band);
-  LOG_I(RRC,
+  LOG_A(RRC,
         PROTOCOL_RRC_CTXT_UE_FMT" Logical Channel DL-DCCH, Generate NR UECapabilityEnquiry (bytes %d)\n",
         PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP),
         size);
@@ -3464,6 +3464,7 @@ void rrc_eNB_generate_defaultRRCConnectionReconfiguration(const protocol_ctxt_t
     ReportConfig_NR->reportConfig.choice.reportConfigInterRAT.ext7->reportQuantityCellNR_r15->ss_rsrq = TRUE;
     ReportConfig_NR->reportConfig.choice.reportConfigInterRAT.ext7->reportQuantityCellNR_r15->ss_sinr = TRUE;
     ASN_SEQUENCE_ADD(&ReportConfig_list->list, ReportConfig_NR);
+    LOG_A(RRC, "Generating RRCCConnectionReconfigurationRequest (NRUE Measurement Report Request).\n");
   }
 
   //  LTE_RRCConnectionReconfiguration->criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.measConfig->reportConfigToAddModList = ReportConfig_list;
@@ -4443,14 +4444,7 @@ static int encode_CG_ConfigInfo(
     = calloc(1,sizeof(struct NR_CG_ConfigInfo_IEs));
   AssertFatal(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo != NULL,
               "failed to allocate memory for cg_configinfo_IEs");
-  /* Melissa Elkadi: None of the three following if statments are true. In this case,
-     we never fill the container and in the gNB we are never parsing the UE_capability_info.
-     I believe this is happening because we are not properly sending the UE_Capability_Info
-     over from the LTE UE. We received the info from the NR UE but we dont fill the container
-     properly? */
-  LOG_I(RRC,"Got here Melissa Elkadi %s():%d\n", __FUNCTION__, __LINE__);
   if(ue_context_pP->ue_context.UE_Capability_MRDC) {
-    LOG_I(RRC,"Got here Melissa Elkadi%s():%d\n", __FUNCTION__, __LINE__);
     RAT_Container_count++;
     enc_rval = uper_encode_to_buffer(&asn_DEF_NR_UE_MRDC_Capability,NULL,
                                      (void *)ue_context_pP->ue_context.UE_Capability_MRDC,temp_buff,ASN_MAX_ENCODE_SIZE);
@@ -4465,7 +4459,6 @@ static int encode_CG_ConfigInfo(
   }
 
   if(ue_context_pP->ue_context.UE_Capability_nr) {
-    LOG_I(RRC,"Got here Melissa Elkadi %s():%d\n", __FUNCTION__, __LINE__);
     RAT_Container_count++;
     enc_rval = uper_encode_to_buffer(&asn_DEF_NR_UE_NR_Capability,NULL,
                                      (void *)ue_context_pP->ue_context.UE_Capability_nr,temp_buff,ASN_MAX_ENCODE_SIZE);
@@ -4480,7 +4473,6 @@ static int encode_CG_ConfigInfo(
   }
 
   if (RAT_Container_count) {
-    LOG_I(RRC,"Got here Melissa Elkadi %s():%d\n", __FUNCTION__, __LINE__);
     cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->ue_CapabilityInfo = calloc(1,sizeof( OCTET_STRING_t));
     AssertFatal(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo-> ue_CapabilityInfo != NULL, "failed to allocate memory for ue_capabilityinfo");
     ue_cap_rat_container_list = calloc(1,sizeof(NR_UE_CapabilityRAT_ContainerList_t));
@@ -4632,7 +4624,7 @@ rrc_eNB_process_MeasurementReport(
                  sizeof(transport_layer_addr_t));
         }
 
-        LOG_I(RRC,
+        LOG_A(RRC,
               "[eNB %d] frame %d subframe %d: UE rnti %x switching to NSA mode\n",
               ctxt_pP->module_id, ctxt_pP->frame, ctxt_pP->subframe, ctxt_pP->rnti);
         itti_send_msg_to_task(TASK_X2AP, ENB_MODULE_ID_TO_INSTANCE(ctxt_pP->module_id), msg);
@@ -7707,12 +7699,11 @@ rrc_eNB_decode_dcch(
         if (ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.
             present ==
             LTE_RRCConnectionReconfigurationComplete__criticalExtensions_PR_rrcConnectionReconfigurationComplete_r8) {
-            LOG_I(RRC, "Melissa, the present is set for NR woowho! The status is %d\n",ue_context_p->ue_context.Status);
           /*NN: revise the condition */
           /*FK: left the condition as is for the case MME is used (S1 mode) but setting  dedicated_DRB = 1 otherwise (noS1 mode) so that no second RRCReconfiguration message activationg more DRB is sent as this causes problems with the nasmesh driver.*/
           int flexran_agent_handover = 0;
 
-          if (1) {
+          if (1) { //Melissa: This is a hack. We are bypassing EPC mode here.
             if (ue_context_p->ue_context.Status == RRC_RECONFIGURED) {
               dedicated_DRB = 1;
               LOG_I(RRC,
@@ -7762,34 +7753,30 @@ rrc_eNB_decode_dcch(
                     PROTOCOL_RRC_CTXT_UE_FMT" UE State = RRC_HO_EXECUTION (xid %ld)\n",
                     PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP),ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.rrc_TransactionIdentifier);
             } else if(ue_context_p->ue_context.Status == RRC_NR_NSA) {
-              LOG_I(RRC, "Melissa, got here %d!\n", __LINE__);
               //Looking for a condition to trigger S1AP E-RAB-Modification-indication, based on the reception of RRCConnectionReconfigurationComplete
               //including NR specific elements.
               if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                  nonCriticalExtension!=NULL) { LOG_I(RRC, "Melissa, got here %d!\n", __LINE__);
+                  nonCriticalExtension!=NULL) {
                 if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                    nonCriticalExtension->nonCriticalExtension!=NULL) { LOG_I(RRC, "Melissa, got here %d!\n", __LINE__);
+                    nonCriticalExtension->nonCriticalExtension!=NULL) {
                   if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                      nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) { LOG_I(RRC, "Melissa, got here %d!\n", __LINE__);
+                      nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) {
                     if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                        nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) { LOG_I(RRC, "Melissa, got here %d!\n", __LINE__);
+                        nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) {
                       if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                          nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) { LOG_I(RRC, "Melissa, got here %d!\n", __LINE__);
+                          nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) {
                         if (ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                            nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) { LOG_I(RRC, "Melissa, got here %d!\n", __LINE__);
+                            nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) {
                           if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
                               nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension
                               ->scg_ConfigResponseNR_r15!=NULL) {
-                            LOG_I(RRC, "Melissa, the scg_config response is not null!\n");
                             dedicated_DRB = -1;     /* put a value that does not run anything below */
                             ue_context_p->ue_context.Status = RRC_NR_NSA_RECONFIGURED;
                             /*Trigger E-RAB Modification Indication */
-                            LOG_I(RRC, "Melissa, calling rrc_eNB_send_E_RAB_Modification_Indication!\n");
                             rrc_eNB_send_E_RAB_Modification_Indication(ctxt_pP, ue_context_p);
-                            LOG_I(RRC, "Melissa, calling rrc_eNB_process_reconfiguration_complete_endc!\n");
                             /* send reconfiguration complete to gNB */
                             rrc_eNB_process_reconfiguration_complete_endc(ctxt_pP, ue_context_p);
-                            LOG_I(RRC, "Melissa, finished rrc_eNB_process_reconfiguration_complete_endc!\n");
+                            LOG_A(RRC, "Sent rrcReconfigurationComplete to gNB\n");
                           }
                         }
                       }
@@ -8159,7 +8146,7 @@ rrc_eNB_decode_dcch(
         for (i = 0; i < ul_dcch_msg->message.choice.c1.choice.ueCapabilityInformation.criticalExtensions.choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList.list.count; i++) {
           if (ul_dcch_msg->message.choice.c1.choice.ueCapabilityInformation.criticalExtensions.choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList.list.array[i]->rat_Type ==
               LTE_RAT_Type_nr) {
-              LOG_I(RRC, "got nrUE capabilities for UE %x\n", ctxt_pP->rnti);
+              LOG_A(RRC, "got nrUE capabilities for UE %x\n", ctxt_pP->rnti);
             if(ue_context_p->ue_context.UE_Capability_nr) {
               ASN_STRUCT_FREE(asn_DEF_NR_UE_NR_Capability,ue_context_p->ue_context.UE_Capability_nr);
               ue_context_p->ue_context.UE_Capability_nr = 0;
@@ -9032,7 +9019,6 @@ void rrc_eNB_process_ENDC_x2_setup_request(int mod_id, x2ap_ENDC_setup_req_t *m)
 }
 
 void rrc_eNB_process_AdditionResponseInformation(const module_id_t enb_mod_idP, x2ap_ENDC_sgnb_addition_req_ACK_t *m) {
-  LOG_I(RRC, "Melissa Elkadi we got here %s():%d\n", __FUNCTION__, __LINE__);
   NR_CG_Config_t *CG_Config = NULL;
   {
     int i;
@@ -9478,7 +9464,6 @@ void *rrc_enb_process_itti_msg(void *notUsed) {
       break;
 
     case X2AP_ENDC_SGNB_ADDITION_REQ_ACK: {
-      LOG_I(RRC, "Melissa Elkadi we got here %s():%d\n", __FUNCTION__, __LINE__);
       rrc_eNB_process_AdditionResponseInformation(ENB_INSTANCE_TO_MODULE_ID(instance), &X2AP_ENDC_SGNB_ADDITION_REQ_ACK(msg_p));
       break;
     }
diff --git a/openair2/RRC/LTE/rrc_eNB_endc.c b/openair2/RRC/LTE/rrc_eNB_endc.c
index b8ac6eb3a9..a2792adba5 100644
--- a/openair2/RRC/LTE/rrc_eNB_endc.c
+++ b/openair2/RRC/LTE/rrc_eNB_endc.c
@@ -173,7 +173,7 @@ int rrc_eNB_generate_RRCConnectionReconfiguration_endc(protocol_ctxt_t *ctxt,
   unsigned char scg_conf_buf[4] = { 0, 0, 0, 0 };
   if (scg_group_config!=NULL) {
 	  nr.choice.setup.nr_SecondaryCellGroupConfig_r15 = scg_group_config; //&scg_conf;
-          LOG_E(RRC, "Melissa Elkadi. setting scg_group_config\n");
+          LOG_E(RRC, "setting scg_group_config\n");
   }
   else{
 	  nr.choice.setup.nr_SecondaryCellGroupConfig_r15 = &dummy_scg_conf;
@@ -201,7 +201,7 @@ int rrc_eNB_generate_RRCConnectionReconfiguration_endc(protocol_ctxt_t *ctxt,
 
   if(scg_RB_config!=NULL) {
 	  cr_1510.nr_RadioBearerConfig1_r15 = scg_RB_config;
-          LOG_E(RRC, "Melissa Elkadi. setting scg_RB_config\n");
+          LOG_E(RRC, "setting scg_RB_config\n");
   }
   else{
 	  cr_1510.nr_RadioBearerConfig1_r15 = &dummy_nr1_conf;
diff --git a/openair2/RRC/NR/MESSAGES/asn1_msg.c b/openair2/RRC/NR/MESSAGES/asn1_msg.c
index d49847d1af..8b22766cf3 100644
--- a/openair2/RRC/NR/MESSAGES/asn1_msg.c
+++ b/openair2/RRC/NR/MESSAGES/asn1_msg.c
@@ -1411,7 +1411,7 @@ do_NR_RRCReconfigurationComplete_for_nsa(
                                                   buffer_size);
   AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %lu)!\n",
                enc_rval.failed_type->name, enc_rval.encoded);
-  LOG_I(NR_RRC, "rrcReconfigurationComplete Encoded %zd bits (%zd bytes)\n", enc_rval.encoded, (enc_rval.encoded+7)/8);
+  LOG_A(NR_RRC, "rrcReconfigurationComplete Encoded %zd bits (%zd bytes)\n", enc_rval.encoded, (enc_rval.encoded+7)/8);
   return((enc_rval.encoded+7)/8);
 }
 
diff --git a/openair2/RRC/NR/rrc_gNB.c b/openair2/RRC/NR/rrc_gNB.c
index 5f6b03930d..a4f325ea13 100755
--- a/openair2/RRC/NR/rrc_gNB.c
+++ b/openair2/RRC/NR/rrc_gNB.c
@@ -339,6 +339,8 @@ void rrc_gNB_process_AdditionRequestInformation(const module_id_t gnb_mod_idP, x
   AssertFatal(cg_configinfo->criticalExtensions.choice.c1->present == NR_CG_ConfigInfo__criticalExtensions__c1_PR_cg_ConfigInfo,
               "ueCapabilityInformation not present\n");
   parse_CG_ConfigInfo(rrc,cg_configinfo,m);
+  LOG_A(NR_RRC, "Successfully parced CG_ConfigInfo of size %zu bits. (%zu bytes)\n",
+        dec_rval.consumed, (dec_rval.consumed +7/8));
 }
 
 
@@ -2433,7 +2435,7 @@ void *rrc_gnb_task(void *args_p) {
         break;
 
       case X2AP_ENDC_SGNB_RECONF_COMPLETE:
-        LOG_I(NR_RRC, "Melissa Elkadi Handling of reconfiguration complete message at RRC gNB is pending \n");
+        LOG_A(NR_RRC, "Handling of reconfiguration complete message at RRC gNB is pending \n");
         break;
 
       case NGAP_INITIAL_CONTEXT_SETUP_REQ:
diff --git a/openair2/RRC/NR/rrc_gNB_internode.c b/openair2/RRC/NR/rrc_gNB_internode.c
index e4286e1f97..04749b2800 100644
--- a/openair2/RRC/NR/rrc_gNB_internode.c
+++ b/openair2/RRC/NR/rrc_gNB_internode.c
@@ -46,7 +46,6 @@ int parse_CG_ConfigInfo(gNB_RRC_INST *rrc, NR_CG_ConfigInfo_t *CG_ConfigInfo, x2
         NR_CG_ConfigInfo_IEs_t *cg_ConfigInfo = CG_ConfigInfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo;
 
         if (cg_ConfigInfo->ue_CapabilityInfo) {
-          LOG_I(RRC, "Melissa Elkadi. We got here %s():%d\n", __FUNCTION__, __LINE__);
           // Decode UE-CapabilityRAT-ContainerList
           NR_UE_CapabilityRAT_ContainerList_t *UE_CapabilityRAT_ContainerList=NULL;
           UE_CapabilityRAT_ContainerList = calloc(1,sizeof(NR_UE_CapabilityRAT_ContainerList_t));
@@ -60,7 +59,6 @@ int parse_CG_ConfigInfo(gNB_RRC_INST *rrc, NR_CG_ConfigInfo_t *CG_ConfigInfo, x2
             AssertFatal(1==0,"[InterNode] Failed to decode NR_UE_CapabilityRAT_ContainerList (%zu bits), size of OCTET_STRING %lu\n",
                         dec_rval.consumed, cg_ConfigInfo->ue_CapabilityInfo->size);
           }
-          LOG_I(RRC, "Melissa Elkadi. We got here %s():%d\n", __FUNCTION__, __LINE__);
           rrc_parse_ue_capabilities(rrc,UE_CapabilityRAT_ContainerList, m,cg_ConfigInfo);
         }
 
diff --git a/openair2/RRC/NR/rrc_gNB_nsa.c b/openair2/RRC/NR/rrc_gNB_nsa.c
index f9ef7604cd..2de304067f 100644
--- a/openair2/RRC/NR/rrc_gNB_nsa.c
+++ b/openair2/RRC/NR/rrc_gNB_nsa.c
@@ -65,7 +65,6 @@ extern rlc_op_status_t nr_rrc_rlc_config_asn1_req (const protocol_ctxt_t   * con
     struct NR_CellGroupConfig__rlc_BearerToAddModList *rlc_bearer2add_list);
 
 void rrc_parse_ue_capabilities(gNB_RRC_INST *rrc, NR_UE_CapabilityRAT_ContainerList_t *UE_CapabilityRAT_ContainerList, x2ap_ENDC_sgnb_addition_req_t *m, NR_CG_ConfigInfo_IEs_t  *cg_config_info) {
-  LOG_I(RRC, "Melissa Elkadi. We got here %s():%d\n", __FUNCTION__, __LINE__);
   struct rrc_gNB_ue_context_s        *ue_context_p = NULL;
 
   OCTET_STRING_t *ueCapabilityRAT_Container_nr=NULL;
@@ -125,6 +124,7 @@ void rrc_parse_ue_capabilities(gNB_RRC_INST *rrc, NR_UE_CapabilityRAT_ContainerL
   if ( LOG_DEBUGFLAG(DEBUG_ASN1) && ueCapabilityRAT_Container_MRDC != NULL ) {
     xer_fprint(stdout, &asn_DEF_NR_UE_MRDC_Capability, ue_context_p->ue_context.UE_Capability_MRDC);
   }
+  LOG_A(RRC, "Successfully decoded UE NR capabilities (NR and MRDC)\n");
 
   rrc_add_nsa_user(rrc,ue_context_p, m);
 }
@@ -134,7 +134,6 @@ RB_PROTOTYPE(rrc_nr_ue_tree_s, rrc_gNB_ue_context_s, entries,
              rrc_gNB_compare_ue_rnti_id);
 
 void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_p, x2ap_ENDC_sgnb_addition_req_t *m) {
-  LOG_I(RRC, "Melissa Elkadi. We got here %s():%d\n", __FUNCTION__, __LINE__);
   // generate nr-Config-r15 containers for LTE RRC : inside message for X2 EN-DC (CG-Config Message from 38.331)
   rrc_gNB_carrier_data_t *carrier=&rrc->carrier;
   MessageDef *msg;
@@ -281,7 +280,7 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_
       create_tunnel_req.num_tunnels    = m->nb_e_rabs_tobeadded;
       RB_INSERT(rrc_nr_ue_tree_s, &RC.nrrrc[rrc->module_id]->rrc_ue_head, ue_context_p);
       PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, rrc->module_id, GNB_FLAG_YES, ue_context_p->ue_id_rnti, 0, 0,rrc->module_id);
-      #if 0 //Melissa this is a hack.
+      #if 0 //Melissa this is a hack: we are bypassing the EPC functionality.
       gtpv1u_create_s1u_tunnel(
         ctxt.instance,
         &create_tunnel_req,
@@ -377,7 +376,7 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_
       (LTE_PMCH_InfoList_r9_t *) NULL,
       ue_context_p->ue_context.secondaryCellGroup->rlc_BearerToAddModList);
 
-  LOG_I(RRC, "Melissa Elkadi. %s:%d: done RRC PDCP/RLC ASN1 request for UE rnti %x\n", __FUNCTION__, __LINE__, ctxt.rnti);
+  LOG_I(RRC, "%s:%d: done RRC PDCP/RLC ASN1 request for UE rnti %x\n", __FUNCTION__, __LINE__, ctxt.rnti);
 
 }
 
diff --git a/openair2/RRC/NR_UE/rrc_UE.c b/openair2/RRC/NR_UE/rrc_UE.c
index fd79544f7a..86bc08c592 100644
--- a/openair2/RRC/NR_UE/rrc_UE.c
+++ b/openair2/RRC/NR_UE/rrc_UE.c
@@ -289,7 +289,6 @@ int8_t nr_rrc_ue_process_rrcReconfiguration(const module_id_t module_id, NR_RRCR
           //  after first time, update it and free the memory after.
           NR_UE_rrc_inst[module_id].cell_group_config = cellGroupConfig;
           nr_rrc_ue_process_scg_config(module_id,cellGroupConfig);
-          LOG_I(NR_RRC, "Melissa, we have finished nr_rrc_ue_process_scg_config. Now freeing. \n");
           SEQUENCE_free(&asn_DEF_NR_CellGroupConfig, (void *)NR_UE_rrc_inst[module_id].cell_group_config, 0);
         }
       }
@@ -2994,7 +2993,7 @@ static void nsa_rrc_ue_process_ueCapabilityEnquiry(void)
   AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %lu)!\n",
                enc_rval.failed_type->name, enc_rval.encoded);
   UECap->sdu_size = (enc_rval.encoded + 7) / 8;
-  LOG_I(NR_RRC, "[NR_RRC] NRUE Capability encoded, %d bytes (%zd bits)\n",
+  LOG_A(NR_RRC, "[NR_RRC] NRUE Capability encoded, %d bytes (%zd bits)\n",
         UECap->sdu_size, enc_rval.encoded + 7);
   /* Melissa: Hack. Need to add ctxt->mod_id as array indices */
   NR_UE_rrc_inst[0].UECap = UECap;
@@ -3015,7 +3014,7 @@ static void nsa_rrc_ue_process_ueCapabilityEnquiry(void)
 
 void process_lte_nsa_msg(nsa_msg_t *msg, int msg_len)
 {
-    LOG_I(NR_RRC, "We are processing an NSA message\n");
+    LOG_D(NR_RRC, "Processing an NSA message\n");
     Rrc_Msg_Type_t msg_type = msg->msg_type;
     uint8_t *const msg_buffer = msg->msg_buffer;
     msg_len -= sizeof(msg->msg_type);
@@ -3023,7 +3022,7 @@ void process_lte_nsa_msg(nsa_msg_t *msg, int msg_len)
     {
         case UE_CAPABILITY_ENQUIRY:
         {
-            LOG_I(NR_RRC, "We are processing a %d message \n", msg_type);
+            LOG_D(NR_RRC, "We are processing a %d message \n", msg_type);
             NR_FreqBandList_t *nr_freq_band_list = NULL;
             asn_dec_rval_t dec_rval = uper_decode_complete(NULL,
                             &asn_DEF_NR_FreqBandList,
@@ -3042,9 +3041,9 @@ void process_lte_nsa_msg(nsa_msg_t *msg, int msg_len)
                      nr_freq_band_list->list.array[i]->choice.bandInformationNR->bandNR);
             }
             MessageDef *dummy_msg = itti_alloc_new_message(TASK_RRC_NSA_UE, 0, UE_CAPABILITY_DUMMY);
-            LOG_I(NR_RRC, "We are calling nsa_sendmsg_to_lte_ue to send a UE_CAPABILITY_DUMMY\n");
+            LOG_D(NR_RRC, "We are calling nsa_sendmsg_to_lte_ue to send a UE_CAPABILITY_DUMMY\n");
             nsa_sendmsg_to_lte_ue(dummy_msg, sizeof(dummy_msg), UE_CAPABILITY_DUMMY);
-            LOG_I(NR_RRC, "We have sent a UE_CAPABILITY_DUMMY\n");
+            LOG_A(NR_RRC, "Sent initial NRUE Capability response to LTE UE\n");
             break;
         }
 
@@ -3084,17 +3083,10 @@ void process_lte_nsa_msg(nsa_msg_t *msg, int msg_len)
               LOG_E(RRC, "Failed to decode measurement object (%zu bits) %d\n", dec_rval.consumed, dec_rval.code);
               break;
             }
-            LOG_I(NR_RRC, "NR carrierFreq_r15 (ssb): %ld and sub carrier spacing:%ld\n",
+            LOG_D(NR_RRC, "NR carrierFreq_r15 (ssb): %ld and sub carrier spacing:%ld\n",
                   nr_meas_obj->measObject.choice.measObjectNR_r15.carrierFreq_r15,
                   nr_meas_obj->measObject.choice.measObjectNR_r15.rs_ConfigSSB_r15.subcarrierSpacingSSB_r15);
             start_oai_nrue_threads();
-            /* Create a processs RRC_MEASUREMENT_PROCEDURE function. This
-               function will tell the NR UE which frequency to take measurements
-               on. You can log these values for fun. This will trigger 5G UE socket with proxy
-               to be opened. It will listen for PBCH from gNB (proxy technically). Then it will
-               call the ususal MIB functions to handle the MIB. Intervene in 5G stack to decode the MIB.
-               Also, after receiving PBCH it will start sending SSB index/cellID and some info from MIB to UE
-               as measurement reporting message*/
             break;
         }
         case RRC_CONFIG_COMPLETE_REQ:
@@ -3113,7 +3105,7 @@ void process_lte_nsa_msg(nsa_msg_t *msg, int msg_len)
             AssertFatal(sizeof(hdr) + nr_RadioBearer_size + nr_SecondaryCellGroup_size != msg_len,
                         "Bad received msg\n");
             NR_RRC_TransactionIdentifier_t t_id = hdr.trans_id;
-            LOG_I(NR_RRC, "nr_RadioBearerConfig1_r15 size %d nr_SecondaryCellGroupConfig_r15 size %d t_id %d\n",
+            LOG_I(NR_RRC, "nr_RadioBearerConfig1_r15 size %d nr_SecondaryCellGroupConfig_r15 size %d t_id %ld\n",
                       nr_RadioBearer_size,
                       nr_SecondaryCellGroup_size,
                       t_id);