X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fcm%2Frgr.c;h=b176d641b8ad1da78b1f716d7289cd8370ecb000;hb=87c35884595a3166121854c3ae6e6e856f004ff4;hp=a5a386a8b6ced189ac8e229c20f619b9732a424a;hpb=105199ef642ffe9736ea24a01d4546578fa25e60;p=o-du%2Fl2.git

diff --git a/src/cm/rgr.c b/src/cm/rgr.c
index a5a386a8b..b176d641b 100755
--- a/src/cm/rgr.c
+++ b/src/cm/rgr.c
@@ -57,22 +57,14 @@
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrBndReq
+S16 cmPkRgrBndReq
 (
 Pst* pst,
 SuId suId,
 SpId spId
 )
-#else
-PUBLIC S16 cmPkRgrBndReq(pst, suId, spId)
-Pst* pst;
-SuId suId;
-SpId spId;
-#endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkRgrBndReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -80,7 +72,7 @@ SpId spId;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR001, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(spId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -89,7 +81,7 @@ SpId spId;
          (ErrVal)ERGR002, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(suId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -98,10 +90,10 @@ SpId spId;
          (ErrVal)ERGR003, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTRGRBNDREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -120,24 +112,16 @@ SpId spId;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrBndReq
+S16 cmUnpkRgrBndReq
 (
 RgrBndReq func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrBndReq(func, pst, mBuf)
-RgrBndReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SuId suId;
    SpId spId;
    
-   TRC3(cmUnpkRgrBndReq)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -146,7 +130,7 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR004, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SUnpkS16(&spId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -155,10 +139,10 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR005, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, spId));
+   return ((*func)(pst, suId, spId));
 }
 
 
@@ -178,22 +162,14 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrBndCfm
+S16 cmPkRgrBndCfm
 (
 Pst* pst,
 SuId suId,
-U8 status
+uint8_t status
 )
-#else
-PUBLIC S16 cmPkRgrBndCfm(pst, suId, status)
-Pst* pst;
-SuId suId;
-U8 status;
-#endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkRgrBndCfm)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -201,16 +177,16 @@ U8 status;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR006, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SPkU8(status, mBuf) != ROK) {
+   if (oduUnpackUInt8(status, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR007, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(suId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -219,10 +195,10 @@ U8 status;
          (ErrVal)ERGR008, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTRGRBNDCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -242,24 +218,16 @@ U8 status;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrBndCfm
+S16 cmUnpkRgrBndCfm
 (
 RgrBndCfm func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrBndCfm(func, pst, mBuf)
-RgrBndCfm func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SuId suId;
-   U8 status;
+   uint8_t status;
    
-   TRC3(cmUnpkRgrBndCfm)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -268,19 +236,19 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR009, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SUnpkU8(&status, mBuf) != ROK) {
+   if (oduPackUInt8(&status, mBuf) != ROK) {
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR010, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, status));
+   return ((*func)(pst, suId, status));
 }
 
 
@@ -299,22 +267,14 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUbndReq
+S16 cmPkRgrUbndReq
 (
 Pst* pst,
 SpId spId,
 Reason reason
 )
-#else
-PUBLIC S16 cmPkRgrUbndReq(pst, spId, reason)
-Pst* pst;
-SpId spId;
-Reason reason;
-#endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkRgrUbndReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -322,7 +282,7 @@ Reason reason;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR011, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(reason, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -331,7 +291,7 @@ Reason reason;
          (ErrVal)ERGR012, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(spId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -340,10 +300,10 @@ Reason reason;
          (ErrVal)ERGR013, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTRGRUBNDREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -362,24 +322,16 @@ Reason reason;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUbndReq
+S16 cmUnpkRgrUbndReq
 (
 RgrUbndReq func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUbndReq(func, pst, mBuf)
-RgrUbndReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SpId spId;
    Reason reason;
    
-   TRC3(cmUnpkRgrUbndReq)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -388,7 +340,7 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR014, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SUnpkS16(&reason, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -397,10 +349,10 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR015, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, spId, reason));
+   return ((*func)(pst, spId, reason));
 }
 
 
@@ -420,24 +372,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCfgReq
+S16 cmUnpkRgrCfgReq
 (
 RgrCfgReq func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrCfgReq(func, pst, mBuf)
-RgrCfgReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    RgrCfgTransId transId;
    RgrCfgReqInfo *cfgReqInfo;
    
-   TRC3(cmUnpkRgrCfgReq)
 #if 0
    if (SUnpkS16(&spId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -446,7 +390,7 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR021, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 #endif
 
@@ -457,31 +401,31 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR022, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo,sizeof(RgrCfgReqInfo))) != ROK) {
+   if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&cfgReqInfo,sizeof(RgrCfgReqInfo))) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR023, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   cmMemset((U8 *)cfgReqInfo, 0, sizeof(RgrCfgReqInfo));
+   memset(cfgReqInfo, 0, sizeof(RgrCfgReqInfo));
    if (pst->selector == ODU_SELECTOR_LC) 
       if (cmUnpkRgrCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
-         SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(RgrCfgReqInfo));
+         SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(RgrCfgReqInfo));
          SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
                (ErrVal)ERGR024, (ErrVal)0, "Packing failed");
 #endif
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, transId, cfgReqInfo));
+   return ((*func)(pst, transId, cfgReqInfo));
 }
 
 /* rgr_c_001.main_3: Added TTI indication from MAC to RGR user */
@@ -501,22 +445,15 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrTtiIndInfo
+S16 cmPkRgrTtiIndInfo
 (
 RgrTtiIndInfo *param,
 Buffer        *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrTtiIndInfo(param, mBuf)
-RgrTtiIndInfo *param;
-Buffer        *mBuf;
-#endif
 {
-   TRC3(cmPkRgrTtiInd)
-   CMCHKPK(SPkU16, param->sfn, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->sfn, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -533,23 +470,16 @@ Buffer        *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrTtiIndInfo
+S16 cmUnpkRgrTtiIndInfo
 (
 RgrTtiIndInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrTtiIndInfo(param, mBuf)
-RgrTtiIndInfo *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmUnpkRgrTtiIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->sfn, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt16, &param->sfn, mBuf);
+   return ROK;
 }
 
 
@@ -568,22 +498,14 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrTtiInd
+S16 cmPkRgrTtiInd
 (
 Pst* pst,
 SuId suId,
 RgrTtiIndInfo *ttiInd
 )
-#else
-PUBLIC S16 cmPkRgrTtiInd(pst, suId, ttiInd)
-Pst* pst;
-SuId suId;
-RgrTtiIndInfo *ttiInd;
-#endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkRgrTtiInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -591,7 +513,7 @@ RgrTtiIndInfo *ttiInd;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR025, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmPkRgrTtiIndInfo(ttiInd, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -599,9 +521,9 @@ RgrTtiIndInfo *ttiInd;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR026, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(suId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -609,13 +531,13 @@ RgrTtiIndInfo *ttiInd;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR027, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
+   SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
    pst->event = (Event) EVTRGRTTIIND;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -634,24 +556,16 @@ RgrTtiIndInfo *ttiInd;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrTtiInd
+S16 cmUnpkRgrTtiInd
 (
 RgrTtiInd func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrTtiInd(func, pst, mBuf)
-RgrTtiInd func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SuId suId;
    RgrTtiIndInfo *ttiInd;
    
-   TRC3(cmUnpkRgrTtiInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -660,9 +574,9 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR028, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if ((SGetSBuf(pst->region, pst->pool, (Data **)&ttiInd, sizeof(RgrTtiIndInfo))) != ROK) 
+   if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&ttiInd, sizeof(RgrTtiIndInfo))) != ROK) 
    {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -670,12 +584,12 @@ Buffer *mBuf;
           (ErrVal)ERGR029, (ErrVal)0, "UnPacking failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
  
    if (cmUnpkRgrTtiIndInfo(ttiInd, mBuf) != ROK) {
       /*ccpu00114888- Memory Leak issue- Start*/
-      SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ttiInd, 
             sizeof(RgrTtiIndInfo));
       /*ccpu00114888- Memory Leak issue- End*/
       SPutMsg(mBuf);
@@ -684,10 +598,10 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR030, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, ttiInd));
+   return ((*func)(pst, suId, ttiInd));
 }
 
 
@@ -706,22 +620,14 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrCfgCfm
+S16 cmPkRgrCfgCfm
 (
 Pst* pst,
 RgrCfgTransId transId,
-U8 status
+uint8_t status
 )
-#else
-PUBLIC S16 cmPkRgrCfgCfm(pst, transId, status)
-Pst* pst;
-RgrCfgTransId transId;
-U8 status;
-#endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkRgrCfgCfm)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -729,16 +635,16 @@ U8 status;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR031, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SPkU8(status, mBuf) != ROK) {
+   if (oduUnpackUInt8(status, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR032, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -747,10 +653,10 @@ U8 status;
          (ErrVal)ERGR033, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTMACSCHCFGCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -769,24 +675,16 @@ U8 status;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCfgCfm
+S16 cmUnpkRgrCfgCfm
 (
 RgrCfgCfm func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrCfgCfm(func, pst, mBuf)
-RgrCfgCfm func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    RgrCfgTransId transId;
-   U8 status;
+   uint8_t status;
    
-   TRC3(cmUnpkRgrCfgCfm)
 
    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -795,19 +693,19 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR036, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SUnpkU8(&status, mBuf) != ROK) {
+   if (oduPackUInt8(&status, mBuf) != ROK) {
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR037, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, transId, status));
+   return ((*func)(pst, transId, status));
 }
 
 /* rgr_c_001.main_4: ADD-Added for SI Enhancement. */
@@ -827,25 +725,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrSiCfgCfm
+S16 cmPkRgrSiCfgCfm
 (
 Pst* pst,
 SuId suId,
 RgrCfgTransId transId,
-U8 status
+uint8_t status
 )
-#else
-PUBLIC S16 cmPkRgrSiCfgCfm(pst, suId, transId, status)
-Pst* pst;
-SuId suId;
-RgrCfgTransId transId;
-U8 status;
-#endif
 {
    Buffer *mBuf = NULLP;
 
-   TRC3(cmPkRgrSiCfgCfm)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -853,16 +742,16 @@ U8 status;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR038, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SPkU8(status, mBuf) != ROK) {
+   if (oduUnpackUInt8(status, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR039, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -871,7 +760,7 @@ U8 status;
          (ErrVal)ERGR040, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(suId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -880,11 +769,11 @@ U8 status;
          (ErrVal)ERGR041, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    pst->event = (Event) EVTRGRSICFGCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -903,25 +792,17 @@ U8 status;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSiCfgCfm
+S16 cmUnpkRgrSiCfgCfm
 (
 RgrSiCfgCfm func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrSiCfgCfm(func, pst, mBuf)
-RgrSiCfgCfm func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SuId suId;
    RgrCfgTransId transId;
-   U8 status;
+   uint8_t status;
    
-   TRC3(cmUnpkRgrSiCfgCfm)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -930,7 +811,7 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR042, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -939,19 +820,19 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR043, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SUnpkU8(&status, mBuf) != ROK) {
+   if (oduPackUInt8(&status, mBuf) != ROK) {
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR044, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, transId, status));
+   return ((*func)(pst, suId, transId, status));
 }
 #endif/*RGR_SI_SCH*/
 
@@ -971,26 +852,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrCfgTransId
+S16 cmPkRgrCfgTransId
 (
 RgrCfgTransId *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrCfgTransId(param, mBuf)
-RgrCfgTransId *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmPkRgrCfgTransId)
 
    for (i=RGR_CFG_TRANSID_SIZE-1; i >= 0; i--) {
-      CMCHKPK(SPkU8, param->trans[i], mBuf);
+      CMCHKPK(oduUnpackUInt8, param->trans[i], mBuf);
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1010,26 +884,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCfgTransId
+S16 cmUnpkRgrCfgTransId
 (
 RgrCfgTransId *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrCfgTransId(param, mBuf)
-RgrCfgTransId *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmUnpkRgrCfgTransId)
 
    for (i=0; i<RGR_CFG_TRANSID_SIZE; i++) {
-      CMCHKUNPK(SUnpkU8, &param->trans[i], mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->trans[i], mBuf);
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1049,24 +916,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrDlHqCfg
+S16 cmPkRgrDlHqCfg
 (
 RgrDlHqCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrDlHqCfg(param, mBuf)
-RgrDlHqCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrDlHqCfg)
 
-   CMCHKPK(SPkU8, param->maxMsg4HqTx, mBuf);
-   CMCHKPK(SPkU8, param->maxDlHqTx, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->maxMsg4HqTx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxDlHqTx, mBuf);
+   return ROK;
 }
 
 
@@ -1086,24 +946,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDlHqCfg
+S16 cmUnpkRgrDlHqCfg
 (
 RgrDlHqCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrDlHqCfg(param, mBuf)
-RgrDlHqCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrDlHqCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->maxDlHqTx, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->maxMsg4HqTx, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->maxDlHqTx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxMsg4HqTx, mBuf);
+   return ROK;
 }
 
 
@@ -1123,24 +976,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrRntiCfg
+S16 cmPkRgrRntiCfg
 (
 RgrRntiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrRntiCfg(param, mBuf)
-RgrRntiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrRntiCfg)
-
-   CMCHKPK(SPkU16, param->size, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->size, mBuf);
    CMCHKPK(cmPkLteRnti, param->startRnti, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1160,24 +1005,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrRntiCfg
+S16 cmUnpkRgrRntiCfg
 (
 RgrRntiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrRntiCfg(param, mBuf)
-RgrRntiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrRntiCfg)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->startRnti, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->size, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt16, &param->size, mBuf);
+   return ROK;
 }
 
 #ifdef EMTC_ENABLE
@@ -1196,27 +1034,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcRntiCfg
+S16 cmPkRgrEmtcRntiCfg
 (
 RgrEmtcRntiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrEmtcRntiCfg(param, mBuf)
-RgrEmtcRntiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrEmtcRntiCfg)
 
-   CMCHKPK(SPkU16, param->size, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->size, mBuf);
    CMCHKPK(cmPkLteRnti, param->rntiCeModeBRange, mBuf);
    CMCHKPK(cmPkLteRnti, param->rntiCeModeBStart, mBuf);
    CMCHKPK(cmPkLteRnti, param->rntiCeModeARange, mBuf);
    CMCHKPK(cmPkLteRnti, param->rntiCeModeAStart, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1236,28 +1067,21 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcRntiCfg
+S16 cmUnpkRgrEmtcRntiCfg
 (
 RgrEmtcRntiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrEmtcRntiCfg(param, mBuf)
-RgrEmtcRntiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrEmtcRntiCfg)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rntiCeModeAStart, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->rntiCeModeARange, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->rntiCeModeBStart, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->rntiCeModeBRange, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->size, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->size, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 #endif
 
@@ -1277,25 +1101,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrDlCmnCodeRateCfg
+S16 cmPkRgrDlCmnCodeRateCfg
 (
 RgrDlCmnCodeRateCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrDlCmnCodeRateCfg(param, mBuf)
-RgrDlCmnCodeRateCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrDlCmnCodeRateCfg)
-
-   CMCHKPK(SPkU8, param->ccchCqi, mBuf);
-   CMCHKPK(SPkU16, param->pdcchCodeRate, mBuf);
-   CMCHKPK(SPkU16, param->bcchPchRaCodeRate, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->ccchCqi, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->pdcchCodeRate, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->bcchPchRaCodeRate, mBuf);
+   return ROK;
 }
 
 
@@ -1315,25 +1131,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDlCmnCodeRateCfg
+S16 cmUnpkRgrDlCmnCodeRateCfg
 (
 RgrDlCmnCodeRateCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrDlCmnCodeRateCfg(param, mBuf)
-RgrDlCmnCodeRateCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrDlCmnCodeRateCfg)
-
-   CMCHKUNPK(SUnpkU16, &param->bcchPchRaCodeRate, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->pdcchCodeRate, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->ccchCqi, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt16, &param->bcchPchRaCodeRate, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->pdcchCodeRate, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ccchCqi, mBuf);
+   return ROK;
 }
 
 
@@ -1353,23 +1161,14 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrCfiCfg
+S16 cmPkRgrCfiCfg
 (
 RgrCfiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrCfiCfg(param, mBuf)
-RgrCfiCfg *param;
-Buffer *mBuf;
-#endif
 {
-
-   TRC3(cmPkRgrCfiCfg)
-
-   CMCHKPK(SPkU8, param->cfi, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->cfi, mBuf);
+   return ROK;
 }
 
 
@@ -1389,23 +1188,15 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCfiCfg
+S16 cmUnpkRgrCfiCfg
 (
 RgrCfiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrCfiCfg(param, mBuf)
-RgrCfiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrCfiCfg)
-
-   CMCHKUNPK(SUnpkU8, &param->cfi, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->cfi, mBuf);
+   return ROK;
 }
 
 
@@ -1425,29 +1216,22 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrPuschSubBandCfg
+S16 cmPkRgrPuschSubBandCfg
 (
 RgrPuschSubBandCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrPuschSubBandCfg(param, mBuf)
-RgrPuschSubBandCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmPkRgrPuschSubBandCfg)
 
    for (i=param->numSubbands-1; i >= 0; i--) {
-      CMCHKPK(SPkU8, param->dmrs[i], mBuf);
+      CMCHKPK(oduUnpackUInt8, param->dmrs[i], mBuf);
    }
-   CMCHKPK(SPkU8, param->size, mBuf);
-   CMCHKPK(SPkU8, param->numSubbands, mBuf);
-   CMCHKPK(SPkU8, param->subbandStart, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->size, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numSubbands, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->subbandStart, mBuf);
+   return ROK;
 }
 
 
@@ -1467,29 +1251,21 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrPuschSubBandCfg
+S16 cmUnpkRgrPuschSubBandCfg
 (
 RgrPuschSubBandCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrPuschSubBandCfg(param, mBuf)
-RgrPuschSubBandCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmUnpkRgrPuschSubBandCfg)
-
-   CMCHKUNPK(SUnpkU8, &param->subbandStart, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numSubbands, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->size, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->subbandStart, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numSubbands, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->size, mBuf);
    for (i=0; i<param->numSubbands; i++) {
-      CMCHKUNPK(SUnpkU8, &param->dmrs[i], mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->dmrs[i], mBuf);
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1509,23 +1285,14 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUlCmnCodeRateCfg
+S16 cmPkRgrUlCmnCodeRateCfg
 (
 RgrUlCmnCodeRateCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUlCmnCodeRateCfg(param, mBuf)
-RgrUlCmnCodeRateCfg *param;
-Buffer *mBuf;
-#endif
 {
-
-   TRC3(cmPkRgrUlCmnCodeRateCfg)
-
-   CMCHKPK(SPkU8, param->ccchCqi, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->ccchCqi, mBuf);
+   return ROK;
 }
 
 
@@ -1545,23 +1312,15 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUlCmnCodeRateCfg
+S16 cmUnpkRgrUlCmnCodeRateCfg
 (
 RgrUlCmnCodeRateCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUlCmnCodeRateCfg(param, mBuf)
-RgrUlCmnCodeRateCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUlCmnCodeRateCfg)
-
-   CMCHKUNPK(SUnpkU8, &param->ccchCqi, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->ccchCqi, mBuf);
+   return ROK;
 }
 
 
@@ -1581,23 +1340,14 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUlTrgCqiCfg
+S16 cmPkRgrUlTrgCqiCfg
 (
 RgrUlTrgCqiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUlTrgCqiCfg(param, mBuf)
-RgrUlTrgCqiCfg *param;
-Buffer *mBuf;
-#endif
 {
-
-   TRC3(cmPkRgrUlTrgCqiCfg)
-
-   CMCHKPK(SPkU8, param->trgCqi, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->trgCqi, mBuf);
+   return ROK;
 }
 
 
@@ -1617,23 +1367,15 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUlTrgCqiCfg
+S16 cmUnpkRgrUlTrgCqiCfg
 (
 RgrUlTrgCqiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUlTrgCqiCfg(param, mBuf)
-RgrUlTrgCqiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUlTrgCqiCfg)
-
-   CMCHKUNPK(SUnpkU8, &param->trgCqi, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->trgCqi, mBuf);
+   return ROK;
 }
 
 
@@ -1653,260 +1395,196 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrBwCfg
+S16 cmPkRgrBwCfg
 (
 RgrBwCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrBwCfg(param, mBuf)
-RgrBwCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrBwCfg)
-
-   CMCHKPK(SPkU8, param->ulTotalBw, mBuf);
-   CMCHKPK(SPkU8, param->dlTotalBw, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->ulTotalBw, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->dlTotalBw, mBuf);
+   return ROK;
 }
 
 
 #ifdef EMTC_ENABLE 
 /* EMTC related pack changes start*/
 
-#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcSiCfg
+S16 cmPkRgrEmtcSiCfg
 (
 RgrEmtcSiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrEmtcSiCfg(param, mBuf)
-RgrEmtcSiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmPkRgrEmtcSiCfg)
    	
-   CMCHKPK(SPkU8, param->siHoppingEnable, mBuf);
-   CMCHKPK(SPkU32, param->modPrd, mBuf);
-   CMCHKPK(SPkU8, param->siWinSizeBr, mBuf);
-   CMCHKPK(SPkU8, param->sib1Repetition, mBuf);
-   CMCHKPK(SPkU8, param->siRepetition, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->siHoppingEnable, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->modPrd, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->siWinSizeBr, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->sib1Repetition, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->siRepetition, mBuf);
    
-   CMCHKPK(SPkU16, param->startSymbolLc, mBuf);
-   //CMCHKPK(SPkU8, param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->startSymbolLc, mBuf);
+   //CMCHKPK(oduUnpackUInt8, param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
    /*Changes by SIMRAN*/
     if(!(param->fddDLOrTddSfBitmapLC.sfnPtnChoice))
     {
-      CMCHKPK(SPkU16, param->fddDLOrTddSfBitmapLC.u.ptn10, mBuf);
+      CMCHKPK(oduUnpackUInt16, param->fddDLOrTddSfBitmapLC.u.ptn10, mBuf);
     }
     else
    {
       //CMCHKPK(SPkU64,param->fddDLOrTddSfBitmapLC.u.ptn40, mBuf);
       for (i=0; i<2; i++) {
-         CMCHKPK(SPkU32, param->fddDLOrTddSfBitmapLC.u.ptn40[i], mBuf);
+         CMCHKPK(oduUnpackUInt32, param->fddDLOrTddSfBitmapLC.u.ptn40[i], mBuf);
       }
 
    }
-   CMCHKPK(SPkU8, param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
-   //CMCHKPK(SPkU16, param->fddDlOrTddSfBitmapBR, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
+   //CMCHKPK(oduUnpackUInt16, param->fddDlOrTddSfBitmapBR, mBuf);
    
      for (i= (param->numSi-1); i >= 0; i--) {
-   		 CMCHKPK(SPkU8, param->schdInfo[i].emtcSiNarrowBand, mBuf);
-   		 CMCHKPK(SPkU16, param->schdInfo[i].emtcSiTbs, mBuf);
+   		 CMCHKPK(oduUnpackUInt8, param->schdInfo[i].emtcSiNarrowBand, mBuf);
+   		 CMCHKPK(oduUnpackUInt16, param->schdInfo[i].emtcSiTbs, mBuf);
      }
 
      for (i= (param->numSi-1); i >= 0; i--) {
-   	  CMCHKPK(SPkU32, param->siPeriodicity[i], mBuf);
+   	  CMCHKPK(oduUnpackUInt32, param->siPeriodicity[i], mBuf);
    	}
    
-     CMCHKPK(SPkU8, param->numSi, mBuf);  
+     CMCHKPK(oduUnpackUInt8, param->numSi, mBuf);  
 
- RETVALUE(ROK);
+ return ROK;
 }
 
 
 
 
-#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcRachCfg
+S16 cmPkRgrEmtcRachCfg
 (
 RgrEmtcRachCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrEmtcRachCfg(param, mBuf)
-RgrEmtcRachCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmPkRgrEmtcRachCfg)
    	
-   CMCHKPK(SPkU8, param->emtcCeLvlSupported, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->emtcCeLvlSupported, mBuf);
 
    for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {
-   	  CMCHKPK(SPkU8, param->ceLevelInfo[i].emtcRarHopping, mBuf);
-	  CMCHKPK(SPkU16, param->ceLevelInfo[i].raEmtcWinSize, mBuf);
-	  CMCHKPK(SPkU16, param->ceLevelInfo[i].raEmtcContResTmr, mBuf);
-   	  CMCHKPK(SPkU16, param->ceLevelInfo[i].emtcPreambleTransMax, mBuf);
-	  CMCHKPK(SPkU8, param->ceLevelInfo[i].emtcPreambleMap.firstPreamble, mBuf);
-   	  CMCHKPK(SPkU8, param->ceLevelInfo[i].emtcPreambleMap.lastPreamble, mBuf);
+   	  CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcRarHopping, mBuf);
+	  CMCHKPK(oduUnpackUInt16, param->ceLevelInfo[i].raEmtcWinSize, mBuf);
+	  CMCHKPK(oduUnpackUInt16, param->ceLevelInfo[i].raEmtcContResTmr, mBuf);
+   	  CMCHKPK(oduUnpackUInt16, param->ceLevelInfo[i].emtcPreambleTransMax, mBuf);
+	  CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcPreambleMap.firstPreamble, mBuf);
+   	  CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcPreambleMap.lastPreamble, mBuf);
    	}
    
- RETVALUE(ROK);
+ return ROK;
 }
 
 
-#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcPdschCfg
+S16 cmPkRgrEmtcPdschCfg
 (
 RgrEmtcPdschCfg*param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrEmtcPdschCfg(param, mBuf)
-RgrEmtcPdschCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrEmtcPdschCfg)
-   CMCHKPK(SPkU16, param->emtcMaxRepCeModeA, mBuf);
-   CMCHKPK(SPkU16, param->emtcMaxRepCeModeB, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeA, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeB, mBuf);
    
- RETVALUE(ROK);
+ return ROK;
 }
 
-#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcPuschCfg
+S16 cmPkRgrEmtcPuschCfg
 (
 RgrEmtcPuschCfg*param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrEmtcPuschCfg(param, mBuf)
-RgrEmtcPuschCfg *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmPkRgrEmtcPuschCfg)
-   CMCHKPK(SPkU16, param->emtcMaxRepCeModeA, mBuf);
-   CMCHKPK(SPkU16, param->emtcMaxRepCeModeB, mBuf);
-   CMCHKPK(SPkU8,  param->emtcHoppingOffset, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeA, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeB, mBuf);
+   CMCHKPK(oduUnpackUInt8,  param->emtcHoppingOffset, mBuf);
+   return ROK;
 }
 
 
 
-#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcPucchCfg
+S16 cmPkRgrEmtcPucchCfg
 (
 RgrEmtcPucchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrEmtcPucchCfg(param, mBuf)
-RgrEmtcPucchCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
+   for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) 
+   {
+   	  CMCHKPK(oduUnpackUInt16, param->emtcN1pucchAnInfoLst[i], mBuf);
+   }
 
-    TRC3(cmPkRgrEmtcPucchCfg)
-   for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {
-   	  CMCHKPK(SPkU16, param->emtcN1pucchAnInfoLst[i], mBuf);
-  	}
-
- 	CMCHKPK(SPkU8, param->emtcPucchNumRepCEMsg4Lvl0, mBuf);
- 	CMCHKPK(SPkU8, param->emtcPucchNumRepCEMsg4Lvl1, mBuf);
- 	CMCHKPK(SPkU8, param->emtcPucchNumRepCEMsg4Lvl2, mBuf);
- 	CMCHKPK(SPkU8, param->emtcPucchNumRepCEMsg4Lvl3, mBuf);	
+ 	CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl0, mBuf);
+ 	CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl1, mBuf);
+ 	CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl2, mBuf);
+ 	CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl3, mBuf);	
    
- RETVALUE(ROK);
+ return ROK;
 }
 
 
-#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcPrachCeParamCfg
+S16 cmPkRgrEmtcPrachCeParamCfg
 (
 RgrEmtcPrachCEParamLst *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrEmtcPrachCeParamCfg(param, mBuf)
-RgrEmtcPrachCEParamLst *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmPkRgrEmtcPrachCeParamCfg) 
-   CMCHKPK(SPkU8, param->emtcPrachCfgIdx, mBuf);
-   CMCHKPK(SPkU8, param->emtcPrachFreqOffset, mBuf);
-   CMCHKPK(SPkU16,  param->emtcPrachStartSubFrame, mBuf);
-   CMCHKPK(SPkU8, param->emtcMaxPremAttemptCE, mBuf);
-   CMCHKPK(SPkU8, param->emtcNumRepPerPreambleAtt, mBuf);
-   CMCHKPK(SPkU8,  param->emtcNumMpdcchNBtoMonitor, mBuf);
-   CMCHKPK(SPkU8, param->emtcMpdcchNBtoMonitor[0], mBuf);
-   CMCHKPK(SPkU8,  param->emtcMpdcchNBtoMonitor[1], mBuf);
-   CMCHKPK(SPkU16, param->emtcMpdcchNumRep, mBuf);
-   CMCHKPK(SPkU8,  param->emtcPrachHoppingCfg, mBuf);   
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->emtcPrachCfgIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->emtcPrachFreqOffset, mBuf);
+   CMCHKPK(oduUnpackUInt16,  param->emtcPrachStartSubFrame, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->emtcMaxPremAttemptCE, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->emtcNumRepPerPreambleAtt, mBuf);
+   CMCHKPK(oduUnpackUInt8,  param->emtcNumMpdcchNBtoMonitor, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->emtcMpdcchNBtoMonitor[0], mBuf);
+   CMCHKPK(oduUnpackUInt8,  param->emtcMpdcchNBtoMonitor[1], mBuf);
+   CMCHKPK(oduUnpackUInt16, param->emtcMpdcchNumRep, mBuf);
+   CMCHKPK(oduUnpackUInt8,  param->emtcPrachHoppingCfg, mBuf);   
+   return ROK;
 }
 
 
 
-#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcPrachCfg
+S16 cmPkRgrEmtcPrachCfg
 (
 RgrEmtcPrachCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrEmtcPrachCfg(param, mBuf)
-RgrEmtcPrachCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmPkRgrEmtcPrachCfg)
- 	CMCHKPK(SPkU8, param->emtcMpdcchStartSFCssRaFdd, mBuf);
- 	CMCHKPK(SPkU8, param->emtcPrachHopingOffset, mBuf);
- 	CMCHKPK(SPkU8, param->emtcInitialCElevel, mBuf);
+ 	CMCHKPK(oduUnpackUInt8, param->emtcMpdcchStartSFCssRaFdd, mBuf);
+ 	CMCHKPK(oduUnpackUInt8, param->emtcPrachHopingOffset, mBuf);
+ 	CMCHKPK(oduUnpackUInt8, param->emtcInitialCElevel, mBuf);
    for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {   	
  	CMCHKPK(cmPkRgrEmtcPrachCeParamCfg, &param->emtcPrachCEparmLst[i], mBuf);
    	}
    
- RETVALUE(ROK);
+ return ROK;
 }
 
 
 
 
-#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcCfg
+S16 cmPkRgrEmtcCfg
 (
 RgrEmtcCellCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrEmtcCfg(param, mBuf)
-RgrEmtcCellCfg *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmPkRgrEmtcCfg)
-   CMCHKPK(SPkU16, param->pci, mBuf);
-   CMCHKPK(SPkU32, param->emtcT300Tmr, mBuf);
-   CMCHKPK(SPkU32, param->emtcT301Tmr, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->pci, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->emtcT300Tmr, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->emtcT301Tmr, mBuf);
    CMCHKPK(cmPkRgrEmtcSiCfg, &param->emtcSiCfg, mBuf);
    CMCHKPK(cmPkRgrEmtcRachCfg, &param->emtcRachCfg, mBuf);
    CMCHKPK(cmPkRgrEmtcPdschCfg, &param->emtcPdschCfg, mBuf);
@@ -1914,239 +1592,185 @@ Buffer *mBuf;
    CMCHKPK(cmPkRgrEmtcPrachCfg, &param->emtcPrachCfg, mBuf);
    CMCHKPK(cmPkRgrEmtcPucchCfg, &param->emtcPucchCfg, mBuf);
    CMCHKPK(cmPkRgrEmtcRntiCfg, &param->emtcMacRnti, mBuf);
-   CMCHKPK(SPkU8, param->emtcPdschNbIdx, mBuf);
-   CMCHKPK(SPkU8, param->emtcMpdcchNbIdx, mBuf);
-   CMCHKPK(SPkU8, param->emtcPuschNbIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->emtcPdschNbIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->emtcMpdcchNbIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->emtcPuschNbIdx, mBuf);
    
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /* EMTC related pack changes end*/
 
 /* EMTC related unpack changes start*/
 
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcSiCfg
+S16 cmUnpkRgrEmtcSiCfg
 (
 RgrEmtcSiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrEmtcSiCfg(param, mBuf)
-RgrEmtcSiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
      S32 i;
-     U32 tmpEnum; 
-     TRC3(cmUnpkRgrEmtcSiCfg)
-     		 CMCHKUNPK(SUnpkU8, &param->numSi, mBuf); 
+     uint32_t tmpEnum; 
+     CMCHKUNPK(oduPackUInt8, &param->numSi, mBuf); 
 
-	  for (i=0; i < param->numSi ; i++) {
-   	  	 CMCHKUNPK(SUnpkU32,(U32*)&tmpEnum,mBuf);
-	  		 param->siPeriodicity[i] = (RgrSiPeriodicity) tmpEnum;
+     for (i=0; i < param->numSi ; i++) 
+     {
+     	 CMCHKUNPK(oduPackUInt32,(uint32_t*)&tmpEnum,mBuf);
+	 param->siPeriodicity[i] = (RgrSiPeriodicity) tmpEnum;
      }   
 
-     for (i=0; i < param->numSi ; i++) {
-   		 CMCHKUNPK(SUnpkU16, &param->schdInfo[i].emtcSiTbs, mBuf);
-   		 CMCHKUNPK(SUnpkU8, &param->schdInfo[i].emtcSiNarrowBand, mBuf);
+     for (i=0; i < param->numSi ; i++)
+     {
+   	 CMCHKUNPK(oduPackUInt16, &param->schdInfo[i].emtcSiTbs, mBuf);
+   	 CMCHKUNPK(oduPackUInt8, &param->schdInfo[i].emtcSiNarrowBand, mBuf);
      }
-     //CMCHKUNPK(SUnpkU16, &param->fddDlOrTddSfBitmapBR, mBuf);
-     CMCHKUNPK(SUnpkU8, &param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
+     //CMCHKUNPK(oduPackUInt16, &param->fddDlOrTddSfBitmapBR, mBuf);
+     CMCHKUNPK(oduPackUInt8, &param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
      /*Changes by SIMRAN*/
        if(!(param->fddDLOrTddSfBitmapLC.sfnPtnChoice))
        {
-        CMCHKUNPK(SUnpkU16, &param->fddDLOrTddSfBitmapLC.u.ptn10, mBuf);
+        CMCHKUNPK(oduPackUInt16, &param->fddDLOrTddSfBitmapLC.u.ptn10, mBuf);
        }
        else
        {
           for (i=1; i>=0; i--) {
-            CMCHKUNPK(SUnpkU32, &param->fddDLOrTddSfBitmapLC.u.ptn40[i], mBuf);
+            CMCHKUNPK(oduPackUInt32, &param->fddDLOrTddSfBitmapLC.u.ptn40[i], mBuf);
             }
      }
 
-     CMCHKUNPK(SUnpkU16, &param->startSymbolLc, mBuf);
-     CMCHKUNPK(SUnpkU8, &param->siRepetition, mBuf);
-     CMCHKUNPK(SUnpkU8, &param->sib1Repetition, mBuf);
-     CMCHKUNPK(SUnpkU8, &param->siWinSizeBr, mBuf);
-     CMCHKUNPK(SUnpkU32, (U32*)&tmpEnum, mBuf);
+     CMCHKUNPK(oduPackUInt16, &param->startSymbolLc, mBuf);
+     CMCHKUNPK(oduPackUInt8, &param->siRepetition, mBuf);
+     CMCHKUNPK(oduPackUInt8, &param->sib1Repetition, mBuf);
+     CMCHKUNPK(oduPackUInt8, &param->siWinSizeBr, mBuf);
+     CMCHKUNPK(oduPackUInt32, (uint32_t*)&tmpEnum, mBuf);
      param->modPrd = (RgrModPeriodicity) tmpEnum;
-     CMCHKUNPK(SUnpkU8, &param->siHoppingEnable, mBuf);
+     CMCHKUNPK(oduPackUInt8, &param->siHoppingEnable, mBuf);
 
- 	  RETVALUE(ROK);
+ 	  return ROK;
 }
 
 
 
 
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcRachCfg
+S16 cmUnpkRgrEmtcRachCfg
 (
 RgrEmtcRachCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrEmtcRachCfg(param, mBuf)
-RgrEmtcRachCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmUnpkRgrEmtcRachCfg)
    for (i=0; i < RGR_MAX_CE_LEVEL; i++) {
-   	  CMCHKUNPK(SUnpkU8, &(param->ceLevelInfo[i].emtcPreambleMap.lastPreamble), mBuf);
-	  CMCHKUNPK(SUnpkU8, &(param->ceLevelInfo[i].emtcPreambleMap.firstPreamble), mBuf);
-   	  CMCHKUNPK(SUnpkU16, &(param->ceLevelInfo[i].emtcPreambleTransMax), mBuf);
-	  CMCHKUNPK(SUnpkU16, &(param->ceLevelInfo[i].raEmtcContResTmr), mBuf);
-	  CMCHKUNPK(SUnpkU16, &(param->ceLevelInfo[i].raEmtcWinSize), mBuf);
-   	  CMCHKUNPK(SUnpkU8,&(param->ceLevelInfo[i].emtcRarHopping), mBuf);
+   	  CMCHKUNPK(oduPackUInt8, &(param->ceLevelInfo[i].emtcPreambleMap.lastPreamble), mBuf);
+	  CMCHKUNPK(oduPackUInt8, &(param->ceLevelInfo[i].emtcPreambleMap.firstPreamble), mBuf);
+   	  CMCHKUNPK(oduPackUInt16, &(param->ceLevelInfo[i].emtcPreambleTransMax), mBuf);
+	  CMCHKUNPK(oduPackUInt16, &(param->ceLevelInfo[i].raEmtcContResTmr), mBuf);
+	  CMCHKUNPK(oduPackUInt16, &(param->ceLevelInfo[i].raEmtcWinSize), mBuf);
+   	  CMCHKUNPK(oduPackUInt8,&(param->ceLevelInfo[i].emtcRarHopping), mBuf);
    	}
-    CMCHKUNPK(SUnpkU8, &param->emtcCeLvlSupported, mBuf);   
- RETVALUE(ROK);
+    CMCHKUNPK(oduPackUInt8, &param->emtcCeLvlSupported, mBuf);   
+ return ROK;
 }
 
 
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcPdschCfg
+S16 cmUnpkRgrEmtcPdschCfg
 (
 RgrEmtcPdschCfg*param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrEmtcPdschCfg(param, mBuf)
-RgrEmtcPdschCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrEmtcPdschCfg)
-   CMCHKUNPK(SUnpkU16, &param->emtcMaxRepCeModeB, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->emtcMaxRepCeModeA, mBuf);
- RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt16, &param->emtcMaxRepCeModeB, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->emtcMaxRepCeModeA, mBuf);
+ return ROK;
 }
 
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcPuschCfg
+S16 cmUnpkRgrEmtcPuschCfg
 (
 RgrEmtcPuschCfg*param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrEmtcPuschCfg(param, mBuf)
-RgrEmtcPuschCfg *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmUnpkRgrEmtcPuschCfg)
-   CMCHKUNPK(SUnpkU8,  &param->emtcHoppingOffset, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->emtcMaxRepCeModeB, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->emtcMaxRepCeModeA, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8,  &param->emtcHoppingOffset, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->emtcMaxRepCeModeB, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->emtcMaxRepCeModeA, mBuf);
+   return ROK;
 }
 
 
 
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcPucchCfg
+S16 cmUnpkRgrEmtcPucchCfg
 (
 RgrEmtcPucchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrEmtcPucchCfg(param, mBuf)
-RgrEmtcPucchCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
 
-   TRC3(cmUnpkRgrEmtcPucchCfg)
 
- 	CMCHKUNPK(SUnpkU8, &param->emtcPucchNumRepCEMsg4Lvl3, mBuf);
- 	CMCHKUNPK(SUnpkU8, &param->emtcPucchNumRepCEMsg4Lvl2, mBuf);
- 	CMCHKUNPK(SUnpkU8, &param->emtcPucchNumRepCEMsg4Lvl1, mBuf);
- 	CMCHKUNPK(SUnpkU8, &param->emtcPucchNumRepCEMsg4Lvl0, mBuf);	
+ 	CMCHKUNPK(oduPackUInt8, &param->emtcPucchNumRepCEMsg4Lvl3, mBuf);
+ 	CMCHKUNPK(oduPackUInt8, &param->emtcPucchNumRepCEMsg4Lvl2, mBuf);
+ 	CMCHKUNPK(oduPackUInt8, &param->emtcPucchNumRepCEMsg4Lvl1, mBuf);
+ 	CMCHKUNPK(oduPackUInt8, &param->emtcPucchNumRepCEMsg4Lvl0, mBuf);	
  
    for (i=0; i <  RGR_MAX_CE_LEVEL ; i++) {
-   	  CMCHKUNPK(SUnpkU16, &param->emtcN1pucchAnInfoLst[i], mBuf);
+   	  CMCHKUNPK(oduPackUInt16, &param->emtcN1pucchAnInfoLst[i], mBuf);
   	}   
- RETVALUE(ROK);
+ return ROK;
 }
 
 
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcPrachCeParamCfg
+S16 cmUnpkRgrEmtcPrachCeParamCfg
 (
 RgrEmtcPrachCEParamLst *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrEmtcPrachCeParamCfg(param, mBuf)
-RgrEmtcPrachCEParamLst *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmUnpkRgrEmtcPrachCeParamCfg)
-   CMCHKUNPK(SUnpkU8,  &param->emtcPrachHoppingCfg, mBuf);  
-   CMCHKUNPK(SUnpkU16, &param->emtcMpdcchNumRep, mBuf);
-   CMCHKUNPK(SUnpkU8,  &param->emtcMpdcchNBtoMonitor[1], mBuf);
-   CMCHKUNPK(SUnpkU8, &param->emtcMpdcchNBtoMonitor[0], mBuf);
-   CMCHKUNPK(SUnpkU8,  &param->emtcNumMpdcchNBtoMonitor, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->emtcNumRepPerPreambleAtt, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->emtcMaxPremAttemptCE, mBuf);
-   CMCHKUNPK(SUnpkU16,  &param->emtcPrachStartSubFrame, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->emtcPrachFreqOffset, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->emtcPrachCfgIdx, mBuf); 
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8,  &param->emtcPrachHoppingCfg, mBuf);  
+   CMCHKUNPK(oduPackUInt16, &param->emtcMpdcchNumRep, mBuf);
+   CMCHKUNPK(oduPackUInt8,  &param->emtcMpdcchNBtoMonitor[1], mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->emtcMpdcchNBtoMonitor[0], mBuf);
+   CMCHKUNPK(oduPackUInt8,  &param->emtcNumMpdcchNBtoMonitor, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->emtcNumRepPerPreambleAtt, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->emtcMaxPremAttemptCE, mBuf);
+   CMCHKUNPK(oduPackUInt16,  &param->emtcPrachStartSubFrame, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->emtcPrachFreqOffset, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->emtcPrachCfgIdx, mBuf); 
+   return ROK;
 }
 
 
 
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcPrachCfg
+S16 cmUnpkRgrEmtcPrachCfg
 (
 RgrEmtcPrachCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrEmtcPrachCfg(param, mBuf)
-RgrEmtcPrachCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmUnpkRgrEmtcPrachCfg)
    for (i=0; i < RGR_MAX_CE_LEVEL; i++) {   	
  	CMCHKUNPK(cmUnpkRgrEmtcPrachCeParamCfg, &param->emtcPrachCEparmLst[i], mBuf);
    	}
- 	CMCHKUNPK(SUnpkU8, &param->emtcInitialCElevel, mBuf);
- 	CMCHKUNPK(SUnpkU8, &param->emtcPrachHopingOffset, mBuf);
- 	CMCHKUNPK(SUnpkU8, &param->emtcMpdcchStartSFCssRaFdd, mBuf);
+ 	CMCHKUNPK(oduPackUInt8, &param->emtcInitialCElevel, mBuf);
+ 	CMCHKUNPK(oduPackUInt8, &param->emtcPrachHopingOffset, mBuf);
+ 	CMCHKUNPK(oduPackUInt8, &param->emtcMpdcchStartSFCssRaFdd, mBuf);
 
- RETVALUE(ROK);
+ return ROK;
 }
 
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcCfg
+S16 cmUnpkRgrEmtcCfg
 (
 RgrEmtcCellCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrEmtcCfg(param, mBuf)
-RgrEmtcCellCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrEmtcCfg)
-   CMCHKUNPK(SUnpkU8, &param->emtcPuschNbIdx, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->emtcMpdcchNbIdx, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->emtcPdschNbIdx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->emtcPuschNbIdx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->emtcMpdcchNbIdx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->emtcPdschNbIdx, mBuf);
    CMCHKUNPK(cmUnpkRgrEmtcRntiCfg, &param->emtcMacRnti, mBuf);
    CMCHKUNPK(cmUnpkRgrEmtcPucchCfg, &param->emtcPucchCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrEmtcPrachCfg, &param->emtcPrachCfg, mBuf);
@@ -2154,15 +1778,15 @@ Buffer *mBuf;
    CMCHKUNPK(cmUnpkRgrEmtcPdschCfg, &param->emtcPdschCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrEmtcRachCfg, &param->emtcRachCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrEmtcSiCfg, &param->emtcSiCfg, mBuf);
-   CMCHKUNPK(SUnpkU32,&param->emtcT301Tmr, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->emtcT300Tmr, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->pci, mBuf);
+   CMCHKUNPK(oduPackUInt32,&param->emtcT301Tmr, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->emtcT300Tmr, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->pci, mBuf);
 
 
 
 
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /* EMTC related unpack changes end*/
@@ -2186,24 +1810,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrBwCfg
+S16 cmUnpkRgrBwCfg
 (
 RgrBwCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrBwCfg(param, mBuf)
-RgrBwCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrBwCfg)
-
-   CMCHKUNPK(SUnpkU8, &param->dlTotalBw, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->ulTotalBw, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->dlTotalBw, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ulTotalBw, mBuf);
+   return ROK;
 }
 
 
@@ -2223,24 +1839,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrPhichCfg
+S16 cmPkRgrPhichCfg
 (
 RgrPhichCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrPhichCfg(param, mBuf)
-RgrPhichCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrPhichCfg)
-
-   CMCHKPK(SPkU8, param->isDurExtend, mBuf);
-   CMCHKPK(SPkU32, param->ngEnum, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->isDurExtend, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->ngEnum, mBuf);
+   return ROK;
 }
 
 
@@ -2260,26 +1868,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrPhichCfg
+S16 cmUnpkRgrPhichCfg
 (
 RgrPhichCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrPhichCfg(param, mBuf)
-RgrPhichCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrPhichCfg)
 
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->ngEnum = (RgrPhichNg) tmpEnum;
-   CMCHKUNPK(SUnpkU8, &param->isDurExtend, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->isDurExtend, mBuf);
+   return ROK;
 }
 
 
@@ -2299,28 +1900,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrPucchCfg
+S16 cmPkRgrPucchCfg
 (
 RgrPucchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrPucchCfg(param, mBuf)
-RgrPucchCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrPucchCfg)
+   CMCHKPK(oduUnpackUInt8, param->maxPucchRb, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->cyclicShift, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->deltaShift, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->n1PucchAn, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->resourceSize, mBuf);
 
-   CMCHKPK(SPkU8, param->maxPucchRb, mBuf);
-   CMCHKPK(SPkU8, param->cyclicShift, mBuf);
-   CMCHKPK(SPkU8, param->deltaShift, mBuf);
-   CMCHKPK(SPkU16, param->n1PucchAn, mBuf);
-   CMCHKPK(SPkU8, param->resourceSize, mBuf);
-
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2340,28 +1933,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrPucchCfg
+S16 cmUnpkRgrPucchCfg
 (
 RgrPucchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrPucchCfg(param, mBuf)
-RgrPucchCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrPucchCfg)
+   CMCHKUNPK(oduPackUInt8, &param->resourceSize, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->n1PucchAn, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->deltaShift, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cyclicShift, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxPucchRb, mBuf);
 
-   CMCHKUNPK(SUnpkU8, &param->resourceSize, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->n1PucchAn, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->deltaShift, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->cyclicShift, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->maxPucchRb, mBuf);
-
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2381,26 +1966,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrSrsCfg
+S16 cmPkRgrSrsCfg
 (
 RgrSrsCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrSrsCfg(param, mBuf)
-RgrSrsCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrSrsCfg)
 
-   CMCHKPK(SPkU8, param->srsSubFrameCfg, mBuf);
-   CMCHKPK(SPkU32, param->srsBwEnum, mBuf);
-   CMCHKPK(SPkU32, param->srsCfgPrdEnum, mBuf);
-   CMCHKPK(SPkU8, param->isSrsCfgSetup, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->srsSubFrameCfg, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->srsBwEnum, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->srsCfgPrdEnum, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isSrsCfgSetup, mBuf);
+   return ROK;
 }
 
 
@@ -2420,29 +1998,21 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSrsCfg
+S16 cmUnpkRgrSrsCfg
 (
 RgrSrsCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrSrsCfg(param, mBuf)
-RgrSrsCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrSrsCfg)
-
-   CMCHKUNPK(SUnpkU8, &param->isSrsCfgSetup, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isSrsCfgSetup, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->srsCfgPrdEnum = (RgrSrsCfgPrd) tmpEnum;
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->srsBwEnum = (RgrSrsBwCfg) tmpEnum;
-   CMCHKUNPK(SUnpkU8, &param->srsSubFrameCfg, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->srsSubFrameCfg, mBuf);
+   return ROK;
 }
 
 
@@ -2462,40 +2032,33 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrRachCfg
+S16 cmPkRgrRachCfg
 (
 RgrRachCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrRachCfg(param, mBuf)
-RgrRachCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmPkRgrRachCfg)
 
-   CMCHKPK(SPkU8, param->prachResource, mBuf);
-   CMCHKPK(SPkU16, param->msgSizeGrpA, mBuf);
-   CMCHKPK(SPkU8, param->sizeRaPreambleGrpA, mBuf);
-   CMCHKPK(SPkU8, param->numRaPreamble, mBuf);
-   CMCHKPK(SPkU8, param->maxMsg3Tx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->prachResource, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->msgSizeGrpA, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->sizeRaPreambleGrpA, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numRaPreamble, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxMsg3Tx, mBuf);
       for (i=param->raOccasion.size-1; i >= 0; i--) {
-         CMCHKPK(SPkU8, param->raOccasion.subFrameNum[i], mBuf);
+         CMCHKPK(oduUnpackUInt8, param->raOccasion.subFrameNum[i], mBuf);
       }
-      CMCHKPK(SPkU32, param->raOccasion.sfnEnum, mBuf);
-      CMCHKPK(SPkU8, param->raOccasion.size, mBuf);
-   CMCHKPK(SPkU8, param->raWinSize, mBuf);
-   CMCHKPK(SPkU8, param->preambleFormat, mBuf);
+      CMCHKPK(oduUnpackUInt32, param->raOccasion.sfnEnum, mBuf);
+      CMCHKPK(oduUnpackUInt8, param->raOccasion.size, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->raWinSize, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->preambleFormat, mBuf);
 #ifdef RGR_V1
    /* rgr_c_001.main_5: cccpu00112372: Added contention resolution 
     * timer configuration */
-   CMCHKPK(SPkU8, param->contResTmr, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->contResTmr, mBuf);
 #endif
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2515,41 +2078,34 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrRachCfg
+S16 cmUnpkRgrRachCfg
 (
 RgrRachCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrRachCfg(param, mBuf)
-RgrRachCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
    S32 i;
-   TRC3(cmUnpkRgrRachCfg)
 #ifdef RGR_V1 
    /* rgr_c_001.main_5: cccpu00112372: Added contention resolution 
     * timer configuration */
-   CMCHKUNPK(SUnpkU8, &param->contResTmr, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->contResTmr, mBuf);
 #endif
-   CMCHKUNPK(SUnpkU8, &param->preambleFormat, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->raWinSize, mBuf);
-      CMCHKUNPK(SUnpkU8, &param->raOccasion.size, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->preambleFormat, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->raWinSize, mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->raOccasion.size, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->raOccasion.sfnEnum = (RgrRaSfn) tmpEnum;
       for (i=0; i<param->raOccasion.size; i++) {
-         CMCHKUNPK(SUnpkU8, &param->raOccasion.subFrameNum[i], mBuf);
+         CMCHKUNPK(oduPackUInt8, &param->raOccasion.subFrameNum[i], mBuf);
       }
-   CMCHKUNPK(SUnpkU8, &param->maxMsg3Tx, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numRaPreamble, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->sizeRaPreambleGrpA, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->msgSizeGrpA, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->prachResource, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->maxMsg3Tx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numRaPreamble, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->sizeRaPreambleGrpA, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->msgSizeGrpA, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->prachResource, mBuf);
+   return ROK;
 }
 
 
@@ -2569,24 +2125,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrSiCfg
+S16 cmPkRgrSiCfg
 (
 RgrSiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrSiCfg(param, mBuf)
-RgrSiCfg *param;
-Buffer *mBuf;
-#endif
 {
    /* rgr_c_001.main_4:MOD-Modified for SI Enhancement. */
 #ifdef RGR_SI_SCH
    S16 idx;
 #endif/*RGR_SI_SCH*/
 
-   TRC3(cmPkRgrSiCfg)
 
 #ifdef RGR_SI_SCH
    if(param->numSi > sizeof(param->siPeriodicity)/
@@ -2595,16 +2144,16 @@ Buffer *mBuf;
                        sizeof(param->siPeriodicity[0]);
 
    for (idx=param->numSi-1; idx >= 0; idx--) {
-   /* Enum to be packed/unpacked as U32 instead of S32 */
-      CMCHKPK(SPkU32, param->siPeriodicity[idx], mBuf);
+   /* Enum to be packed/unpacked as uint32_t instead of S32 */
+      CMCHKPK(oduUnpackUInt32, param->siPeriodicity[idx], mBuf);
    }
-   CMCHKPK(SPkU8, param->numSi, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numSi, mBuf);
    /*rgr_c_001.main_9 ccpu00115364 MOD changed modPrd to enum*/
-   CMCHKPK(SPkU32, (U32)param->modPrd, mBuf);
+   CMCHKPK(oduUnpackUInt32, (uint32_t)param->modPrd, mBuf);
 #endif/*RGR_SI_SCH*/
-   CMCHKPK(SPkU8, param->retxCnt, mBuf);
-   CMCHKPK(SPkU8, param->siWinSize, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->retxCnt, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->siWinSize, mBuf);
+   return ROK;
 }
 
 
@@ -2624,47 +2173,40 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSiCfg
+S16 cmUnpkRgrSiCfg
 (
 RgrSiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrSiCfg(param, mBuf)
-RgrSiCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
    /* rgr_c_001.main_4:MOD-Modified for SI Enhancement. */
 #ifdef RGR_SI_SCH
    S16 idx;
 #endif/*RGR_SI_SCH*/
 
-   TRC3(cmUnpkRgrSiCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->siWinSize, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->retxCnt, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->siWinSize, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->retxCnt, mBuf);
 #ifdef RGR_SI_SCH
    /*rgr_c_001.main_9 ccpu00115364 MOD changed modPrd to enum*/
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->modPrd = (RgrModPeriodicity) tmpEnum;
-   CMCHKUNPK(SUnpkU8, &param->numSi, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numSi, mBuf);
 
    if(param->numSi > sizeof(param->siPeriodicity)/
                        sizeof(param->siPeriodicity[0]))
       param->numSi = sizeof(param->siPeriodicity)/
                        sizeof(param->siPeriodicity[0]);
 
-   /* Enum to be packed/unpacked as U32 instead of S32 */
+   /* Enum to be packed/unpacked as uint32_t instead of S32 */
    for (idx=0; idx < param->numSi; idx++) {
-      CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+      CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
       param->siPeriodicity[idx] = (RgrSiPeriodicity) tmpEnum;
    }
 #endif/*RGR_SI_SCH*/
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2684,24 +2226,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrTpcRntiCfg
+S16 cmPkRgrTpcRntiCfg
 (
 RgrTpcRntiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrTpcRntiCfg(param, mBuf)
-RgrTpcRntiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrTpcRntiCfg)
 
-   CMCHKPK(SPkU16, param->size, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->size, mBuf);
    CMCHKPK(cmPkLteRnti, param->startTpcRnti, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2721,24 +2256,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrTpcRntiCfg
+S16 cmUnpkRgrTpcRntiCfg
 (
 RgrTpcRntiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrTpcRntiCfg(param, mBuf)
-RgrTpcRntiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrTpcRntiCfg)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->startTpcRnti, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->size, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt16, &param->size, mBuf);
+   return ROK;
 }
 
 
@@ -2758,30 +2286,22 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUlPwrCfg
+S16 cmPkRgrUlPwrCfg
 (
 RgrUlPwrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUlPwrCfg(param, mBuf)
-RgrUlPwrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUlPwrCfg)
-
    CMCHKPK(cmPkRgrTpcRntiCfg, &param->puschPwrFmt3a, mBuf);
    CMCHKPK(cmPkRgrTpcRntiCfg, &param->puschPwrFmt3, mBuf);
    CMCHKPK(cmPkRgrTpcRntiCfg, &param->pucchPwrFmt3a, mBuf);
    CMCHKPK(cmPkRgrTpcRntiCfg, &param->pucchPwrFmt3, mBuf);
    CMCHKPK(SPkS8, param->deltaPreambleMsg3, mBuf);
    CMCHKPK(SPkS8, param->p0NominalPucch, mBuf);
-   CMCHKPK(SPkU32, param->alpha, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->alpha, mBuf);
    CMCHKPK(SPkS8, param->p0NominalPusch, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2801,24 +2321,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUlPwrCfg
+S16 cmUnpkRgrUlPwrCfg
 (
 RgrUlPwrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUlPwrCfg(param, mBuf)
-RgrUlPwrCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrUlPwrCfg)
 
    CMCHKUNPK(SUnpkS8, &param->p0NominalPusch, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->alpha = (RgrPwrAlpha) tmpEnum;
    CMCHKUNPK(SUnpkS8, &param->p0NominalPucch, mBuf);
    CMCHKUNPK(SUnpkS8, &param->deltaPreambleMsg3, mBuf);
@@ -2826,7 +2339,7 @@ Buffer *mBuf;
    CMCHKUNPK(cmUnpkRgrTpcRntiCfg, &param->pucchPwrFmt3a, mBuf);
    CMCHKUNPK(cmUnpkRgrTpcRntiCfg, &param->puschPwrFmt3, mBuf);
    CMCHKUNPK(cmUnpkRgrTpcRntiCfg, &param->puschPwrFmt3a, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2846,25 +2359,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrPuschCfg
+S16 cmPkRgrPuschCfg
 (
 RgrPuschCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrPuschCfg(param, mBuf)
-RgrPuschCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrPuschCfg)
 
-   CMCHKPK(SPkU8, param->hopOffst, mBuf);
-   CMCHKPK(SPkU8, param->isIntraHop, mBuf);
-   CMCHKPK(SPkU8, param->numSubBands, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->hopOffst, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isIntraHop, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numSubBands, mBuf);
+   return ROK;
 }
 
 
@@ -2884,25 +2390,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrPuschCfg
+S16 cmUnpkRgrPuschCfg
 (
 RgrPuschCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrPuschCfg(param, mBuf)
-RgrPuschCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrPuschCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->numSubBands, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isIntraHop, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->hopOffst, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->numSubBands, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isIntraHop, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->hopOffst, mBuf);
+   return ROK;
 }
 
 
@@ -2922,27 +2421,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrCodeBookRstCfg
+S16 cmPkRgrCodeBookRstCfg
 (
 RgrCodeBookRstCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrCodeBookRstCfg(param, mBuf)
-RgrCodeBookRstCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmPkRgrCodeBookRstCfg)
 
    for (i=1-1; i >= 0; i--) {
-      CMCHKPK(SPkU32, param->pmiBitMap[i], mBuf);
+      CMCHKPK(oduUnpackUInt32, param->pmiBitMap[i], mBuf);
    }
-   CMCHKPK(SPkU8, param->pres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+   return ROK;
 }
 
 
@@ -2962,27 +2454,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCodeBookRstCfg
+S16 cmUnpkRgrCodeBookRstCfg
 (
 RgrCodeBookRstCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrCodeBookRstCfg(param, mBuf)
-RgrCodeBookRstCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmUnpkRgrCodeBookRstCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
    for (i=0; i<1; i++) {
-      CMCHKUNPK(SUnpkU32, &param->pmiBitMap[i], mBuf);
+      CMCHKUNPK(oduPackUInt32, &param->pmiBitMap[i], mBuf);
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3002,25 +2487,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrPreambleSetCfg
+S16 cmPkRgrPreambleSetCfg
 (
 RgrPreambleSetCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrPreambleSetCfg(param, mBuf)
-RgrPreambleSetCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrPreambleSetCfg)
 
-   CMCHKPK(SPkU8, param->size, mBuf);
-   CMCHKPK(SPkU8, param->start, mBuf);
-   CMCHKPK(SPkU8, param->pres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->size, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->start, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+   return ROK;
 }
 
 
@@ -3040,25 +2518,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrPreambleSetCfg
+S16 cmUnpkRgrPreambleSetCfg
 (
 RgrPreambleSetCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrPreambleSetCfg(param, mBuf)
-RgrPreambleSetCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrPreambleSetCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->start, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->size, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->start, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->size, mBuf);
+   return ROK;
 }
 
 
@@ -3078,27 +2549,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrCmnLchCfg
+S16 cmPkRgrCmnLchCfg
 (
 RgrCmnLchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrCmnLchCfg(param, mBuf)
-RgrCmnLchCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrCmnLchCfg)
-
-   CMCHKPK(SPkU8, param->ulTrchType, mBuf);
-   CMCHKPK(SPkU8, param->dlTrchType, mBuf);
-   CMCHKPK(SPkU8, param->dir, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->ulTrchType, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->dir, mBuf);
    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3118,27 +2581,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCmnLchCfg
+S16 cmUnpkRgrCmnLchCfg
 (
 RgrCmnLchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrCmnLchCfg(param, mBuf)
-RgrCmnLchCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrCmnLchCfg)
 
    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->dir, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->dlTrchType, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->ulTrchType, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->dir, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->dlTrchType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ulTrchType, mBuf);
+   return ROK;
 }
 
 
@@ -3158,24 +2614,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrDlfsCfg
+S16 cmPkRgrDlfsCfg
 (
 RgrDlfsCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrDlfsCfg(param, mBuf)
-RgrDlfsCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrDlfsCfg)
 
-   CMCHKPK(SPkU8, param->thresholdCqi, mBuf);
-   CMCHKPK(SPkU8, param->isDlFreqSel, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->thresholdCqi, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isDlFreqSel, mBuf);
+   return ROK;
 }
 
 
@@ -3195,24 +2644,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDlfsCfg
+S16 cmUnpkRgrDlfsCfg
 (
 RgrDlfsCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrDlfsCfg(param, mBuf)
-RgrDlfsCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrDlfsCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->isDlFreqSel, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->thresholdCqi, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->isDlFreqSel, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->thresholdCqi, mBuf);
+   return ROK;
 }
 
 
@@ -3236,26 +2678,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrTddPrachInfo
+S16 cmPkRgrTddPrachInfo
 (
 RgrTddPrachInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrTddPrachInfo(param, mBuf)
-RgrTddPrachInfo *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrTddPrachInfo)
 
-   CMCHKPK(SPkU8, param->ulStartSfIdx, mBuf);
-   CMCHKPK(SPkU8, param->halfFrm, mBuf);
-   CMCHKPK(SPkU32, param->sfn, mBuf);
-   CMCHKPK(SPkU8, param->freqIdx, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->ulStartSfIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->halfFrm, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->sfn, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->freqIdx, mBuf);
+   return ROK;
 }
 
 
@@ -3275,28 +2710,21 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrTddPrachInfo
+S16 cmUnpkRgrTddPrachInfo
 (
 RgrTddPrachInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrTddPrachInfo(param, mBuf)
-RgrTddPrachInfo *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrTddPrachInfo)
 
-   CMCHKUNPK(SUnpkU8, &param->freqIdx, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->freqIdx, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->sfn = tmpEnum;
-   CMCHKUNPK(SUnpkU8, &param->halfFrm, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->ulStartSfIdx, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->halfFrm, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ulStartSfIdx, mBuf);
+   return ROK;
 }
 
 
@@ -3316,27 +2744,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrTddPrachRscInfo
+S16 cmPkRgrTddPrachRscInfo
 (
 RgrTddPrachRscInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrTddPrachRscInfo(param, mBuf)
-RgrTddPrachRscInfo *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmPkRgrTddPrachRscInfo)
 
    for (i=param->numRsc-1; i >= 0; i--) {
       CMCHKPK(cmPkRgrTddPrachInfo, &param->prachInfo[i], mBuf);
    }
-   CMCHKPK(SPkU8, param->numRsc, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->numRsc, mBuf);
+   return ROK;
 }
 
 
@@ -3356,27 +2777,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrTddPrachRscInfo
+S16 cmUnpkRgrTddPrachRscInfo
 (
 RgrTddPrachRscInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrTddPrachRscInfo(param, mBuf)
-RgrTddPrachRscInfo *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmUnpkRgrTddPrachRscInfo)
 
-   CMCHKUNPK(SUnpkU8, &param->numRsc, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numRsc, mBuf);
    for (i=0; i<param->numRsc; i++) {
       CMCHKUNPK(cmUnpkRgrTddPrachInfo, &param->prachInfo[i], mBuf);
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3400,28 +2814,21 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrEnbPfs
+S16 cmPkRgrEnbPfs
 (
 RgrEnbPfs  *param,
 Buffer    *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrEnbPfs(param, mBuf)
-RgrEnbPfs  *param;
-Buffer    *mBuf;
-#endif
 {
    S32 idx;
-   TRC3(cmPkRgrEnbPfs)
    for(idx = RGR_MAX_NUM_QCI-1; idx >= 0; idx--)
    {
-      CMCHKPK(SPkU32, param->qciWgt[idx], mBuf);
+      CMCHKPK(oduUnpackUInt32, param->qciWgt[idx], mBuf);
    }   
-   CMCHKPK(SPkU8, param->fairCoeffi, mBuf);
-   CMCHKPK(SPkU8, param->tptCoeffi, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->fairCoeffi, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->tptCoeffi, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3441,28 +2848,21 @@ Buffer    *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEnbPfs
+S16 cmUnpkRgrEnbPfs
 (
 RgrEnbPfs *param,
 Buffer   *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrEnbPfs(param, mBuf)
-RgrEnbPfs *param;
-Buffer *mBuf;
-#endif
 {
    S32 idx;
-   TRC3(cmUnpkRgrEnbPfs)
 
-   CMCHKUNPK(SUnpkU8, &param->tptCoeffi, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->fairCoeffi, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->tptCoeffi, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->fairCoeffi, mBuf);
    for(idx = 0; idx < RGR_MAX_NUM_QCI; idx++)
    {
-      CMCHKUNPK(SUnpkU32, &param->qciWgt[idx], mBuf);
+      CMCHKUNPK(oduPackUInt32, &param->qciWgt[idx], mBuf);
    }   
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /*rgr_c_001.main_7 - Added support for SPS*/
@@ -3483,25 +2883,18 @@ TODO: Check if this is to be added to re-configuration as well
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrSpsCellCfg
+S16 cmPkRgrSpsCellCfg
 (
 RgrSpsCellCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrSpsCellCfg(param, mBuf)
-RgrSpsCellCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrSpsCellCfg)
-   CMCHKPK(SPkU16, param->maxSpsUePerUlSf, mBuf);
-   CMCHKPK(SPkU16, param->maxSpsUePerDlSf, mBuf);
-   CMCHKPK(SPkU8, param->maxSpsDlBw, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->maxSpsUePerUlSf, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->maxSpsUePerDlSf, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxSpsDlBw, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3522,30 +2915,23 @@ TODO: Check if this is to be added to re-configuration as well
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSpsDlCellCfg
+S16 cmUnpkRgrSpsDlCellCfg
 (
 RgrSpsCellCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrSpsDlCellCfg(param, mBuf)
-RgrSpsCellCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrSpsDlCellCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->maxSpsDlBw, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->maxSpsUePerDlSf, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->maxSpsUePerUlSf, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxSpsDlBw, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->maxSpsUePerDlSf, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->maxSpsUePerUlSf, mBuf);
    
-   RETVALUE(ROK);
+   return ROK;
 }
 
 #ifdef RG_5GTF
-PUBLIC S16 cmPkRgr5gtfCellCfg
+S16 cmPkRgr5gtfCellCfg
 (
 Rgr5gtfCellCfg   *param,
 Buffer           *mBuf
@@ -3555,18 +2941,18 @@ Buffer           *mBuf
    for (idx = MAX_5GTF_SUBFRAME_INFO - 1; idx >= 0 ;--idx)
    {
 
-      CMCHKPK(SPkU32, param->dynConfig[(U8)idx], mBuf);
+      CMCHKPK(oduUnpackUInt32, param->dynConfig[(uint8_t)idx], mBuf);
    }
-   CMCHKPK(SPkU8, param->uePerGrp, mBuf);
-   CMCHKPK(SPkU8, param->ueGrpPerTti, mBuf);
-   CMCHKPK(SPkU8, param->numUes, mBuf);
-   CMCHKPK(SPkU8, param->numOfCC, mBuf);
-   CMCHKPK(SPkU8, param->bwPerCC, mBuf);
-   CMCHKPK(SPkU8, param->cfi, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->uePerGrp, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->ueGrpPerTti, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numUes, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numOfCC, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->bwPerCC, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->cfi, mBuf);
+   return ROK;
 }
 
-PUBLIC S16 cmUnPkRgr5gtfCellCfg
+S16 cmUnPkRgr5gtfCellCfg
 (
 Rgr5gtfCellCfg   *param,
 Buffer           *mBuf
@@ -3574,18 +2960,18 @@ Buffer           *mBuf
 {
    S8 idx = 0;      
    
-   CMCHKUNPK(SUnpkU8, &param->cfi, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->bwPerCC, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numOfCC, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numUes, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->ueGrpPerTti, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->uePerGrp, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cfi, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->bwPerCC, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numOfCC, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numUes, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ueGrpPerTti, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->uePerGrp, mBuf);
    for (idx = 0; idx < MAX_5GTF_SUBFRAME_INFO ; ++idx)
    {
 
-      CMCHKUNPK(SUnpkU32, &param->dynConfig[(U8)idx], mBuf);
+      CMCHKUNPK(oduPackUInt32, &param->dynConfig[(uint8_t)idx], mBuf);
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 #endif
 
@@ -3606,23 +2992,16 @@ Buffer           *mBuf
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PRIVATE S16 cmPkRgrLteUCellCfg
+static S16 cmPkRgrLteUCellCfg
 (
 RgrLteUCfg *param,
 Buffer *mBuf
 )
-#else
-PRIVATE S16 cmPkRgrLteUCellCfg(param, mBuf)
-RgrLteUCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrlteUCellCfg)
-   CMCHKPK(SPkU8, param->isLaaCell, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isLaaCell, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -3640,24 +3019,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PRIVATE S16 cmUnpkRgrLteUCellCfg
+static S16 cmUnpkRgrLteUCellCfg
 (
 RgrLteUCfg *param,
 Buffer *mBuf
 )
-#else
-PRIVATE S16 cmUnpkRgrLteUCellCfg(param, mBuf)
-RgrLteUCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrLteUCellCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->isLaaCell, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isLaaCell, mBuf);
    
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /* LTE_ADV_FLAG_REMOVED_START */
@@ -3676,24 +3048,17 @@ Buffer *mBuf;
  *     File  : 
  *
  **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrLteAdvancedUeConfig
+S16 cmPkRgrLteAdvancedUeConfig
 (
- RgrLteAdvancedUeConfig *param,
- Buffer *mBuf
- )
-#else
-PUBLIC S16 cmPkRgrLteAdvancedUeConfig(param, mBuf)
-   RgrLteAdvancedUeConfig *param;
-   Buffer *mBuf;
-#endif
+RgrLteAdvancedUeConfig *param,
+Buffer *mBuf
+)
 {
 
-   TRC3(cmPkRgrLteAdvancedUeConfig)
-   CMCHKPK(SPkU8, param->isUeCellEdge, mBuf);
-   CMCHKPK(SPkU8, param->isAbsUe, mBuf);
-   CMCHKPK(SPkU32, param->pres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->isUeCellEdge, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isAbsUe, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->pres, mBuf);
+   return ROK;
 }
 
 /***********************************************************
@@ -3711,24 +3076,17 @@ PUBLIC S16 cmPkRgrLteAdvancedUeConfig(param, mBuf)
  *     File  : 
  *
  **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLteAdvancedUeConfig
+S16 cmUnpkRgrLteAdvancedUeConfig
 (
- RgrLteAdvancedUeConfig *param,
- Buffer *mBuf
- )
-#else
-PUBLIC S16 cmUnpkRgrLteAdvancedUeConfig(param, mBuf)
-   RgrLteAdvancedUeConfig *param;
-   Buffer *mBuf;
-#endif
+RgrLteAdvancedUeConfig *param,
+Buffer *mBuf
+)
 {
 
-   TRC3(cmUnpkRgrLteAdvancedUeConfig)
-   CMCHKUNPK(SUnpkU32, &param->pres, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isAbsUe, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isUeCellEdge, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt32, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isAbsUe, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isUeCellEdge, mBuf);
+   return ROK;
 }
 
 /***********************************************************
@@ -3746,31 +3104,24 @@ PUBLIC S16 cmUnpkRgrLteAdvancedUeConfig(param, mBuf)
  *     File  : 
  *
  **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrAbsConfig
+S16 cmPkRgrAbsConfig
 (
- RgrAbsConfig *param,
- Buffer *mBuf
- )
-#else
-PUBLIC S16 cmPkRgrAbsConfig(param, mBuf)
-   RgrAbsConfig *param;
-   Buffer *mBuf;
-#endif
+RgrAbsConfig *param,
+Buffer *mBuf
+)
 {
    S8   indx = 0;
 
-   TRC3(cmPkRgrAbsConfig)
-   CMCHKPK(SPkU32, (U32)param->status, mBuf);
+   CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
    for (indx = RGR_ABS_PATTERN_LEN-1; indx >= 0; indx--) 
    {
-      CMCHKPK(SPkU8, param->absPattern[(U8)indx], mBuf);
+      CMCHKPK(oduUnpackUInt8, param->absPattern[(uint8_t)indx], mBuf);
    }
 
-   CMCHKPK(SPkU32, param->absPatternType, mBuf);
-   CMCHKPK(SPkU32, param->absLoadPeriodicity, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->absPatternType, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->absLoadPeriodicity, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 
 }
 /***********************************************************
@@ -3788,29 +3139,22 @@ PUBLIC S16 cmPkRgrAbsConfig(param, mBuf)
  *     File  : 
  *
  **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrSfrConfig
+S16 cmPkRgrSfrConfig
 (
- RgrSfrConfig *param,
- Buffer *mBuf
- )
-#else
-PUBLIC S16 cmPkRgrSfrConfig(param, mBuf)
-   RgrSfrConfig *param;
-   Buffer *mBuf;
-#endif
+RgrSfrConfig *param,
+Buffer *mBuf
+)
 {
-   TRC3(cmPkRgrSfrConfig)
 
-   CMCHKPK(SPkU32, (U32)param->status, mBuf);
+   CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
 #ifdef TFU_UPGRADE   
-   CMCHKPK(SPkU32, param->pwrThreshold.pHigh, mBuf);
-   CMCHKPK(SPkU32, param->pwrThreshold.pLow, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->pwrThreshold.pHigh, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->pwrThreshold.pLow, mBuf);
 #endif   
-   CMCHKPK(SPkU8, param->cellEdgeRbRange.endRb, mBuf);
-   CMCHKPK(SPkU8, param->cellEdgeRbRange.startRb, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->cellEdgeRbRange.endRb, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->cellEdgeRbRange.startRb, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 
 }
 
@@ -3830,23 +3174,16 @@ PUBLIC S16 cmPkRgrSfrConfig(param, mBuf)
  *     File  : 
  *
  **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrDsfrConfig
+S16 cmPkRgrDsfrConfig
 (
- RgrDsfrConfig *param,
- Buffer *mBuf
- )
-#else
-PUBLIC S16 cmPkRgrDsfrConfig(param, mBuf)
-   RgrDsfrConfig *param;
-   Buffer *mBuf;
-#endif
+RgrDsfrConfig *param,
+Buffer *mBuf
+)
 {
-   TRC3(cmPkRgrDsfrConfig)
 
-   CMCHKPK(SPkU32, (U32)param->status, mBuf);
+   CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 
 }
 
@@ -3866,22 +3203,15 @@ PUBLIC S16 cmPkRgrDsfrConfig(param, mBuf)
  *     File  : 
  *
  **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDsfrConfig
+S16 cmUnpkRgrDsfrConfig
 (
- RgrDsfrConfig *param,
- Buffer *mBuf
- )
-#else
-PUBLIC S16 cmUnpkRgrDsfrConfig(param, mBuf)
-   RgrDsfrConfig *param;
-   Buffer *mBuf;
-#endif
+RgrDsfrConfig *param,
+Buffer *mBuf
+)
 {
-   TRC3(cmUnpkRgrDsfrConfig)
 
-   CMCHKUNPK(SUnpkU32, (U32 *)&param->status, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->status, mBuf);
+   return ROK;
 
 }
 
@@ -3901,26 +3231,20 @@ PUBLIC S16 cmUnpkRgrDsfrConfig(param, mBuf)
  *     File  : 
  *
  **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrCellLteAdvancedFeatureCfg
+
+S16 cmPkRgrCellLteAdvancedFeatureCfg
 (
- RgrLteAdvancedCellConfig *param,
- Buffer *mBuf
- )
-#else
-PUBLIC S16 cmPkRgrCellLteAdvancedFeatureCfg(param, mBuf)
-   RgrLteAdvancedCellConfig *param;
-   Buffer *mBuf;
-#endif
+RgrLteAdvancedCellConfig *param,
+Buffer *mBuf
+)
 {
-   TRC3(cmPkRgrCellLteAdvancedFeatureCfg)
 
-   CMCHKPK(SPkU32, param->pres, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->pres, mBuf);
    CMCHKPK(cmPkRgrDsfrConfig, &param->dsfrCfg, mBuf); /*AIRSPAN_LTE_ADV_DSFR*/
    CMCHKPK(cmPkRgrSfrConfig,  &param->sfrCfg, mBuf);
    CMCHKPK(cmPkRgrAbsConfig,  &param->absCfg, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 
 }   
 
@@ -3940,31 +3264,24 @@ PUBLIC S16 cmPkRgrCellLteAdvancedFeatureCfg(param, mBuf)
  *     File  : 
  *
  **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrAbsConfig
+S16 cmUnpkRgrAbsConfig
 (
- RgrAbsConfig *param,
- Buffer *mBuf
- )
-#else
-PUBLIC S16 cmUnpkRgrAbsConfig(param, mBuf)
-   RgrAbsConfig *param;
-   Buffer *mBuf;
-#endif
+RgrAbsConfig *param,
+Buffer *mBuf
+)
 {
 
    S8 indx = 0;
-   TRC3(cmUnpkRgrAbsConfig)
 
-   CMCHKUNPK(SUnpkU32, &param->absLoadPeriodicity, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->absPatternType, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->absLoadPeriodicity, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->absPatternType, mBuf);
    for (indx = 0; indx <RGR_ABS_PATTERN_LEN; indx++) 
    {
-      CMCHKUNPK(SUnpkU8, &param->absPattern[(U8)indx], mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->absPattern[(uint8_t)indx], mBuf);
    }
-   CMCHKUNPK(SUnpkU32, (U32*)&param->status, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->status, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 
 }
 
@@ -3983,30 +3300,23 @@ PUBLIC S16 cmUnpkRgrAbsConfig(param, mBuf)
  *     File  : 
  *
  **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSfrConfig
+S16 cmUnpkRgrSfrConfig
 (
- RgrSfrConfig *param,
- Buffer *mBuf
- )
-#else
-PUBLIC S16 cmUnpkRgrSfrConfig(param, mBuf)
-   RgrSfrConfig *param;
-   Buffer *mBuf;
-#endif
+RgrSfrConfig *param,
+Buffer *mBuf
+)
 {
 
-   TRC3(cmUnpkRgrSfrConfig)
 
-   CMCHKUNPK(SUnpkU8, &param->cellEdgeRbRange.startRb, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->cellEdgeRbRange.endRb, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cellEdgeRbRange.startRb, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cellEdgeRbRange.endRb, mBuf);
 #ifdef TFU_UPGRADE   
-   CMCHKUNPK(SUnpkU32, (U32*)&param->pwrThreshold.pLow, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32*)&param->pwrThreshold.pHigh, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->pwrThreshold.pLow, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->pwrThreshold.pHigh, mBuf);
 #endif   
-   CMCHKUNPK(SUnpkU32, (U32*)&param->status, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->status, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -4024,26 +3334,19 @@ PUBLIC S16 cmUnpkRgrSfrConfig(param, mBuf)
  *     File  : 
  *
  **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCellLteAdvancedFeatureCfg
+S16 cmUnpkRgrCellLteAdvancedFeatureCfg
 (
- RgrLteAdvancedCellConfig *param,
- Buffer *mBuf
- )
-#else
-PUBLIC S16 cmUnpkRgrCellLteAdvancedFeatureCfg(param, mBuf)
-   RgrLteAdvancedCellConfig *param;
-   Buffer *mBuf;
-#endif
+RgrLteAdvancedCellConfig *param,
+Buffer *mBuf
+)
 {
 
-   TRC3(cmUnpkRgrCellLteAdvancedFeatureCfg)
    CMCHKUNPK(cmUnpkRgrAbsConfig, &param->absCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrSfrConfig, &param->sfrCfg, mBuf);   
    CMCHKUNPK(cmUnpkRgrDsfrConfig, &param->dsfrCfg, mBuf); /*AIRSPAN_LTE_ADV_DSFR*/
-   CMCHKUNPK(SUnpkU32, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->pres, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /* LTE_ADV_FLAG_REMOVED_END */
@@ -4061,27 +3364,20 @@ PUBLIC S16 cmUnpkRgrCellLteAdvancedFeatureCfg(param, mBuf)
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkMacSchedGnbCfg
+S16 cmPkMacSchedGnbCfg
 (
 MacSchedGnbCfg *param,
 Buffer         *mBuf
 )
-#else
-PUBLIC S16 cmPkMacSchedGnbCfg(param, mBuf)
-RgrSchedEnbCfg *param;
-Buffer         *mBuf;
-#endif
 {
-   TRC3(cmPkMacSchedGnbCfg)
 
-   CMCHKPK(SPkU8, param->maxDlUePerTti, mBuf);
-   CMCHKPK(SPkU8, param->maxUlUePerTti, mBuf);
-   CMCHKPK(SPkU8, param->numCells, mBuf);
-   CMCHKPK(SPkU8, param->dlSchdType, mBuf);
-   CMCHKPK(SPkU8, param->ulSchdType, mBuf);
-   CMCHKPK(SPkU8, param->numTxAntPorts, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->maxDlUePerTti, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxUlUePerTti, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numCells, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->dlSchdType, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->ulSchdType, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numTxAntPorts, mBuf);
+   return ROK;
 } /* cmPkRgrSchedEnbCfg */
 
 /***********************************************************
@@ -4099,28 +3395,21 @@ Buffer         *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchedGnbCfg
+S16 cmUnpkMacSchedGnbCfg
 (
 MacSchedGnbCfg *param,
 Buffer         *mBuf
 )
-#else
-PUBLIC S16 cmUnpkMacSchedGnbCfg(param, mBuf)
-MacSchedGnbCfg *param;
-Buffer         *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkMacSchedGnbCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->numTxAntPorts, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->ulSchdType, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->dlSchdType, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numCells, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->maxUlUePerTti, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->maxDlUePerTti, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->numTxAntPorts, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ulSchdType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->dlSchdType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numCells, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxUlUePerTti, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxDlUePerTti, mBuf);
+   return ROK;
 } /* cmUnpkMacSchedGnbCfg */
 
 
@@ -4139,21 +3428,14 @@ Buffer         *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrCellCfg
+S16 cmPkRgrCellCfg
 (
 RgrCellCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrCellCfg(param, mBuf)
-RgrCellCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmPkRgrCellCfg)
 
 #ifdef EMTC_ENABLE 
 /* EMTC related changes start*/
@@ -4166,35 +3448,35 @@ Buffer *mBuf;
    CMCHKPK(cmPkRgr5gtfCellCfg, &param->Cell5gtfCfg, mBuf);
 #endif
 #ifdef LTE_ADV
-   CMCHKPK(SPkU8, param->isPucchFormat3Sptd, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isPucchFormat3Sptd, mBuf);
 #endif
 /*LAA: Pack LAA params*/
    CMCHKPK(cmPkRgrLteUCellCfg, &param->lteUCfg, mBuf);
-   CMCHKPK(SPkU32, param->msg4pAVal, mBuf);
-   CMCHKPK(SPkU8, param->isAutoCfgModeEnb, mBuf);
-   CMCHKPK(SPkU8, param->isDynCfiEnb, mBuf);
-   CMCHKPK(SPkU16, param->phichTxPwrOffset, mBuf);
-   CMCHKPK(SPkU16, param->rarTxPwrOffset, mBuf);
-   CMCHKPK(SPkU16, param->pcchTxPwrOffset, mBuf);
-   CMCHKPK(SPkU16, param->bcchTxPwrOffset, mBuf);
-
-   CMCHKPK(SPkU16, param->t300TmrVal, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->msg4pAVal, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isAutoCfgModeEnb, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isDynCfiEnb, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->phichTxPwrOffset, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->rarTxPwrOffset, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->pcchTxPwrOffset, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->bcchTxPwrOffset, mBuf);
+
+   CMCHKPK(oduUnpackUInt16, param->t300TmrVal, mBuf);
 /*rgr_c_001.main_7 - Added support for SPS*/
    CMCHKPK(cmPkRgrSpsCellCfg, &param->spsCfg, mBuf);
 
 /* rgr_c_001.main_3: Added TTI indication from MAC to RGR user */
-   CMCHKPK(SPkU8, param->rrmTtiIndPrd, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->rrmTtiIndPrd, mBuf);
 #ifdef LTE_TDD
    CMCHKPK(cmPkRgrTddPrachRscInfo, &param->prachRscInfo, mBuf);
-   CMCHKPK(SPkU8, param->spclSfCfgIdx, mBuf);
-   CMCHKPK(SPkU8, param->ulDlCfgIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->spclSfCfgIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->ulDlCfgIdx, mBuf);
 
 #endif
    CMCHKPK(cmPkRgrCellCsgParamCfg, &param->csgParamCfg, mBuf);
    for (i=param->numCmnLcs-1; i >= 0; i--) {
       CMCHKPK(cmPkRgrCmnLchCfg, &param->cmnLcCfg[i], mBuf);
    }
-   CMCHKPK(SPkU8, param->numCmnLcs, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numCmnLcs, mBuf);
    CMCHKPK(cmPkRgrPreambleSetCfg, &param->macPreambleSet, mBuf);
    CMCHKPK(cmPkRgrPuschCfg, &param->puschCfg, mBuf);
    CMCHKPK(cmPkRgrUlPwrCfg, &param->pwrCfg, mBuf);
@@ -4215,36 +3497,36 @@ Buffer *mBuf;
    CMCHKPK(cmPkRgrCfiCfg, &param->cfiCfg, mBuf);
    CMCHKPK(cmPkRgrRntiCfg, &param->macRnti, mBuf);
    CMCHKPK(cmPkRgrDlHqCfg, &param->dlHqCfg, mBuf);
-   CMCHKPK(SPkU8, param->dlfsSchdType, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->dlfsSchdType, mBuf);
 
    CMCHKPK(SPkS8, param->pMax, mBuf);
-   CMCHKPK(SPkU8, param->cellModSchm, mBuf);
-   CMCHKPK(SPkU8, param->isCpDlExtend, mBuf);
-   CMCHKPK(SPkU8, param->isCpUlExtend, mBuf);
-   CMCHKPK(SPkU8, param->maxUlUeNewTxPerTti, mBuf);
-   CMCHKPK(SPkU8, param->maxDlUeNewTxPerTti, mBuf);
-   CMCHKPK(SPkU8, param->maxDlRetxBw, mBuf);
-   CMCHKPK(SPkU8, param->maxDlBwPerUe, mBuf);
-   CMCHKPK(SPkU8, param->maxUlBwPerUe, mBuf);
-   CMCHKPK(SPkU8, param->maxCcchPerDlSf, mBuf);
-   CMCHKPK(SPkU8, param->maxUePerDlSf, mBuf);
-   CMCHKPK(SPkU8, param->maxUePerUlSf, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->cellModSchm, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isCpDlExtend, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isCpUlExtend, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxUlUeNewTxPerTti, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxDlUeNewTxPerTti, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxDlRetxBw, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxDlBwPerUe, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxUlBwPerUe, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxCcchPerDlSf, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxUePerDlSf, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxUePerUlSf, mBuf);
 #ifdef RGR_V1
    /* rgr_x_001.main_7: [ccpu00112789] Added configuration for maximum number
       of  MSG3s */
-   CMCHKPK(SPkU8, param->maxMsg3PerUlSf, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxMsg3PerUlSf, mBuf);
 #endif
-   CMCHKPK(SPkU8, param->macInst, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->macInst, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
 
 #ifdef EMTC_ENABLE 
 /* EMTC related changes start*/
-   CMCHKPK(SPkU8, param->emtcEnable, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->emtcEnable, mBuf);
    CMCHKPK(cmPkRgrEmtcCfg, &param->emtcCellCfg, mBuf);
 /* EMTC related changes ends*/
 #endif
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -4264,49 +3546,42 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCellCfg
+S16 cmUnpkRgrCellCfg
 (
 RgrCellCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrCellCfg(param, mBuf)
-RgrCellCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
 
-   TRC3(cmUnpkRgrCellCfg)
 #ifdef EMTC_ENABLE   	
 /* EMTC related changes start*/
    CMCHKUNPK(cmUnpkRgrEmtcCfg, &param->emtcCellCfg, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->emtcEnable, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->emtcEnable, mBuf);
 /* EMTC related changes ends*/
 #endif
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->macInst, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->macInst, mBuf);
 #ifdef RGR_V1
    /* rgr_x_001.main_7: [ccpu00112789] Added configuration for maximum number
       of  MSG3s */
-   CMCHKUNPK(SUnpkU8, &param->maxMsg3PerUlSf, mBuf);
-#endif
-   CMCHKUNPK(SUnpkU8, &param->maxUePerUlSf, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->maxUePerDlSf, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->maxCcchPerDlSf, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->maxUlBwPerUe, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->maxDlBwPerUe, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->maxDlRetxBw, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->maxDlUeNewTxPerTti, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->maxUlUeNewTxPerTti, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isCpUlExtend, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isCpDlExtend, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->cellModSchm, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxMsg3PerUlSf, mBuf);
+#endif
+   CMCHKUNPK(oduPackUInt8, &param->maxUePerUlSf, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxUePerDlSf, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxCcchPerDlSf, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxUlBwPerUe, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxDlBwPerUe, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxDlRetxBw, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxDlUeNewTxPerTti, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxUlUeNewTxPerTti, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isCpUlExtend, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isCpDlExtend, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cellModSchm, mBuf);
    CMCHKUNPK(SUnpkS8, &param->pMax, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->dlfsSchdType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->dlfsSchdType, mBuf);
    CMCHKUNPK(cmUnpkRgrDlHqCfg, &param->dlHqCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrRntiCfg, &param->macRnti, mBuf);
    CMCHKUNPK(cmUnpkRgrCfiCfg, &param->cfiCfg, mBuf);
@@ -4327,40 +3602,40 @@ Buffer *mBuf;
    CMCHKUNPK(cmUnpkRgrUlPwrCfg, &param->pwrCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrPuschCfg, &param->puschCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrPreambleSetCfg, &param->macPreambleSet, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numCmnLcs, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numCmnLcs, mBuf);
    for (i=0; i<param->numCmnLcs; i++) {
       CMCHKUNPK(cmUnpkRgrCmnLchCfg, &param->cmnLcCfg[i], mBuf);
    }
    CMCHKUNPK(cmUnpkRgrCellCsgParamCfg, &param->csgParamCfg, mBuf);
 
 #ifdef LTE_TDD
-   CMCHKUNPK(SUnpkU8, &param->ulDlCfgIdx, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->spclSfCfgIdx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ulDlCfgIdx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->spclSfCfgIdx, mBuf);
    CMCHKUNPK(cmUnpkRgrTddPrachRscInfo, &param->prachRscInfo, mBuf);
 
 #endif
 /* rgr_c_001.main_3: Added TTI indication from MAC to RGR user */
-   CMCHKUNPK(SUnpkU8, &param->rrmTtiIndPrd, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->rrmTtiIndPrd, mBuf);
    /*rgr_c_001.main_7 - Added support for SPS*/
    CMCHKUNPK(cmUnpkRgrSpsDlCellCfg, &param->spsCfg, mBuf);
 
-   CMCHKUNPK(SUnpkU16, &param->t300TmrVal, mBuf);
-   CMCHKPK(SUnpkU16, &param->bcchTxPwrOffset, mBuf);
-   CMCHKPK(SUnpkU16, &param->pcchTxPwrOffset, mBuf);
-   CMCHKPK(SUnpkU16, &param->rarTxPwrOffset, mBuf);
-   CMCHKPK(SUnpkU16, &param->phichTxPwrOffset, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isDynCfiEnb, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isAutoCfgModeEnb, mBuf);
-   CMCHKPK(SUnpkU32, (U32*)&param->msg4pAVal, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->t300TmrVal, mBuf);
+   CMCHKPK(oduPackUInt16, &param->bcchTxPwrOffset, mBuf);
+   CMCHKPK(oduPackUInt16, &param->pcchTxPwrOffset, mBuf);
+   CMCHKPK(oduPackUInt16, &param->rarTxPwrOffset, mBuf);
+   CMCHKPK(oduPackUInt16, &param->phichTxPwrOffset, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isDynCfiEnb, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isAutoCfgModeEnb, mBuf);
+   CMCHKPK(oduPackUInt32, (uint32_t*)&param->msg4pAVal, mBuf);
    /*LAA: Unpack LAA Cell params*/
    CMCHKUNPK(cmUnpkRgrLteUCellCfg, &param->lteUCfg, mBuf);
    #ifdef LTE_ADV
-   CMCHKUNPK(SUnpkU8, &param->isPucchFormat3Sptd, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isPucchFormat3Sptd, mBuf);
 #endif
 #ifdef RG_5GTF
    CMCHKUNPK(cmUnPkRgr5gtfCellCfg, &param->Cell5gtfCfg, mBuf);
 #endif
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -4380,29 +3655,22 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeAprdDlCqiCfg
+S16 cmPkRgrUeAprdDlCqiCfg
 (
 RgrUeAprdDlCqiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeAprdDlCqiCfg(param, mBuf)
-RgrUeAprdDlCqiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeAprdDlCqiCfg)
    /*Pack Aperiodic Trigger List only for Pcell */
 #ifdef LTE_ADV
-   CMCHKPK(SPkU8, param->triggerSet2, mBuf);
-   CMCHKPK(SPkU8, param->triggerSet1, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->triggerSet2, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->triggerSet1, mBuf);
 #endif
 
-   CMCHKPK(SPkU32, param->aprdModeEnum, mBuf);
-   CMCHKPK(SPkU8, param->pres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt32, param->aprdModeEnum, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+   return ROK;
 }
 
 
@@ -4422,32 +3690,25 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeAprdDlCqiCfg
+S16 cmUnpkRgrUeAprdDlCqiCfg
 (
 RgrUeAprdDlCqiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeAprdDlCqiCfg(param, mBuf)
-RgrUeAprdDlCqiCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrUeAprdDlCqiCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->aprdModeEnum = (RgrAprdCqiMode) tmpEnum;
 
 #ifdef LTE_ADV
-   CMCHKUNPK(SUnpkU8, &param->triggerSet1, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->triggerSet2, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->triggerSet1, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->triggerSet2, mBuf);
 #endif
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -4470,29 +3731,22 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUePrdDlCqiCfg
+S16 cmPkRgrUePrdDlCqiCfg
 (
 RgrUePrdDlCqiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUePrdDlCqiCfg(param, mBuf)
-RgrUePrdDlCqiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUePrdDlCqiCfg)
 
-   CMCHKPK(SPkU16, param->cqiPmiCfgIdx, mBuf);
-   CMCHKPK(SPkU8, param->k, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->cqiPmiCfgIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->k, mBuf);
    CMCHKPK(SPkS8, param->cqiOffst, mBuf);
-   CMCHKPK(SPkU8, param->subframeOffst, mBuf);
-   CMCHKPK(SPkU32, param->prdicityEnum, mBuf);
-   CMCHKPK(SPkU32, param->prdModeEnum, mBuf);
-   CMCHKPK(SPkU8, param->pres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->subframeOffst, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->prdicityEnum, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->prdModeEnum, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+   return ROK;
 }
 
 
@@ -4512,32 +3766,25 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUePrdDlCqiCfg
+S16 cmUnpkRgrUePrdDlCqiCfg
 (
 RgrUePrdDlCqiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUePrdDlCqiCfg(param, mBuf)
-RgrUePrdDlCqiCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrUePrdDlCqiCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->prdModeEnum = tmpEnum;
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->prdicityEnum = tmpEnum;
-   CMCHKUNPK(SUnpkU8, &param->subframeOffst, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->subframeOffst, mBuf);
    CMCHKUNPK(SUnpkS8, &param->cqiOffst, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->k, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->cqiPmiCfgIdx, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->k, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->cqiPmiCfgIdx, mBuf);
+   return ROK;
 }
 
 
@@ -4560,31 +3807,24 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeDlPCqiSetup
+S16 cmPkRgrUeDlPCqiSetup
 (
 RgrUeDlPCqiSetup *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeDlPCqiSetup(param, mBuf)
-RgrUeDlPCqiSetup *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeDlPCqiSetup)
 
-   CMCHKPK(SPkU32, param->prdModeEnum, mBuf);
-   CMCHKPK(SPkU8, param->sANCQI, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->prdModeEnum, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->sANCQI, mBuf);
    /*rgr_c_001.main_9 DEL removed unwanted comments*/
-   CMCHKPK(SPkU16, param->riCfgIdx, mBuf);
-   CMCHKPK(SPkU8, param->riEna, mBuf);
-   CMCHKPK(SPkU8, param->k, mBuf);
-   CMCHKPK(SPkU8, param->cqiRepType, mBuf);
-   CMCHKPK(SPkU16, param->cqiPCfgIdx, mBuf);
-   CMCHKPK(SPkU16, param->cqiPResIdx, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt16, param->riCfgIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->riEna, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->k, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->cqiRepType, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->cqiPCfgIdx, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->cqiPResIdx, mBuf);
+   return ROK;
 }
 
 
@@ -4604,33 +3844,26 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeDlPCqiSetup
+S16 cmUnpkRgrUeDlPCqiSetup
 (
 RgrUeDlPCqiSetup *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeDlPCqiSetup(param, mBuf)
-RgrUeDlPCqiSetup *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrUeDlPCqiSetup)
 
-   CMCHKUNPK(SUnpkU16, &param->cqiPResIdx, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->cqiPCfgIdx, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->cqiRepType, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->k, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->riEna, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->cqiPResIdx, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->cqiPCfgIdx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cqiRepType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->k, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->riEna, mBuf);
    /*rgr_c_001.main_9 DEL removed unwanted comments*/
-   CMCHKUNPK(SUnpkU16, &param->riCfgIdx, mBuf); 
-   CMCHKUNPK(SUnpkU8, &param->sANCQI, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->riCfgIdx, mBuf); 
+   CMCHKUNPK(oduPackUInt8, &param->sANCQI, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->prdModeEnum = (RgrPrdCqiMode) tmpEnum;
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -4650,24 +3883,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUePrdDlCqiCfg
+S16 cmPkRgrUePrdDlCqiCfg
 (
 RgrUePrdDlCqiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUePrdDlCqiCfg(param, mBuf)
-RgrUePrdDlCqiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUePrdDlCqiCfg)
 
    CMCHKPK(cmPkRgrUeDlPCqiSetup, &param->cqiSetup, mBuf);
-   CMCHKPK(SPkU8, param->type, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->type, mBuf);
+   return ROK;
 }
 
 
@@ -4687,24 +3913,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUePrdDlCqiCfg
+S16 cmUnpkRgrUePrdDlCqiCfg
 (
 RgrUePrdDlCqiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUePrdDlCqiCfg(param, mBuf)
-RgrUePrdDlCqiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUePrdDlCqiCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->type, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->type, mBuf);
    CMCHKUNPK(cmUnpkRgrUeDlPCqiSetup, &param->cqiSetup, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -4725,31 +3944,24 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeUlSrsSetupCfg
+S16 cmPkRgrUeUlSrsSetupCfg
 (
 RgrUeUlSrsSetupCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeUlSrsSetupCfg(param, mBuf)
-RgrUeUlSrsSetupCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeUlSrsSetupCfg)
 
-   CMCHKPK(SPkU8, param->fDomPosi, mBuf);
-   CMCHKPK(SPkU8, param->txComb, mBuf);
-   CMCHKPK(SPkU8, param->sANSrs, mBuf);
-   CMCHKPK(SPkU8, param->duration, mBuf);
-   CMCHKPK(SPkU32, param->cycShift, mBuf);
-   CMCHKPK(SPkU32, param->srsHopBw, mBuf);
-   CMCHKPK(SPkU32, param->srsBw, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->fDomPosi, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->txComb, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->sANSrs, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->duration, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->cycShift, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->srsHopBw, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->srsBw, mBuf);
    /*rgr_c_001.main_9 DEL removed unwanted comments*/
-   CMCHKPK(SPkU16, param->srsCfgIdx, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt16, param->srsCfgIdx, mBuf);
+   return ROK;
 }
 
 
@@ -4770,35 +3982,28 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeUlSrsSetupCfg
+S16 cmUnpkRgrUeUlSrsSetupCfg
 (
 RgrUeUlSrsSetupCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeUlSrsSetupCfg(param, mBuf)
-RgrUeUlSrsSetupCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrUeUlSrsSetupCfg)
 
    /*rgr_c_001.main_9 DEL removed unwanted comments*/
-   CMCHKUNPK(SUnpkU16, &param->srsCfgIdx, mBuf); 
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->srsCfgIdx, mBuf); 
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->srsBw = (RgrUlSrsBwInfo) tmpEnum;
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->srsHopBw = (RgrUlSrsHoBwInfo) tmpEnum;
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->cycShift = (RgrUlSrsCycShiftInfo) tmpEnum;
-   CMCHKUNPK(SUnpkU8, &param->duration, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->sANSrs, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->txComb, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->fDomPosi, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->duration, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->sANSrs, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->txComb, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->fDomPosi, mBuf);
+   return ROK;
 }
 
 
@@ -4818,26 +4023,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSrSetupCfg
+S16 cmPkRgrUeSrSetupCfg
 (
 RgrUeSrSetupCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeSrSetupCfg(param, mBuf)
-RgrUeSrSetupCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeSrSetupCfg)
 
    /* ccpu00131601:DEL - dTMax Packing removed since this param will not 
     * be required by Scheduler*/
-   CMCHKPK(SPkU8, param->srCfgIdx, mBuf);
-   CMCHKPK(SPkU16, param->srResIdx, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->srCfgIdx, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->srResIdx, mBuf);
+   return ROK;
 }
 
 
@@ -4857,25 +4055,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSrSetupCfg
+S16 cmUnpkRgrUeSrSetupCfg
 (
 RgrUeSrSetupCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeSrSetupCfg(param, mBuf)
-RgrUeSrSetupCfg *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmUnpkRgrUeSrSetupCfg)
 
-   CMCHKUNPK(SUnpkU16, &param->srResIdx, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->srCfgIdx, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->srResIdx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->srCfgIdx, mBuf);
    /* ccpu00131601:DEL - dTMax UnPacking removed since this param will not 
     * be required by Scheduler*/
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -4895,24 +4086,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSrCfg
+S16 cmPkRgrUeSrCfg
 (
 RgrUeSrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeSrCfg(param, mBuf)
-RgrUeSrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeSrCfg)
 
    CMCHKPK(cmPkRgrUeSrSetupCfg, &param->srSetup, mBuf);
-   CMCHKPK(SPkU8, param->type, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->type, mBuf);
+   return ROK;
 }
 
 
@@ -4932,24 +4116,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSrCfg
+S16 cmUnpkRgrUeSrCfg
 (
 RgrUeSrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeSrCfg(param, mBuf)
-RgrUeSrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeSrCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->type, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->type, mBuf);
    CMCHKUNPK(cmUnpkRgrUeSrSetupCfg, &param->srSetup, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -4970,25 +4147,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeUlSrsCfg
+S16 cmPkRgrUeUlSrsCfg
 (
 RgrUeUlSrsCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeUlSrsCfg(param, mBuf)
-RgrUeUlSrsCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeUlSrsCfg)
 
    /*rgr_c_001.main_9 DEL removed unwanted comments*/
    CMCHKPK(cmPkRgrUeUlSrsSetupCfg, &param->srsSetup, mBuf);  
-   CMCHKPK(SPkU8, param->type, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->type, mBuf);
+   return ROK;
 }
 
 
@@ -5009,25 +4179,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeUlSrsCfg
+S16 cmUnpkRgrUeUlSrsCfg
 (
 RgrUeUlSrsCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeUlSrsCfg(param, mBuf)
-RgrUeUlSrsCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeUlSrsCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->type, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->type, mBuf);
    /*rgr_c_001.main_9 DEL removed unwanted comments*/
    CMCHKUNPK(cmUnpkRgrUeUlSrsSetupCfg, &param->srsSetup, mBuf);  
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -5049,20 +4212,13 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeDlCqiCfg
+S16 cmPkRgrUeDlCqiCfg
 (
 RgrUeDlCqiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeDlCqiCfg(param, mBuf)
-RgrUeDlCqiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeDlCqiCfg)
 
 
 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
@@ -5075,7 +4231,7 @@ Buffer *mBuf;
    CMCHKPK(cmPkRgrUePrdDlCqiCfg, &param->prdCqiCfg, mBuf);
 #endif
    CMCHKPK(cmPkRgrUeAprdDlCqiCfg, &param->aprdCqiCfg, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -5095,24 +4251,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeDlCqiCfg
+S16 cmUnpkRgrUeDlCqiCfg
 (
 RgrUeDlCqiCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeDlCqiCfg(param, mBuf)
-RgrUeDlCqiCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeDlCqiCfg)
 
    CMCHKUNPK(cmUnpkRgrUeAprdDlCqiCfg, &param->aprdCqiCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrUePrdDlCqiCfg, &param->prdCqiCfg, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -5132,25 +4281,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeMeasGapCfg
+S16 cmPkRgrUeMeasGapCfg
 (
 RgrUeMeasGapCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeMeasGapCfg(param, mBuf)
-RgrUeMeasGapCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeMeasGapCfg)
 
-   CMCHKPK(SPkU8, param->gapOffst, mBuf);
-   CMCHKPK(SPkU8, param->gapPrd, mBuf);
-   CMCHKPK(SPkU8, param->isMesGapEnabled, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->gapOffst, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->gapPrd, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isMesGapEnabled, mBuf);
+   return ROK;
 }
 
 
@@ -5170,25 +4312,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeMeasGapCfg
+S16 cmUnpkRgrUeMeasGapCfg
 (
 RgrUeMeasGapCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeMeasGapCfg(param, mBuf)
-RgrUeMeasGapCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeMeasGapCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->isMesGapEnabled, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->gapPrd, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->gapOffst, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->isMesGapEnabled, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->gapPrd, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->gapOffst, mBuf);
+   return ROK;
 }
 
 /*rgr_c_001.main_9 ADD DRX functionality under flag*/
@@ -5208,24 +4343,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrDrxLongCycleOffst
+S16 cmPkRgrDrxLongCycleOffst
 (
 RgrDrxLongCycleOffst *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrDrxLongCycleOffst(param, mBuf)
-RgrDrxLongCycleOffst *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrDrxLongCycleOffst)
 
-   CMCHKPK(SPkU16, param->drxStartOffst, mBuf);
-   CMCHKPK(SPkU16, param->longDrxCycle, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt16, param->drxStartOffst, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->longDrxCycle, mBuf);
+   return ROK;
 }
 
 
@@ -5245,24 +4373,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDrxLongCycleOffst
+S16 cmUnpkRgrDrxLongCycleOffst
 (
 RgrDrxLongCycleOffst *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrDrxLongCycleOffst(param, mBuf)
-RgrDrxLongCycleOffst *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrDrxLongCycleOffst)
 
-   CMCHKUNPK(SUnpkU16, &param->longDrxCycle, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->drxStartOffst, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt16, &param->longDrxCycle, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->drxStartOffst, mBuf);
+   return ROK;
 }
 
 
@@ -5282,25 +4403,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrDrxShortDrx
+S16 cmPkRgrDrxShortDrx
 (
 RgrDrxShortDrx *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrDrxShortDrx(param, mBuf)
-RgrDrxShortDrx *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrDrxShortDrx)
 
-   CMCHKPK(SPkU8, param->drxShortCycleTmr, mBuf);
-   CMCHKPK(SPkU16, param->shortDrxCycle, mBuf);
-   CMCHKPK(SPkU8, param->pres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->drxShortCycleTmr, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->shortDrxCycle, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+   return ROK;
 }
 
 
@@ -5320,25 +4434,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDrxShortDrx
+S16 cmUnpkRgrDrxShortDrx
 (
 RgrDrxShortDrx *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrDrxShortDrx(param, mBuf)
-RgrDrxShortDrx *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrDrxShortDrx)
 
-   CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->shortDrxCycle, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->drxShortCycleTmr, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->shortDrxCycle, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->drxShortCycleTmr, mBuf);
+   return ROK;
 }
 
 /***********************************************************
@@ -5356,37 +4463,30 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeDrxCfg
+S16 cmPkRgrUeDrxCfg
 (
 RgrUeDrxCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeDrxCfg(param, mBuf)
-RgrUeDrxCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeDrxCfg)
 
    CMCHKPK(cmPkRgrDrxShortDrx, &param->drxShortDrx, mBuf);
    CMCHKPK(cmPkRgrDrxLongCycleOffst, &param->drxLongCycleOffst, mBuf);
-   CMCHKPK(SPkU16, param->drxRetxTmr, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->drxRetxTmr, mBuf);
 #ifdef EMTC_ENABLE
-   CMCHKPK(SPkU8,  param->drxRetxTmrR13Pres, mBuf);
-   CMCHKPK(SPkU8,  param->drxOnDurTmrR13Pres, mBuf);
-   CMCHKPK(SPkU16, param->emtcDrxUlRetxTmr, mBuf);
-   CMCHKPK(SPkU8,  param->isEmtcUe, mBuf); 
+   CMCHKPK(oduUnpackUInt8,  param->drxRetxTmrR13Pres, mBuf);
+   CMCHKPK(oduUnpackUInt8,  param->drxOnDurTmrR13Pres, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->emtcDrxUlRetxTmr, mBuf);
+   CMCHKPK(oduUnpackUInt8,  param->isEmtcUe, mBuf); 
 #endif
-   CMCHKPK(SPkU16, param->drxInactvTmr, mBuf);
-   CMCHKPK(SPkU16, param->drxOnDurTmr, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->drxInactvTmr, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->drxOnDurTmr, mBuf);
 /*rgr_c_001.main_9 ADD added changes for R9*/
 #ifdef LTEMAC_R9
    CMCHKPK(cmPkTknS32, &param->cqiMask, mBuf);
 #endif
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -5406,37 +4506,30 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeDrxCfg
+S16 cmUnpkRgrUeDrxCfg
 (
 RgrUeDrxCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeDrxCfg(param, mBuf)
-RgrUeDrxCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeDrxCfg)
 
 /*rgr_c_001.main_9 ADD added changes for R9*/
 #ifdef LTEMAC_R9
    CMCHKUNPK(cmUnpkTknS32, &param->cqiMask, mBuf);
 #endif
-   CMCHKUNPK(SUnpkU16, &param->drxOnDurTmr, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->drxInactvTmr, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->drxOnDurTmr, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->drxInactvTmr, mBuf);
 #ifdef EMTC_ENABLE
-   CMCHKUNPK(SUnpkU8, &param->isEmtcUe, mBuf); 
-   CMCHKUNPK(SUnpkU16,&param->emtcDrxUlRetxTmr, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->drxOnDurTmrR13Pres, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->drxRetxTmrR13Pres, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isEmtcUe, mBuf); 
+   CMCHKUNPK(oduPackUInt16,&param->emtcDrxUlRetxTmr, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->drxOnDurTmrR13Pres, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->drxRetxTmrR13Pres, mBuf);
 #endif
-   CMCHKUNPK(SUnpkU16, &param->drxRetxTmr, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->drxRetxTmr, mBuf);
    CMCHKUNPK(cmUnpkRgrDrxLongCycleOffst, &param->drxLongCycleOffst, mBuf);
    CMCHKUNPK(cmUnpkRgrDrxShortDrx, &param->drxShortDrx, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /*rgr_c_001.main_9 ADD added DRX changes under DRX*/
@@ -5456,27 +4549,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeCapCfg
+S16 cmPkRgrUeCapCfg
 (
 RgrUeCapCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeCapCfg(param, mBuf)
-RgrUeCapCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeCapCfg)
 
-   CMCHKPK(SPkU8, param->txAntSel, mBuf);
-   CMCHKPK(SPkU8, param->simCqiAckNack, mBuf);
-   CMCHKPK(SPkU8, param->resAloocType1, mBuf);
-   CMCHKPK(SPkU8, param->intraSfFeqHop, mBuf);
-   CMCHKPK(SPkU8, param->pwrClass, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->txAntSel, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->simCqiAckNack, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->resAloocType1, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->intraSfFeqHop, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pwrClass, mBuf);
+   return ROK;
 }
 
 
@@ -5496,28 +4582,21 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeCapCfg
+S16 cmUnpkRgrUeCapCfg
 (
 RgrUeCapCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeCapCfg(param, mBuf)
-RgrUeCapCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeCapCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->pwrClass, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->intraSfFeqHop, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->resAloocType1, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->simCqiAckNack, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->txAntSel, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->pwrClass, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->intraSfFeqHop, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->resAloocType1, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->simCqiAckNack, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->txAntSel, mBuf);
    
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -5536,25 +4615,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeAckNackRepCfg
+S16 cmPkRgrUeAckNackRepCfg
 (
 RgrUeAckNackRepCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeAckNackRepCfg(param, mBuf)
-RgrUeAckNackRepCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeAckNackRepCfg)
 
-   CMCHKPK(SPkU32, param->ackNackRepFactor, mBuf);
-   CMCHKPK(SPkU16, param->pucchAckNackRep, mBuf);
-   CMCHKPK(SPkU8, param->isAckNackEnabled, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt32, param->ackNackRepFactor, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->pucchAckNackRep, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isAckNackEnabled, mBuf);
+   return ROK;
 }
 
 
@@ -5574,27 +4646,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeAckNackRepCfg
+S16 cmUnpkRgrUeAckNackRepCfg
 (
 RgrUeAckNackRepCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeAckNackRepCfg(param, mBuf)
-RgrUeAckNackRepCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrUeAckNackRepCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->isAckNackEnabled, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->pucchAckNackRep, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isAckNackEnabled, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->pucchAckNackRep, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->ackNackRepFactor = (RgrAckNackRepFactor) tmpEnum;
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -5614,26 +4679,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeTxModeCfg
+S16 cmPkRgrUeTxModeCfg
 (
 RgrUeTxModeCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeTxModeCfg(param, mBuf)
-RgrUeTxModeCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeTxModeCfg)
 
-   CMCHKPK(SPkU32, param->txModeEnum, mBuf);
-   CMCHKPK(SPkU32, param->tmTrnstnState, mBuf);
-   CMCHKPK(SPkU8, param->pres, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->txModeEnum, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->tmTrnstnState, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
    
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -5653,29 +4711,22 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeTxModeCfg
+S16 cmUnpkRgrUeTxModeCfg
 (
 RgrUeTxModeCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeTxModeCfg(param, mBuf)
-RgrUeTxModeCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrUeTxModeCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->tmTrnstnState = (RgrTxModeTrnstn) tmpEnum;
 
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->txModeEnum = (RgrTxMode) tmpEnum;
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -5695,24 +4746,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeUlHqCfg
+S16 cmPkRgrUeUlHqCfg
 (
 RgrUeUlHqCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeUlHqCfg(param, mBuf)
-RgrUeUlHqCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeUlHqCfg)
 
-   CMCHKPK(SPkU8, param->deltaHqOffst, mBuf);
-   CMCHKPK(SPkU8, param->maxUlHqTx, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->deltaHqOffst, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->maxUlHqTx, mBuf);
+   return ROK;
 }
 
 
@@ -5732,24 +4776,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeUlHqCfg
+S16 cmUnpkRgrUeUlHqCfg
 (
 RgrUeUlHqCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeUlHqCfg(param, mBuf)
-RgrUeUlHqCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeUlHqCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->maxUlHqTx, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->deltaHqOffst, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->maxUlHqTx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->deltaHqOffst, mBuf);
+   return ROK;
 }
 
 
@@ -5769,25 +4806,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeGrpPwrCfg
+S16 cmPkRgrUeGrpPwrCfg
 (
 RgrUeGrpPwrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeGrpPwrCfg(param, mBuf)
-RgrUeGrpPwrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeGrpPwrCfg)
 
-   CMCHKPK(SPkU8, param->idx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->idx, mBuf);
    CMCHKPK(cmPkLteRnti, param->tpcRnti, mBuf);
-   CMCHKPK(SPkU8, param->pres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+   return ROK;
 }
 
 
@@ -5807,25 +4837,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeGrpPwrCfg
+S16 cmUnpkRgrUeGrpPwrCfg
 (
 RgrUeGrpPwrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeGrpPwrCfg(param, mBuf)
-RgrUeGrpPwrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeGrpPwrCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->tpcRnti, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->idx, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->idx, mBuf);
+   return ROK;
 }
 
 /*rgr_c_001.main_7 - Added support for SPS*/
@@ -5846,30 +4869,23 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSpsDlCfg
+S16 cmPkRgrUeSpsDlCfg
 (
 RgrUeSpsDlCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeSpsDlCfg(param, mBuf)
-RgrUeSpsDlCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmPkRgrUeSpsDlCfg)
-   CMCHKPK(SPkU16, param->explicitRelCnt, mBuf);
-   CMCHKPK(SPkU32, param->dlSpsPrdctyEnum, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->explicitRelCnt, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->dlSpsPrdctyEnum, mBuf);
    for (i=param->numPucchVal-1; i >= 0; i--) {
-      CMCHKPK(SPkU32, param->n1PucchVal[i], mBuf);
+      CMCHKPK(oduUnpackUInt32, param->n1PucchVal[i], mBuf);
    }
-   CMCHKPK(SPkU8, param->numPucchVal, mBuf);
-   CMCHKPK(SPkU8, param->numSpsHqProc, mBuf);
-   CMCHKPK(SPkU8, param->isDlSpsEnabled, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->numPucchVal, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numSpsHqProc, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isDlSpsEnabled, mBuf);
+   return ROK;
 }
 
 
@@ -5889,33 +4905,26 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSpsDlCfg
+S16 cmUnpkRgrUeSpsDlCfg
 (
 RgrUeSpsDlCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeSpsDlCfg(param, mBuf)
-RgrUeSpsDlCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
    S32 i;
-   TRC3(cmUnpkRgrUeSpsDlCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->isDlSpsEnabled, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numSpsHqProc, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numPucchVal, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isDlSpsEnabled, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numSpsHqProc, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numPucchVal, mBuf);
    for (i=0; i<param->numPucchVal; i++) {
-      CMCHKUNPK(SUnpkU32, &param->n1PucchVal[i], mBuf);
+      CMCHKUNPK(oduPackUInt32, &param->n1PucchVal[i], mBuf);
    }
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->dlSpsPrdctyEnum = tmpEnum;
-   CMCHKUNPK(SUnpkU16, &param->explicitRelCnt, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt16, &param->explicitRelCnt, mBuf);
+   return ROK;
 }
 
 
@@ -5935,42 +4944,35 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSpsUlCfg
+S16 cmPkRgrUeSpsUlCfg
 (
 RgrUeSpsUlCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeSpsUlCfg(param, mBuf)
-RgrUeSpsUlCfg *param;
-Buffer *mBuf;
-#endif
 {
 
    S32 i;
-   TRC3(cmPkRgrUeSpsUlCfg)
 
-   CMCHKPK(SPkU8, param->isLcSRMaskEnab, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isLcSRMaskEnab, mBuf);
    for (i=param->lcCnt-1; i >= 0; i--) {
       /* SPS Changes starts */
-      CMCHKPK(SPkU8, param->spsLcInfo[i].isSpsEnabled, mBuf);
-      CMCHKPK(SPkU8, param->spsLcInfo[i].lcId, mBuf);
+      CMCHKPK(oduUnpackUInt8, param->spsLcInfo[i].isSpsEnabled, mBuf);
+      CMCHKPK(oduUnpackUInt8, param->spsLcInfo[i].lcId, mBuf);
       /* SPS Changes ends */
    }
-   CMCHKPK(SPkU8, param->lcCnt, mBuf);
-   CMCHKPK(SPkU32, param->ulSpsPrdctyEnum, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->lcCnt, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->ulSpsPrdctyEnum, mBuf);
       CMCHKPK(SPkS8, param->pwrCfg.p0UePuschVal, mBuf);
       CMCHKPK(SPkS8, param->pwrCfg.p0NominalPuschVal, mBuf);
-   CMCHKPK(SPkU8, param->pwrCfgPres, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pwrCfgPres, mBuf);
 
 #ifdef LTE_TDD
-   CMCHKPK(SPkU8, param->twoIntervalCfg, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->twoIntervalCfg, mBuf);
 
 #endif
-   CMCHKPK(SPkU32, param->implicitRelCnt, mBuf);
-   CMCHKPK(SPkU8, param->isUlSpsEnabled, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt32, param->implicitRelCnt, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isUlSpsEnabled, mBuf);
+   return ROK;
 }
 
 
@@ -5990,43 +4992,36 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSpsUlCfg
+S16 cmUnpkRgrUeSpsUlCfg
 (
 RgrUeSpsUlCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeSpsUlCfg(param, mBuf)
-RgrUeSpsUlCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
    S32 i;
-   TRC3(cmUnpkRgrUeSpsUlCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->isUlSpsEnabled, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isUlSpsEnabled, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->implicitRelCnt = tmpEnum;
 
 #ifdef LTE_TDD
-   CMCHKUNPK(SUnpkU8, &param->twoIntervalCfg, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->twoIntervalCfg, mBuf);
 
 #endif
-   CMCHKUNPK(SUnpkU8, &param->pwrCfgPres, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->pwrCfgPres, mBuf);
       CMCHKUNPK(SUnpkS8, &param->pwrCfg.p0NominalPuschVal, mBuf);
       CMCHKUNPK(SUnpkS8, &param->pwrCfg.p0UePuschVal, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->ulSpsPrdctyEnum = tmpEnum;
-   CMCHKUNPK(SUnpkU8, &param->lcCnt, mBuf); 
+   CMCHKUNPK(oduPackUInt8, &param->lcCnt, mBuf); 
    for (i=0; i<param->lcCnt; i++) {
-      CMCHKUNPK(SUnpkU8, &param->spsLcInfo[i].lcId, mBuf);
-      CMCHKUNPK(SUnpkU8, &param->spsLcInfo[i].isSpsEnabled, mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->spsLcInfo[i].lcId, mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->spsLcInfo[i].isSpsEnabled, mBuf);
    }
-   CMCHKUNPK(SUnpkU8, &param->isLcSRMaskEnab, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->isLcSRMaskEnab, mBuf);
+   return ROK;
 }
 
 
@@ -6046,25 +5041,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSpsCfg
+S16 cmPkRgrUeSpsCfg
 (
 RgrUeSpsCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeSpsCfg(param, mBuf)
-RgrUeSpsCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeSpsCfg)
 
    CMCHKPK(cmPkRgrUeSpsUlCfg, &param->ulSpsCfg, mBuf);
    CMCHKPK(cmPkRgrUeSpsDlCfg, &param->dlSpsCfg, mBuf);
    CMCHKPK(cmPkLteRnti, param->spsRnti, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -6084,25 +5072,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSpsCfg
+S16 cmUnpkRgrUeSpsCfg
 (
 RgrUeSpsCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeSpsCfg(param, mBuf)
-RgrUeSpsCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeSpsCfg)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->spsRnti, mBuf);
    CMCHKUNPK(cmUnpkRgrUeSpsDlCfg, &param->dlSpsCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrUeSpsUlCfg, &param->ulSpsCfg, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -6121,30 +5102,23 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeUlPwrCfg
+S16 cmPkRgrUeUlPwrCfg
 (
 RgrUeUlPwrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeUlPwrCfg(param, mBuf)
-RgrUeUlPwrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeUlPwrCfg)
 
-   CMCHKPK(SPkU8, param->trgCqi, mBuf);
-   CMCHKPK(SPkU8, param->pSRSOffset, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->trgCqi, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pSRSOffset, mBuf);
    CMCHKPK(SPkS8, param->p0UePucch, mBuf);
    CMCHKPK(SPkS8, param->p0UePusch, mBuf);
-   CMCHKPK(SPkU8, param->isDeltaMCSEnabled, mBuf);
-   CMCHKPK(SPkU8, param->isAccumulated, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isDeltaMCSEnabled, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isAccumulated, mBuf);
    CMCHKPK(cmPkRgrUeGrpPwrCfg, &param->uePucchPwr, mBuf);
    CMCHKPK(cmPkRgrUeGrpPwrCfg, &param->uePuschPwr, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -6164,30 +5138,23 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeUlPwrCfg
+S16 cmUnpkRgrUeUlPwrCfg
 (
 RgrUeUlPwrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeUlPwrCfg(param, mBuf)
-RgrUeUlPwrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeUlPwrCfg)
 
    CMCHKUNPK(cmUnpkRgrUeGrpPwrCfg, &param->uePuschPwr, mBuf);
    CMCHKUNPK(cmUnpkRgrUeGrpPwrCfg, &param->uePucchPwr, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isAccumulated, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isDeltaMCSEnabled, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isAccumulated, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isDeltaMCSEnabled, mBuf);
    CMCHKUNPK(SUnpkS8, &param->p0UePusch, mBuf);
    CMCHKUNPK(SUnpkS8, &param->p0UePucch, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->pSRSOffset, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->trgCqi, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->pSRSOffset, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->trgCqi, mBuf);
+   return ROK;
 }
 
 
@@ -6207,25 +5174,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeQosCfg
+S16 cmPkRgrUeQosCfg
 (
 RgrUeQosCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeQosCfg(param, mBuf)
-RgrUeQosCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeQosCfg)
 
-   CMCHKPK(SPkU32, param->ueBr, mBuf);
-   CMCHKPK(SPkU32, param->dlAmbr, mBuf);
-   CMCHKPK(SPkU8, param->ambrPres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt32, param->ueBr, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->dlAmbr, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->ambrPres, mBuf);
+   return ROK;
 }
 
 
@@ -6245,25 +5205,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeQosCfg
+S16 cmUnpkRgrUeQosCfg
 (
 RgrUeQosCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeQosCfg(param, mBuf)
-RgrUeQosCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeQosCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->ambrPres, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->dlAmbr, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->ueBr, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->ambrPres, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->dlAmbr, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->ueBr, mBuf);
+   return ROK;
 }
 
 /*********************************************************** 
@@ -6281,26 +5234,19 @@ Buffer *mBuf;
 *     File  :  
 * 
 **********************************************************/ 
-#ifdef ANSI 
-PUBLIC S16 cmPkRgrUePuschDedCfg 
+S16 cmPkRgrUePuschDedCfg 
 ( 
 RgrUePuschDedCfg *param, 
 Buffer *mBuf 
 ) 
-#else 
-PUBLIC S16 cmPkRgrUePuschDedCfg(param, mBuf) 
-RgrUePuschDedCfg *param; 
-Buffer *mBuf; 
-#endif 
 { 
  
-   TRC3(cmPkRgrUePuschDedCfg) 
  
-   CMCHKPK(SPkU8, param->bCQIIdx, mBuf);
-   CMCHKPK(SPkU8, param->bRIIdx, mBuf);
-   CMCHKPK(SPkU8, param->bACKIdx, mBuf);
-   CMCHKPK(SPkU8, param->pres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->bCQIIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->bRIIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->bACKIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+   return ROK;
 }
 
 
@@ -6320,26 +5266,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUePuschDedCfg
+S16 cmUnpkRgrUePuschDedCfg
 (
 RgrUePuschDedCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUePuschDedCfg(param, mBuf)
-RgrUePuschDedCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUePuschDedCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->bACKIdx, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->bRIIdx, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->bCQIIdx, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->bACKIdx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->bRIIdx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->bCQIIdx, mBuf);
+   return ROK;
 }
 
 /***********************************************************
@@ -6357,24 +5296,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeTxAntSelCfg
+S16 cmPkRgrUeTxAntSelCfg
 (
 RgrUeTxAntSelCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeTxAntSelCfg(param, mBuf)
-RgrUeTxAntSelCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeTxAntSelCfg)
 
-   CMCHKPK(SPkU32, param->selType, mBuf);
-   CMCHKPK(SPkU8, param->pres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt32, param->selType, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+   return ROK;
 }
 
 
@@ -6394,26 +5326,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeTxAntSelCfg
+S16 cmUnpkRgrUeTxAntSelCfg
 (
 RgrUeTxAntSelCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeTxAntSelCfg(param, mBuf)
-RgrUeTxAntSelCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrUeTxAntSelCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->selType = (RgrUeTxAntSelType) tmpEnum;
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -6432,24 +5357,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeTaTmrCfg
+S16 cmPkRgrUeTaTmrCfg
 (
 RgrUeTaTmrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeTaTmrCfg(param, mBuf)
-RgrUeTaTmrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeTaTmrCfg)
 
-   CMCHKPK(SPkU16, param->taTmr, mBuf);
-   CMCHKPK(SPkU8, param->pres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt16, param->taTmr, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+   return ROK;
 }
 
 
@@ -6469,39 +5387,26 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeTaTmrCfg
+S16 cmUnpkRgrUeTaTmrCfg
 (
 RgrUeTaTmrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeTaTmrCfg(param, mBuf)
-RgrUeTaTmrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeTaTmrCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->taTmr, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->taTmr, mBuf);
+   return ROK;
 }
 
 
 #ifdef EMTC_ENABLE
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcUeCfg
+S16 cmUnpkRgrEmtcUeCfg
 (
 RgrUeEmtcCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrEmtcUeCfg(param, mBuf)
-RgrUeEmtcCfg *param;
-Buffer *mBuf;
-#endif
 {
    S32 indx=0;
    S32 idx=0;
@@ -6509,45 +5414,45 @@ Buffer *mBuf;
    RgrPucchRepCfgRel13 *emtcPucchRepCfg = &(param->emtcPucchRepCfg);
    RgrEpdcchAddModLst *epdcchAddModLst;
 
-   CMCHKUNPK(SUnpkU8,&param->pdschReptLevModeA,mBuf);
+   CMCHKUNPK(oduPackUInt8,&param->pdschReptLevModeA,mBuf);
    /*UnPacking PUCCH Rep */
-   CMCHKUNPK(SUnpkU8,&(emtcPucchRepCfg->modeANumPucchRepFormat2),mBuf);
-   CMCHKUNPK(SUnpkU8,&(emtcPucchRepCfg->modeANumPucchRepFormat1),mBuf);
-   CMCHKUNPK(SUnpkU8,&(emtcPucchRepCfg->isPucchRepPres),mBuf);
+   CMCHKUNPK(oduPackUInt8,&(emtcPucchRepCfg->modeANumPucchRepFormat2),mBuf);
+   CMCHKUNPK(oduPackUInt8,&(emtcPucchRepCfg->modeANumPucchRepFormat1),mBuf);
+   CMCHKUNPK(oduPackUInt8,&(emtcPucchRepCfg->isPucchRepPres),mBuf);
    
    
    
    for(indx = 0; indx < RGR_MAX_EPDCCH_SET; indx++)
    {
       epdcchAddModLst =  &(emtcEpdcchCfg->epdcchAddModLst[indx]);
-      CMCHKUNPK(SUnpkU32,&(epdcchAddModLst->extaddgrp2.mpddchNB),mBuf);
-      CMCHKUNPK(SUnpkU16,&(epdcchAddModLst->extaddgrp2.mpdcchNumRep),mBuf);
-      CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD),mBuf);
-      CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->extaddgrp2.mpddchPdschHop),mBuf);
-      CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->extaddgrp2.csiNumRep),mBuf);
-      CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->extaddgrp2.pres),mBuf);
-      CMCHKUNPK(cmUnpkTknU8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
-      CMCHKUNPK(cmUnpkTknU32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
-      CMCHKUNPK(SUnpkU32,&(epdcchAddModLst->pucchResStartoffset),mBuf);
-      CMCHKUNPK(SUnpkU32,&(epdcchAddModLst->dmrsScrambSeq),mBuf);
+      CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->extaddgrp2.mpddchNB),mBuf);
+      CMCHKUNPK(oduPackUInt16,&(epdcchAddModLst->extaddgrp2.mpdcchNumRep),mBuf);
+      CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD),mBuf);
+      CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.mpddchPdschHop),mBuf);
+      CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.csiNumRep),mBuf);
+      CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.pres),mBuf);
+      CMCHKUNPK(cmUnpkTknUInt8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
+      CMCHKUNPK(cmUnpkTknUInt32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
+      CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->pucchResStartoffset),mBuf);
+      CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->dmrsScrambSeq),mBuf);
       for(idx = 0; idx < 5; idx++)
       {
-         CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->resBlkAssignment.rbAssignment[idx]),mBuf);
+         CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->resBlkAssignment.rbAssignment[idx]),mBuf);
       }
 
-      CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->resBlkAssignment.numPRBpairs),mBuf);
-      CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->transmissionType),mBuf);
-      CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->setConfigId),mBuf);
+      CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->resBlkAssignment.numPRBpairs),mBuf);
+      CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->transmissionType),mBuf);
+      CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->setConfigId),mBuf);
 
    }
-   CMCHKUNPK(cmUnpkTknU32,&(emtcEpdcchCfg->startSymbolr11),mBuf);
+   CMCHKUNPK(cmUnpkTknUInt32,&(emtcEpdcchCfg->startSymbolr11),mBuf);
    for(indx = 0; indx < 5; indx++)
    {
-      CMCHKUNPK(SUnpkU8,&(emtcEpdcchCfg->sfPtn.measSfPatFDD[indx]),mBuf);
+      CMCHKUNPK(oduPackUInt8,&(emtcEpdcchCfg->sfPtn.measSfPatFDD[indx]),mBuf);
    }
-   CMCHKUNPK(SUnpkU8, &(emtcEpdcchCfg->sfPtn.pres), mBuf);
-   CMCHKUNPK(SUnpkU8, &(param->pres), mBuf);
-   CMCHKUNPK(SUnpkU8, &(param->isHdFddEnbld), mBuf);
+   CMCHKUNPK(oduPackUInt8, &(emtcEpdcchCfg->sfPtn.pres), mBuf);
+   CMCHKUNPK(oduPackUInt8, &(param->pres), mBuf);
+   CMCHKUNPK(oduPackUInt8, &(param->isHdFddEnbld), mBuf);
 
 #ifdef EMTC_DEBUG_CONSOLE_PRINTS 
    printf("\n EMTC RGR UE unpack\n");
@@ -6588,12 +5493,12 @@ Buffer *mBuf;
 
 #endif
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
 
-PUBLIC S16 cmPkRgrEmtcUeCfg
+S16 cmPkRgrEmtcUeCfg
 (
  RgrUeEmtcCfg *param,
  Buffer *mBuf
@@ -6605,42 +5510,42 @@ PUBLIC S16 cmPkRgrEmtcUeCfg
    RgrPucchRepCfgRel13 *emtcPucchRepCfg = &(param->emtcPucchRepCfg);
    RgrEpdcchAddModLst *epdcchAddModLst;
 
-   CMCHKPK(SPkU8, param->isHdFddEnbld, mBuf);
-   CMCHKPK(SPkU8, param->pres, mBuf);
-   CMCHKPK(SPkU8, emtcEpdcchCfg->sfPtn.pres, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isHdFddEnbld, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+   CMCHKPK(oduUnpackUInt8, emtcEpdcchCfg->sfPtn.pres, mBuf);
    for(indx = 4; indx >=0; indx--)
    {
-      CMCHKPK(SPkU8,emtcEpdcchCfg->sfPtn.measSfPatFDD[indx],mBuf);
+      CMCHKPK(oduUnpackUInt8,emtcEpdcchCfg->sfPtn.measSfPatFDD[indx],mBuf);
    }
-   CMCHKPK(cmPkTknU32,&emtcEpdcchCfg->startSymbolr11,mBuf);
+   CMCHKPK(cmPkTknUInt32,&emtcEpdcchCfg->startSymbolr11,mBuf);
    for(indx = RGR_MAX_EPDCCH_SET-1 ; indx >= 0; indx--)
    {
       epdcchAddModLst =  &(emtcEpdcchCfg->epdcchAddModLst[indx]);
 
-      CMCHKPK(SPkU8,epdcchAddModLst->setConfigId,mBuf);
-      CMCHKPK(SPkU8,epdcchAddModLst->transmissionType,mBuf);
-      CMCHKPK(SPkU8,epdcchAddModLst->resBlkAssignment.numPRBpairs,mBuf);
+      CMCHKPK(oduUnpackUInt8,epdcchAddModLst->setConfigId,mBuf);
+      CMCHKPK(oduUnpackUInt8,epdcchAddModLst->transmissionType,mBuf);
+      CMCHKPK(oduUnpackUInt8,epdcchAddModLst->resBlkAssignment.numPRBpairs,mBuf);
       for(idx = 4; idx >= 0; idx--)
       {
-         CMCHKPK(SPkU8,epdcchAddModLst->resBlkAssignment.rbAssignment[idx],mBuf);
+         CMCHKPK(oduUnpackUInt8,epdcchAddModLst->resBlkAssignment.rbAssignment[idx],mBuf);
       }
-      CMCHKPK(SPkU32,epdcchAddModLst->dmrsScrambSeq,mBuf);
-      CMCHKPK(SPkU32,epdcchAddModLst->pucchResStartoffset,mBuf);
-      CMCHKPK(cmPkTknU32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
-      CMCHKPK(cmPkTknU8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
-      CMCHKPK(SPkU8,epdcchAddModLst->extaddgrp2.pres,mBuf);
-      CMCHKPK(SPkU8,epdcchAddModLst->extaddgrp2.csiNumRep,mBuf);
-      CMCHKPK(SPkU8,epdcchAddModLst->extaddgrp2.mpddchPdschHop,mBuf);
-      CMCHKPK(SPkU8,epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD,mBuf);
-      CMCHKPK(SPkU16,epdcchAddModLst->extaddgrp2.mpdcchNumRep,mBuf);
-      CMCHKPK(SPkU32,epdcchAddModLst->extaddgrp2.mpddchNB,mBuf);
+      CMCHKPK(oduUnpackUInt32,epdcchAddModLst->dmrsScrambSeq,mBuf);
+      CMCHKPK(oduUnpackUInt32,epdcchAddModLst->pucchResStartoffset,mBuf);
+      CMCHKPK(cmPkTknUInt32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
+      CMCHKPK(cmPkTknUInt8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
+      CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.pres,mBuf);
+      CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.csiNumRep,mBuf);
+      CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.mpddchPdschHop,mBuf);
+      CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD,mBuf);
+      CMCHKPK(oduUnpackUInt16,epdcchAddModLst->extaddgrp2.mpdcchNumRep,mBuf);
+      CMCHKPK(oduUnpackUInt32,epdcchAddModLst->extaddgrp2.mpddchNB,mBuf);
    }
    
 /*Packing PUCCH Rep */
-   CMCHKPK(SPkU8,emtcPucchRepCfg->isPucchRepPres, mBuf);
-   CMCHKPK(SPkU8,emtcPucchRepCfg->modeANumPucchRepFormat1,mBuf);
-   CMCHKPK(SPkU8,emtcPucchRepCfg->modeANumPucchRepFormat2,mBuf);
-   CMCHKPK(SPkU8,param->pdschReptLevModeA,mBuf);
+   CMCHKPK(oduUnpackUInt8,emtcPucchRepCfg->isPucchRepPres, mBuf);
+   CMCHKPK(oduUnpackUInt8,emtcPucchRepCfg->modeANumPucchRepFormat1,mBuf);
+   CMCHKPK(oduUnpackUInt8,emtcPucchRepCfg->modeANumPucchRepFormat2,mBuf);
+   CMCHKPK(oduUnpackUInt8,param->pdschReptLevModeA,mBuf);
    
 #ifdef EMTC_DEBUG_CONSOLE_PRINTS 
    printf("\n EMTC RGR UE pack\n");
@@ -6683,37 +5588,37 @@ PUBLIC S16 cmPkRgrEmtcUeCfg
 
 
 
-   RETVALUE(ROK);
+   return ROK;
 }
 #endif
 
 #ifdef RG_5GTF
-PUBLIC S16 cmUnpkRgr5gtfUeCfg
+S16 cmUnpkRgr5gtfUeCfg
 (
  RgrUe5gtfCfg *param,
  Buffer       *mBuf
 )
 {
-   CMCHKUNPK(SUnpkU8, &param->grpId, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->BeamId, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numCC, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->mcs, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->maxPrb, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->grpId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->BeamId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numCC, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->maxPrb, mBuf);
+   return ROK;
 }
 
-PUBLIC S16 cmPkRgr5gtfUeCfg
+S16 cmPkRgr5gtfUeCfg
 (
  RgrUe5gtfCfg *param,
  Buffer       *mBuf
 )
 {
-   CMCHKPK(SPkU8, param->maxPrb, mBuf);
-   CMCHKPK(SPkU8, param->mcs, mBuf);
-   CMCHKPK(SPkU8, param->numCC, mBuf);
-   CMCHKPK(SPkU8, param->BeamId, mBuf);
-   CMCHKPK(SPkU8, param->grpId, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->maxPrb, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numCC, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->BeamId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->grpId, mBuf);
+   return ROK;
 }
 #endif
 
@@ -6733,29 +5638,22 @@ PUBLIC S16 cmPkRgr5gtfUeCfg
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeCfg
+S16 cmPkRgrUeCfg
 (
 RgrUeCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeCfg(param, mBuf)
-RgrUeCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeCfg)
 #ifdef RG_5GTF
    CMCHKPK(cmPkRgr5gtfUeCfg, &param->ue5gtfCfg, mBuf);
 #endif
 #ifdef EMTC_ENABLE
  CMCHKPK(cmPkRgrEmtcUeCfg, &param->emtcUeCfg, mBuf);
 #endif
-   CMCHKPK(SPkU8, param->csgMmbrSta, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->csgMmbrSta, mBuf);
 
-   CMCHKPK(SPkU32, param->accessStratumRls, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->accessStratumRls, mBuf);
    /* LTE_ADV_FLAG_REMOVED_START */
    CMCHKPK(cmPkRgrLteAdvancedUeConfig, &param->ueLteAdvCfg, mBuf);
    /* LTE_ADV_FLAG_REMOVED_END */
@@ -6775,7 +5673,7 @@ Buffer *mBuf;
 
 /*rgr_c_001.main_9 ADD added changes for HDFDD*/
 #ifdef LTEMAC_HDFDD
-   CMCHKPK(SPkU8, param->isHdFddEnbld, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isHdFddEnbld, mBuf);
 #endif
 
 #ifdef TFU_UPGRADE
@@ -6788,15 +5686,15 @@ Buffer *mBuf;
    CMCHKPK(cmPkRgrUeSpsCfg, &param->ueSpsCfg, mBuf);
 
 #ifdef LTE_TDD
-   CMCHKPK(SPkU32, param->ackNackModeEnum, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->ackNackModeEnum, mBuf);
 
 #endif
-   CMCHKPK(cmPkTknU8, &param->dedPreambleId, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->dedPreambleId, mBuf);
    CMCHKPK(cmPkRgrCodeBookRstCfg, &param->ueCodeBookRstCfg, mBuf);
    CMCHKPK(cmPkRgrUeCapCfg, &param->ueCapCfg, mBuf);
    CMCHKPK(cmPkRgrUeMeasGapCfg, &param->ueMesGapCfg, mBuf);
    CMCHKPK(cmPkRgrUeAckNackRepCfg, &param->ueAckNackCfg, mBuf);
-   CMCHKPK(SPkU8, param->isTtiBundlEnabled, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isTtiBundlEnabled, mBuf);
 /*rgr_c_001.main_9 ADD added changes for DRX*/
    
    /* Anshika - Pack only if DRX is enabled */
@@ -6804,9 +5702,9 @@ Buffer *mBuf;
    {   
     CMCHKPK(cmPkRgrUeDrxCfg, &param->ueDrxCfg, mBuf);
    }
-   CMCHKPK(SPkU8, param->ueDrxCfg.isDrxEnabled, mBuf); /* This has to be packed even if
+   CMCHKPK(oduUnpackUInt8, param->ueDrxCfg.isDrxEnabled, mBuf); /* This has to be packed even if
                                                  DRX is disabled */
-   CMCHKPK(SPkU32, param->ueCatEnum, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->ueCatEnum, mBuf);
 #ifdef RGR_V1
    /* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
     * retxBSR-timer */
@@ -6820,7 +5718,7 @@ Buffer *mBuf;
    CMCHKPK(cmPkRgrUeTxModeCfg, &param->txMode, mBuf);
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -6840,21 +5738,14 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeCfg
+S16 cmUnpkRgrUeCfg
 (
 RgrUeCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeCfg(param, mBuf)
-RgrUeCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrUeCfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
@@ -6869,25 +5760,25 @@ Buffer *mBuf;
     * retxBSR-timer */
    CMCHKUNPK(cmUnpkRgrUeBsrTmrCfg, &param->ueBsrTmrCfg, mBuf);
 #endif
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->ueCatEnum = (CmLteUeCategory) tmpEnum;
 /*rgr_c_001.main_9 ADD added changes for DRX*/
    
    /* Anshika - Unpack only if DRX is enabled */
-   CMCHKUNPK(SUnpkU8, &param->ueDrxCfg.isDrxEnabled, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ueDrxCfg.isDrxEnabled, mBuf);
    if(TRUE == param->ueDrxCfg.isDrxEnabled)
    {
       CMCHKUNPK(cmUnpkRgrUeDrxCfg, &param->ueDrxCfg, mBuf);
    }
-   CMCHKUNPK(SUnpkU8, &param->isTtiBundlEnabled, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isTtiBundlEnabled, mBuf);
    CMCHKUNPK(cmUnpkRgrUeAckNackRepCfg, &param->ueAckNackCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrUeMeasGapCfg, &param->ueMesGapCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrUeCapCfg, &param->ueCapCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrCodeBookRstCfg, &param->ueCodeBookRstCfg, mBuf);
-   CMCHKUNPK(cmUnpkTknU8, &param->dedPreambleId, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->dedPreambleId, mBuf);
 
 #ifdef LTE_TDD
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->ackNackModeEnum = tmpEnum;
 
 #endif
@@ -6901,7 +5792,7 @@ Buffer *mBuf;
 #endif
 /*rgr_c_001.main_9 ADD added changes for HDFDD*/
 #ifdef LTEMAC_HDFDD
-   CMCHKUNPK(SUnpkU8, &param->isHdFddEnbld, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isHdFddEnbld, mBuf);
 #endif
    CMCHKUNPK(cmUnpkRgrUePuschDedCfg, &param->puschDedCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrUeTxAntSelCfg, &param->ulTxAntSel, mBuf);
@@ -6916,8 +5807,8 @@ Buffer *mBuf;
    /* LTE_ADV_FLAG_REMOVED_START */
    CMCHKUNPK(cmUnpkRgrLteAdvancedUeConfig, &param->ueLteAdvCfg, mBuf);
    /* LTE_ADV_FLAG_REMOVED_END */
-   CMCHKUNPK(SUnpkU32, (U32 *)&param->accessStratumRls, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->csgMmbrSta, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->accessStratumRls, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->csgMmbrSta, mBuf);
 
 #ifdef EMTC_ENABLE
  CMCHKUNPK(cmUnpkRgrEmtcUeCfg, &param->emtcUeCfg, mBuf);
@@ -6927,7 +5818,7 @@ Buffer *mBuf;
  CMCHKUNPK(cmUnpkRgr5gtfUeCfg, &param->ue5gtfCfg, mBuf);
 #endif
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -6947,25 +5838,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrLchQosCfg
+S16 cmPkRgrLchQosCfg
 (
 RgrLchQosCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrLchQosCfg(param, mBuf)
-RgrLchQosCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrLchQosCfg)
 
-   CMCHKPK(SPkU32, param->mbr, mBuf);
-   CMCHKPK(SPkU32, param->gbr, mBuf);
-   CMCHKPK(SPkU8, param->qci, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt32, param->mbr, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->gbr, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
+   return ROK;
 }
 
 
@@ -6985,25 +5869,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLchQosCfg
+S16 cmUnpkRgrLchQosCfg
 (
 RgrLchQosCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrLchQosCfg(param, mBuf)
-RgrLchQosCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrLchQosCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->qci, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->gbr, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->mbr, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->qci, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->gbr, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->mbr, mBuf);
+   return ROK;
 }
 /*rgr_c_001.main_7 - Added support for SPS*/
 
@@ -7023,24 +5900,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrLchSpsCfg
+S16 cmPkRgrLchSpsCfg
 (
 RgrLchSpsCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrLchSpsCfg(param, mBuf)
-RgrLchSpsCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrLchSpsCfg)
 
    /* SPS_DEV */
-   CMCHKPK(SPkU8, param->isSpsEnabled, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->isSpsEnabled, mBuf);
+   return ROK;
 }
 
 
@@ -7060,24 +5930,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLchSpsCfg
+S16 cmUnpkRgrLchSpsCfg
 (
 RgrLchSpsCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrLchSpsCfg(param, mBuf)
-RgrLchSpsCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrLchSpsCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->isSpsEnabled, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isSpsEnabled, mBuf);
    
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -7096,27 +5959,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrDlLchCfg
+S16 cmPkRgrDlLchCfg
 (
 RgrDlLchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrDlLchCfg(param, mBuf)
-RgrDlLchCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrDlLchCfg)
 /*rgr_c_001.main_7 - Added support for SPS*/
 
-   CMCHKPK(SPkU8, param->rlcReorderTmr, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->rlcReorderTmr, mBuf);
    CMCHKPK(cmPkRgrLchSpsCfg, &param->dlSpsCfg, mBuf);
    CMCHKPK(cmPkRgrLchQosCfg, &param->dlQos, mBuf);
-   CMCHKPK(SPkU8, param->dlTrchType, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
+   return ROK;
 }
 
 
@@ -7136,28 +5992,21 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDlLchCfg
+S16 cmUnpkRgrDlLchCfg
 (
 RgrDlLchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrDlLchCfg(param, mBuf)
-RgrDlLchCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrDlLchCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->dlTrchType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->dlTrchType, mBuf);
    CMCHKUNPK(cmUnpkRgrLchQosCfg, &param->dlQos, mBuf);
    /*rgr_c_001.main_7 - Added support for SPs*/
    CMCHKUNPK(cmUnpkRgrLchSpsCfg, &param->dlSpsCfg, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->rlcReorderTmr, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->rlcReorderTmr, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -7180,24 +6029,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUlLchCfg
+S16 cmPkRgrUlLchCfg
 (
 RgrUlLchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUlLchCfg(param, mBuf)
-RgrUlLchCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUlLchCfg)
 
-   CMCHKPK(SPkU8, param->qci, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -7218,24 +6060,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUlLchCfg
+S16 cmUnpkRgrUlLchCfg
 (
 RgrUlLchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUlLchCfg(param, mBuf)
-RgrUlLchCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUlLchCfg)
 
    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->qci, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->qci, mBuf);
+   return ROK;
 }
 
 
@@ -7256,26 +6091,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUlLcgCfg
+S16 cmPkRgrUlLcgCfg
 (
 RgrUlLcgCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUlLcgCfg(param, mBuf)
-RgrUlLcgCfg *param;
-Buffer *mBuf;
-#endif
 {
 
 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
 #ifdef LTE_L2_MEAS
    S32 i;
 #endif
-   TRC3(cmPkRgrUlLcgCfg)
-   CMCHKPK(SPkU32, param->mbr, mBuf);
-   CMCHKPK(SPkU32, param->gbr, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->mbr, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->gbr, mBuf);
 
 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
 #ifdef LTE_L2_MEAS
@@ -7283,10 +6111,10 @@ Buffer *mBuf;
    {
       CMCHKPK(cmPkRgrUlLchCfg, &param->lchUlCfg[i], mBuf);
    }
-   CMCHKPK(SPkU8, param->numLch, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numLch, mBuf);
 #endif
-   CMCHKPK(SPkU8, param->lcgId, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
+   return ROK;
 }
 
 
@@ -7306,73 +6134,54 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUlLcgCfg
+S16 cmUnpkRgrUlLcgCfg
 (
 RgrUlLcgCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUlLcgCfg(param, mBuf)
-RgrUlLcgCfg *param;
-Buffer *mBuf;
-#endif
 {
 
 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
 #ifdef LTE_L2_MEAS
    S32 i;
 #endif
-   TRC3(cmUnpkRgrUlLcgCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->lcgId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
 #ifdef LTE_L2_MEAS
-   CMCHKUNPK(SUnpkU8, &param->numLch, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numLch, mBuf);
    for (i = 0; i< param->numLch; i++)
    {
       CMCHKUNPK(cmUnpkRgrUlLchCfg, &param->lchUlCfg[i], mBuf);
    }
 
 #endif
-   CMCHKUNPK(SUnpkU32, &param->gbr, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->mbr, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt32, &param->gbr, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->mbr, mBuf);
+   return ROK;
 }
 
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUlLchQciCfg
+S16 cmPkRgrUlLchQciCfg
 (
 RgrUlLchQciCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUlLchQciCfg (param, mBuf)
-RgrUlLchQciCfg *param;
-Buffer *mBuf;
-#endif
 {
-   CMCHKPK(SPkU8, param->lcId, mBuf);
-   CMCHKPK(SPkU8, param->qci, mBuf);
-   CMCHKPK(SPkU8, param->lcgId, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->lcId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
+   return ROK;
 }
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUlLchQciCfg
+S16 cmUnpkRgrUlLchQciCfg
 (
 RgrUlLchQciCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUlLchQciCfg (param, mBuf)
-RgrUlLchQciCfg *param;
-Buffer *mBuf;
-#endif
 {
-   CMCHKUNPK(SUnpkU8, &param->lcgId, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->qci, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->lcId, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->qci, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->lcId, mBuf);
+   return ROK;
 }
 
 
@@ -7391,28 +6200,21 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrLchCfg
+S16 cmPkRgrLchCfg
 (
 RgrLchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrLchCfg(param, mBuf)
-RgrLchCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrLchCfg)
-   CMCHKPK(SPkU8, param->lcgId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
    CMCHKPK(cmPkRgrUlLchQciCfg, &param->ulLchQciInfo, mBuf);
    CMCHKPK(cmPkRgrDlLchCfg, &param->dlInfo, mBuf);
    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -7432,20 +6234,13 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLchCfg
+S16 cmUnpkRgrLchCfg
 (
 RgrLchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrLchCfg(param, mBuf)
-RgrLchCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrLchCfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
@@ -7453,52 +6248,38 @@ Buffer *mBuf;
    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
    CMCHKUNPK(cmUnpkRgrDlLchCfg, &param->dlInfo, mBuf);
    CMCHKUNPK(cmUnpkRgrUlLchQciCfg, &param->ulLchQciInfo, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->lcgId, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
+   return ROK;
 }
 
 
-#ifdef ANSI
-PUBLIC S16 cmPkRgrLcgCfg
+S16 cmPkRgrLcgCfg
 (
 RgrLcgCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrLcgCfg(param, mBuf)
-RgrLcgCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrLcgCfg)
 
    CMCHKPK(cmPkRgrUlLcgCfg, &param->ulInfo, mBuf);
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLcgCfg
+S16 cmUnpkRgrLcgCfg
 (
 RgrLcgCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrLcgCfg(param, mBuf)
-RgrLcgCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrLcgCfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
    CMCHKUNPK(cmUnpkRgrUlLcgCfg, &param->ulInfo, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -7518,20 +6299,13 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrCfg
+S16 cmPkRgrCfg
 (
 RgrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrCfg(param, mBuf)
-RgrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrCfg)
 
       switch(param->cfgType) {
          case RGR_LCG_CFG:
@@ -7550,10 +6324,10 @@ Buffer *mBuf;
             CMCHKPK(cmPkMacSchedGnbCfg, &param->u.schedGnbCfg, mBuf);
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   CMCHKPK(SPkU8, param->cfgType, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->cfgType, mBuf);
+   return ROK;
 }
 
 
@@ -7573,22 +6347,15 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCfg
+S16 cmUnpkRgrCfg
 (
 RgrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrCfg(param, mBuf)
-RgrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->cfgType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cfgType, mBuf);
       switch(param->cfgType) {
          case MAC_GNB_CFG:
             CMCHKUNPK(cmUnpkMacSchedGnbCfg, &param->u.schedGnbCfg, mBuf);
@@ -7606,9 +6373,9 @@ Buffer *mBuf;
             CMCHKUNPK(cmUnpkRgrLcgCfg, &param->u.lcgCfg, mBuf);
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -7628,24 +6395,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrActvTime
+S16 cmPkRgrActvTime
 (
 RgrActvTime *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrActvTime(param, mBuf)
-RgrActvTime *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrActvTime)
 
    CMCHKPK(cmPkLteTimingInfo, &param->actvTime, mBuf);
-   CMCHKPK(SPkU8, param->pres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+   return ROK;
 }
 
 
@@ -7665,24 +6425,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrActvTime
+S16 cmUnpkRgrActvTime
 (
 RgrActvTime *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrActvTime(param, mBuf)
-RgrActvTime *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrActvTime)
 
-   CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->actvTime, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -7702,28 +6455,21 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrCellRecfg
+S16 cmPkRgrCellRecfg
 (
 RgrCellRecfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrCellRecfg(param, mBuf)
-RgrCellRecfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrCellRecfg)
    CMCHKPK(cmPkRgrCellCntrlCmdCfg, &param->cntrlCmdCfg, mBuf);
    CMCHKPK(cmPkRgrCellCsgParamCfg, &param->csgParamCfg, mBuf);
-   CMCHKPK(SPkU8, param->isDynCfiEnb, mBuf);
-   CMCHKPK(SPkU8, param->isAutoCfgModeEnb, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isDynCfiEnb, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isAutoCfgModeEnb, mBuf);
    /* LTE_ADV_FLAG_REMOVED_START */
    CMCHKPK(cmPkRgrCellLteAdvancedFeatureCfg, &param->rgrLteAdvCfg, mBuf);
    /* LTE_ADV_FLAG_REMOVED_END */
-   CMCHKPK(SPkU16, param->t300TmrVal, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->t300TmrVal, mBuf);
    /* rgr_c_001.main_4:MOD-Modified for SI Enhancement. */
 #ifdef RGR_SI_SCH
    CMCHKPK(cmPkRgrSiCfg, &param->siReCfg, mBuf);
@@ -7739,9 +6485,9 @@ Buffer *mBuf;
    CMCHKPK(cmPkRgrCfiCfg, &param->cfiRecfg, mBuf);
    CMCHKPK(cmPkRgrDlHqCfg, &param->dlHqRecfg, mBuf);
    CMCHKPK(cmPkRgrActvTime, &param->recfgActvTime, mBuf);
-   CMCHKPK(SPkU32, param->recfgTypes, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->recfgTypes, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -7761,23 +6507,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCellRecfg
+S16 cmUnpkRgrCellRecfg
 (
 RgrCellRecfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrCellRecfg(param, mBuf)
-RgrCellRecfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrCellRecfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->recfgTypes, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->recfgTypes, mBuf);
    CMCHKUNPK(cmUnpkRgrActvTime, &param->recfgActvTime, mBuf);
    CMCHKUNPK(cmUnpkRgrDlHqCfg, &param->dlHqRecfg, mBuf);
    CMCHKUNPK(cmUnpkRgrCfiCfg, &param->cfiRecfg, mBuf);
@@ -7793,16 +6532,16 @@ Buffer *mBuf;
 #ifdef RGR_SI_SCH
    CMCHKUNPK(cmUnpkRgrSiCfg, &param->siReCfg, mBuf);
 #endif /* RGR_SI_SCH */
-   CMCHKUNPK(SUnpkU16, &param->t300TmrVal, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->t300TmrVal, mBuf);
    /* LTE_ADV_FLAG_REMOVED_START */
    CMCHKUNPK(cmUnpkRgrCellLteAdvancedFeatureCfg, &param->rgrLteAdvCfg, mBuf);
    /* LTE_ADV_FLAG_REMOVED_END */
-   CMCHKUNPK(SUnpkU8, &param->isAutoCfgModeEnb, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isDynCfiEnb, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isAutoCfgModeEnb, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isDynCfiEnb, mBuf);
    CMCHKUNPK(cmUnpkRgrCellCsgParamCfg, &param->csgParamCfg, mBuf);
    CMCHKUNPK(cmUnpkRgrCellCntrlCmdCfg, &param->cntrlCmdCfg, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -7822,37 +6561,30 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeRecfg
+S16 cmPkRgrUeRecfg
 (
 RgrUeRecfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeRecfg(param, mBuf)
-RgrUeRecfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeRecfg)
 #ifdef EMTC_ENABLE
    /* Note: As we add more members to emtcUeRecfg, 
       create a new function for pkUnpk */
-   CMCHKPK(SPkU8, param->emtcUeRecfg.isHdFddEnbld, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->emtcUeRecfg.isHdFddEnbld, mBuf);
 #endif
-   CMCHKPK(SPkU8, param->csgMmbrSta, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->csgMmbrSta, mBuf);
   
-   CMCHKPK(SPkU32, param->accessStratumRls, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->accessStratumRls, mBuf);
 #ifdef LTE_ADV 
-   CMCHKPK(SPkU8, param->simulAckNackCQIFormat3, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->simulAckNackCQIFormat3, mBuf);
    CMCHKPK(cmPkRgrUeSCellAckPucchCfg, &param->sCellAckN1ResCfg,mBuf);
    CMCHKPK(cmPkRgrUeSecCellInfo, &param->ueSCellCfgInfo,mBuf);
 #endif
    /* LTE_ADV_FLAG_REMOVED_START */
-   CMCHKPK(SPkU8, param->ueLteAdvCfg.isUeCellEdge, mBuf);
-   CMCHKPK(SPkU8, param->ueLteAdvCfg.isAbsUe, mBuf);
-   CMCHKPK(SPkU32, param->ueLteAdvCfg.pres, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->ueLteAdvCfg.isUeCellEdge, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->ueLteAdvCfg.isAbsUe, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->ueLteAdvCfg.pres, mBuf);
    /* LTE_ADV_FLAG_REMOVED_END */
    /*ccpu00130497: Removed the duplicate packing*/
 #ifdef TFU_UPGRADE
@@ -7869,7 +6601,7 @@ Buffer *mBuf;
 
 /*rgr_c_001.main_9 ADD added changes for HDFDD*/
 #ifdef LTEMAC_HDFDD
-   CMCHKPK(SPkU8, param->isHdFddEnbld, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isHdFddEnbld, mBuf);
 #endif
 
 #ifdef TFU_UPGRADE
@@ -7883,13 +6615,13 @@ Buffer *mBuf;
    CMCHKPK(cmPkRgrUeTxAntSelCfg, &param->ulTxAntSel, mBuf);
 
    /* rgr_c_001.main_7 - Changes for UE category Reconfiguration */
-   CMCHKPK(SPkU32, param->ueCatEnum, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->ueCatEnum, mBuf);
 
    CMCHKPK(cmPkRgrCodeBookRstCfg, &param->ueCodeBookRstRecfg, mBuf);
    CMCHKPK(cmPkRgrUeMeasGapCfg, &param->ueMeasGapRecfg, mBuf);
    CMCHKPK(cmPkRgrUeCapCfg, &param->ueCapRecfg, mBuf);
    CMCHKPK(cmPkRgrUeAckNackRepCfg, &param->ueAckNackRecfg, mBuf);
-   CMCHKPK(SPkU8, param->isTtiBundlEnabled, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isTtiBundlEnabled, mBuf);
 /*rgr_c_001.main_9 ADD added changes for DRX*/
    
    /* Anshika - Pack only if DRX is enabled */
@@ -7897,7 +6629,7 @@ Buffer *mBuf;
    {
       CMCHKPK(cmPkRgrUeDrxCfg, &param->ueDrxRecfg, mBuf);
    }
-   CMCHKPK(SPkU8, param->ueDrxRecfg.isDrxEnabled, mBuf); /* This has to be packed even if
+   CMCHKPK(oduUnpackUInt8, param->ueDrxRecfg.isDrxEnabled, mBuf); /* This has to be packed even if
                                                  DRX is disabled */
    CMCHKPK(cmPkRgrUeUlPwrCfg, &param->ueUlPwrRecfg, mBuf);
 #ifdef RGR_V1
@@ -7915,15 +6647,15 @@ Buffer *mBuf;
 
    CMCHKPK(cmPkRgrUeAprdDlCqiCfg, &param->aprdDlCqiRecfg, mBuf);
    CMCHKPK(cmPkRgrUeTxModeCfg, &param->txMode, mBuf);
-   /*rgr_c_001.main_9: changing ueRecfgTypes to U32 */
+   /*rgr_c_001.main_9: changing ueRecfgTypes to uint32_t */
    /* LTE_ADV_FLAG_REMOVED_START */
    /* KW fix for LTE_ADV */
-   CMCHKPK(SPkU32, param->ueRecfgTypes, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->ueRecfgTypes, mBuf);
    /* LTE_ADV_FLAG_REMOVED_END */
    CMCHKPK(cmPkLteRnti, param->newCrnti, mBuf);
    CMCHKPK(cmPkLteRnti, param->oldCrnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -7943,29 +6675,22 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeRecfg
+S16 cmUnpkRgrUeRecfg
 (
 RgrUeRecfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeRecfg(param, mBuf)
-RgrUeRecfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrUeRecfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->oldCrnti, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->newCrnti, mBuf);
    /* LTE_ADV_FLAG_REMOVED_START */
-   /*rgr_c_001.main_9: changing ueRecfgTypes to U32 */
+   /*rgr_c_001.main_9: changing ueRecfgTypes to uint32_t */
    /* KW fix for LTE_ADV */
-   CMCHKUNPK(SUnpkU32, &param->ueRecfgTypes, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->ueRecfgTypes, mBuf);
    /* LTE_ADV_FLAG_REMOVED_END */
    CMCHKUNPK(cmUnpkRgrUeTxModeCfg, &param->txMode, mBuf);
 
@@ -7987,18 +6712,18 @@ Buffer *mBuf;
 /*rgr_c_001.main_9 ADD added changes for DRX*/
    
    /* Anshika - Unpack only if DRX is enabled */
-   CMCHKUNPK(SUnpkU8, &param->ueDrxRecfg.isDrxEnabled, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ueDrxRecfg.isDrxEnabled, mBuf);
    if(TRUE == param->ueDrxRecfg.isDrxEnabled)
    {
       CMCHKUNPK(cmUnpkRgrUeDrxCfg, &param->ueDrxRecfg, mBuf);
    }
-   CMCHKUNPK(SUnpkU8, &param->isTtiBundlEnabled, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isTtiBundlEnabled, mBuf);
    CMCHKUNPK(cmUnpkRgrUeAckNackRepCfg, &param->ueAckNackRecfg, mBuf);
    CMCHKUNPK(cmUnpkRgrUeCapCfg, &param->ueCapRecfg, mBuf);
    CMCHKUNPK(cmUnpkRgrUeMeasGapCfg, &param->ueMeasGapRecfg, mBuf);
    CMCHKUNPK(cmUnpkRgrCodeBookRstCfg, &param->ueCodeBookRstRecfg, mBuf);
 /* rgr_c_001.main_7 - Changes for UE category Reconfiguration */
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
    param->ueCatEnum = (CmLteUeCategory) tmpEnum;
    CMCHKUNPK(cmUnpkRgrUeTxAntSelCfg, &param->ulTxAntSel, mBuf);
    /*rgr_c_001.main_7 - Added support for SPS*/
@@ -8013,7 +6738,7 @@ Buffer *mBuf;
 
 /*rgr_c_001.main_9 ADD added changes for HDFDD*/
 #ifdef LTEMAC_HDFDD
-   CMCHKUNPK(SUnpkU8, &param->isHdFddEnbld, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isHdFddEnbld, mBuf);
 #endif
 
    CMCHKUNPK(cmUnpkRgrUePuschDedCfg, &param->puschDedCfg, mBuf);
@@ -8028,23 +6753,23 @@ Buffer *mBuf;
 #endif
 
    /* LTE_ADV_FLAG_REMOVED_START */
-   CMCHKUNPK(SUnpkU32, &param->ueLteAdvCfg.pres, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->ueLteAdvCfg.isAbsUe, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->ueLteAdvCfg.isUeCellEdge, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->ueLteAdvCfg.pres, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ueLteAdvCfg.isAbsUe, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ueLteAdvCfg.isUeCellEdge, mBuf);
    /* LTE_ADV_FLAG_REMOVED_END */
 #ifdef LTE_ADV 
    CMCHKUNPK(cmUnpkRgrUeSecCellInfo, &param->ueSCellCfgInfo,mBuf);
    CMCHKUNPK(cmUnpkRgrUeSCellAckPucchCfg, &param->sCellAckN1ResCfg,mBuf);
-   CMCHKUNPK(SUnpkU8, &param->simulAckNackCQIFormat3, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->simulAckNackCQIFormat3, mBuf);
 #endif
-   CMCHKUNPK(SUnpkU32, (U32 *)&param->accessStratumRls, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->accessStratumRls, mBuf);
 
-   CMCHKUNPK(SUnpkU8, &param->csgMmbrSta, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->csgMmbrSta, mBuf);
 #ifdef EMTC_ENABLE
-   CMCHKPK(SUnpkU8, &param->emtcUeRecfg.isHdFddEnbld, mBuf);
+   CMCHKPK(oduPackUInt8, &param->emtcUeRecfg.isHdFddEnbld, mBuf);
 #endif
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -8064,22 +6789,15 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrLchRecfg
+S16 cmPkRgrLchRecfg
 (
 RgrLchRecfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrLchRecfg(param, mBuf)
-RgrLchRecfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrLchRecfg)
 /*rgr_c_001.main_7 - Added support for SPS*/
-   CMCHKPK(SPkU8, param->lcgId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
    
    CMCHKPK(cmPkRgrUlLchQciCfg, &param->ulLchQciInfo, mBuf);
    CMCHKPK(cmPkRgrLchSpsCfg, &param->dlRecfg.dlSpsRecfg, mBuf);
@@ -8088,7 +6806,7 @@ Buffer *mBuf;
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -8108,20 +6826,13 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLchRecfg
+S16 cmUnpkRgrLchRecfg
 (
 RgrLchRecfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrLchRecfg(param, mBuf)
-RgrLchRecfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrLchRecfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
@@ -8131,76 +6842,62 @@ Buffer *mBuf;
    CMCHKUNPK(cmUnpkRgrLchSpsCfg, &param->dlRecfg.dlSpsRecfg, mBuf);
 
    CMCHKUNPK(cmUnpkRgrUlLchQciCfg, &param->ulLchQciInfo, mBuf);   
-   CMCHKUNPK(SUnpkU8, &param->lcgId, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
+   return ROK;
 }
 
 
-#ifdef ANSI
-PUBLIC S16 cmPkRgrLcgRecfg
+S16 cmPkRgrLcgRecfg
 (
 RgrLcgRecfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrLcgRecfg(param, mBuf)
-RgrLcgRecfg *param;
-Buffer *mBuf;
-#endif
 {
 #ifdef RG_UNUSED
    S32 i;
 #endif
-   TRC3(cmPkRgrLcgRecfg)
 
-   CMCHKPK(SPkU32, param->ulRecfg.mbr, mBuf);
-   CMCHKPK(SPkU32, param->ulRecfg.gbr, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->ulRecfg.mbr, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->ulRecfg.gbr, mBuf);
 #ifdef RG_UNUSED
    for (i = param->ulRecfg.numLch - 1; i >= 0; i--)
    {
       CMCHKPK(cmPkRgrUlLchCfg, &param->ulRecfg.lchUlCfg[i], mBuf);
    }
-   CMCHKPK(SPkU8, param->ulRecfg.numLch, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->ulRecfg.numLch, mBuf);
 #endif
-   CMCHKPK(SPkU8, param->ulRecfg.lcgId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->ulRecfg.lcgId, mBuf);
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLcgRecfg
+S16 cmUnpkRgrLcgRecfg
 (
 RgrLcgRecfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrLcgRecfg(param, mBuf)
-RgrLcgRecfg *param;
-Buffer *mBuf;
-#endif
 {
 #ifdef RG_UNUSED
    S32 i;
 #endif
-   TRC3(cmUnpkRgrLcgRecfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->ulRecfg.lcgId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ulRecfg.lcgId, mBuf);
 
 #ifdef RG_UNUSED
-   CMCHKUNPK(SUnpkU8, &param->ulRecfg.numLch, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ulRecfg.numLch, mBuf);
    for (i = 0; i < param->ulRecfg.numLch; i++)
    {
       CMCHKUNPK(cmUnpkRgrUlLchCfg, &param->ulRecfg.lchUlCfg[i], mBuf);
    }
 #endif
-   CMCHKUNPK(SUnpkU32, &param->ulRecfg.gbr, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->ulRecfg.mbr, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->ulRecfg.gbr, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->ulRecfg.mbr, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -8220,20 +6917,13 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrRecfg
+S16 cmPkRgrRecfg
 (
 RgrRecfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrRecfg(param, mBuf)
-RgrRecfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrRecfg)
 
       switch(param->recfgType) {
          case RGR_LCG_CFG:
@@ -8249,10 +6939,10 @@ Buffer *mBuf;
             CMCHKPK(cmPkRgrCellRecfg, &param->u.cellRecfg, mBuf);
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   CMCHKPK(SPkU8, param->recfgType, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->recfgType, mBuf);
+   return ROK;
 }
 
 
@@ -8272,22 +6962,15 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrRecfg
+S16 cmUnpkRgrRecfg
 (
 RgrRecfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrRecfg(param, mBuf)
-RgrRecfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrRecfg)
 
-   CMCHKUNPK(SUnpkU8, &param->recfgType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->recfgType, mBuf);
       switch(param->recfgType) {
          case RGR_CELL_CFG:
             CMCHKUNPK(cmUnpkRgrCellRecfg, &param->u.cellRecfg, mBuf);
@@ -8302,9 +6985,9 @@ Buffer *mBuf;
             CMCHKUNPK(cmUnpkRgrLcgRecfg, &param->u.lcgRecfg, mBuf);
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 #ifdef LTE_ADV
@@ -8323,21 +7006,15 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeDlSecCellRelInfo
+S16 cmPkRgrUeDlSecCellRelInfo
 (
 RgrUeDlSecCellRelInfo *param,
 Buffer *mBuf
 )
-#else
-PRIVATE S16 cmPkRgrUeDlSecCellRelInfo(param, mBuf)
-RgrUeDlSecCellRelInfo *param;
-Buffer *mBuf;
-#endif
 {
-   CMCHKPK(SPkU16, param->sCellId, mBuf);
-   CMCHKPK(SPkU8, param->sCellIdx, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
+   return ROK;
 }
 
 /***********************************************************
@@ -8355,26 +7032,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSecCellRelInfo
+S16 cmPkRgrUeSecCellRelInfo
 (
 RgrUeSecCellRelInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeSecCellRelInfo(param, mBuf)
-RgrUeSecCellRelInfo *param;
-Buffer *mBuf;
-#endif
 {
    S8 idx;
    for(idx = param->numSCells - 1; idx >= 0; idx--)
    {
-      CMCHKPK(cmPkRgrUeDlSecCellRelInfo, &param->ueSCellRelDedCfg[(U8)idx],mBuf);
+      CMCHKPK(cmPkRgrUeDlSecCellRelInfo, &param->ueSCellRelDedCfg[(uint8_t)idx],mBuf);
    }
-   CMCHKPK(SPkU8, param->numSCells, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 #endif
 
@@ -8394,29 +7065,22 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrDel
+S16 cmPkRgrDel
 (
 RgrDel *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrDel(param, mBuf)
-RgrDel *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrDel)
 
       switch(param->delType) {
          case RGR_LCG_CFG:
-            CMCHKPK(SPkU8, param->u.lcgDel.lcgId, mBuf);
+            CMCHKPK(oduUnpackUInt8, param->u.lcgDel.lcgId, mBuf);
             CMCHKPK(cmPkLteRnti, param->u.lcgDel.crnti, mBuf);
             CMCHKPK(cmPkLteCellId, param->u.lcgDel.cellId, mBuf);
          break;
          case RGR_LCH_CFG:
-            CMCHKPK(SPkU8, param->u.lchDel.lcgId, mBuf);
+            CMCHKPK(oduUnpackUInt8, param->u.lchDel.lcgId, mBuf);
             CMCHKPK(cmPkLteLcId, param->u.lchDel.lcId, mBuf);
             CMCHKPK(cmPkLteRnti, param->u.lchDel.crnti, mBuf);
             CMCHKPK(cmPkLteCellId, param->u.lchDel.cellId, mBuf);
@@ -8431,16 +7095,16 @@ Buffer *mBuf;
 #ifdef LTE_ADV
          case RGR_SCELL_UE_CFG:
             CMCHKPK(cmPkRgrUeSecCellRelInfo, &param->u.ueScellRel.ueSCellRelCfgInfo, mBuf);
-            CMCHKPK(SPkU32, param->u.ueScellRel.ueDelTypes, mBuf);
+            CMCHKPK(oduUnpackUInt32, param->u.ueScellRel.ueDelTypes, mBuf);
             CMCHKPK(cmPkLteRnti, param->u.ueScellRel.crnti, mBuf);
             CMCHKPK(cmPkLteCellId, param->u.ueScellRel.cellId, mBuf);
          break;
 #endif
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   CMCHKPK(SPkU8, param->delType, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->delType, mBuf);
+   return ROK;
 }
 
 
@@ -8461,21 +7125,15 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeDlSecCellRelInfo
+S16 cmUnpkRgrUeDlSecCellRelInfo
 (
 RgrUeDlSecCellRelInfo *param,
 Buffer *mBuf
 )
-#else
-PRIVATE S16 cmUnpkRgrUeDlSecCellRelInfo(param, mBuf)
-RgrUeDlSecCellRelInfo *param;
-Buffer *mBuf;
-#endif
 {
-   CMCHKUNPK(SUnpkU8, &param->sCellIdx, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->sCellId, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->sCellIdx, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->sCellId, mBuf);
+   return ROK;
 }
 
 
@@ -8494,27 +7152,21 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSecCellRelInfo
+S16 cmUnpkRgrUeSecCellRelInfo
 (
 RgrUeSecCellRelInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeSecCellRelInfo(param, mBuf)
-RgrUeSecCellRelInfo *param;
-Buffer *mBuf;
-#endif
 {
-   U8 idx;
+   uint8_t idx;
 
-   CMCHKUNPK(SUnpkU8, &param->numSCells, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numSCells, mBuf);
 
    for(idx = 0; idx < param->numSCells;idx++)
    {
       CMCHKUNPK(cmUnpkRgrUeDlSecCellRelInfo, &param->ueSCellRelDedCfg[idx],mBuf);
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 #endif
 
@@ -8533,22 +7185,15 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDel
+S16 cmUnpkRgrDel
 (
 RgrDel *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrDel(param, mBuf)
-RgrDel *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrDel)
 
-   CMCHKUNPK(SUnpkU8, &param->delType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->delType, mBuf);
       switch(param->delType) {
          case RGR_CELL_CFG:
             CMCHKUNPK(cmUnpkLteCellId, &param->u.cellDel.cellId, mBuf);
@@ -8561,25 +7206,25 @@ Buffer *mBuf;
             CMCHKUNPK(cmUnpkLteCellId, &param->u.lchDel.cellId, mBuf);
             CMCHKUNPK(cmUnpkLteRnti, &param->u.lchDel.crnti, mBuf);
             CMCHKUNPK(cmUnpkLteLcId, &param->u.lchDel.lcId, mBuf);
-            CMCHKUNPK(SUnpkU8, &param->u.lchDel.lcgId, mBuf);
+            CMCHKUNPK(oduPackUInt8, &param->u.lchDel.lcgId, mBuf);
          break;
          case RGR_LCG_CFG:
             CMCHKUNPK(cmUnpkLteCellId, &param->u.lcgDel.cellId, mBuf);
             CMCHKUNPK(cmUnpkLteRnti, &param->u.lcgDel.crnti, mBuf);
-            CMCHKUNPK(SUnpkU8, &param->u.lcgDel.lcgId, mBuf);
+            CMCHKUNPK(oduPackUInt8, &param->u.lcgDel.lcgId, mBuf);
          break;
 #ifdef LTE_ADV
          case RGR_SCELL_UE_CFG:
             CMCHKUNPK(cmUnpkLteCellId, &param->u.ueScellRel.cellId, mBuf);
             CMCHKUNPK(cmUnpkLteRnti, &param->u.ueScellRel.crnti, mBuf);
-            CMCHKUNPK(SUnpkU32, &param->u.ueScellRel.ueDelTypes, mBuf);
+            CMCHKUNPK(oduPackUInt32, &param->u.ueScellRel.ueDelTypes, mBuf);
             CMCHKUNPK(cmUnpkRgrUeSecCellRelInfo, &param->u.ueScellRel.ueSCellRelCfgInfo, mBuf);
          break;
 #endif
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 /***********************************************************
 *
@@ -8596,23 +7241,16 @@ Buffer *mBuf;
 *     File  :
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrSonPrbCfg
+S16 cmPkRgrSonPrbCfg
 (
 RgrPrbCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrSonPrbCfg(param, mBuf)
-RgrPrbCfg *param;
-Buffer *mBuf;
-#endif
 {
    S32 count;
-   TRC3(cmPkRgrPrbCfg)
    for(count = RGR_SCH_MAX_PA_PER_PRB - 1; count >= 0; count --)
    {
-      CMCHKPK(SPkU32, param->paLevelPerPrb[count], mBuf);
+      CMCHKPK(oduUnpackUInt32, param->paLevelPerPrb[count], mBuf);
    }
    for(count = param->numCellCentreUEs - 1; count >= 0; count --)
    {
@@ -8622,10 +7260,10 @@ Buffer *mBuf;
    {
       CMCHKPK(cmPkLteRnti, param->cellEdgeUe[count], mBuf);
    }
-   CMCHKPK(SPkU8, param->numCellCentreUEs, mBuf);
-   CMCHKPK(SPkU8, param->numCellEdgeUEs, mBuf);
-   CMCHKPK(SPkU8, param->isSonIcicEnable, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->numCellCentreUEs, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numCellEdgeUEs, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isSonIcicEnable, mBuf);
+   return ROK;
 }
 
 /***********************************************************
@@ -8643,23 +7281,16 @@ Buffer *mBuf;
 *     File  :
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSonPrbCfg
+S16 cmUnpkRgrSonPrbCfg
 (
 RgrPrbCfg   *param,
 Buffer      *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrSonPrbCfg(param, mBuf)
-RgrPrbCfg   *param;
-Buffer      *mBuf;
-#endif
 {
    S32   count;
-   TRC3(cmUnpkRgrSonPrbCfg)
-   CMCHKUNPK(SUnpkU8, &param->isSonIcicEnable, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numCellEdgeUEs, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numCellCentreUEs, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isSonIcicEnable, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numCellEdgeUEs, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numCellCentreUEs, mBuf);
    for (count = 0; count < param->numCellEdgeUEs; count++)
    {
       CMCHKUNPK(cmUnpkLteRnti, &param->cellEdgeUe[count], mBuf);
@@ -8670,9 +7301,9 @@ Buffer      *mBuf;
    }
    for(count = 0; count < RGR_SCH_MAX_PA_PER_PRB; count ++)
    {
-      CMCHKUNPK(SUnpkU32,(U32 *) &param->paLevelPerPrb[count], mBuf);
+      CMCHKUNPK(oduPackUInt32,(uint32_t *) &param->paLevelPerPrb[count], mBuf);
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 /***********************************************************
 *
@@ -8689,30 +7320,23 @@ Buffer      *mBuf;
 *     File  :
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrSonCfg
+S16 cmPkRgrSonCfg
 (
 RgrSonCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrSonCfg(param, mBuf)
-RgrSonCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrSonCfg)
    switch(param->cfgType)
    {
       case RGR_SON_PRB_CFG :
       CMCHKPK(cmPkRgrSonPrbCfg, &param->u.prbCfg, mBuf);
       break;
       default :
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   CMCHKPK(SPkU32, param->cfgType, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt32, param->cfgType, mBuf);
+   return ROK;
 }
 
 /***********************************************************
@@ -8730,21 +7354,14 @@ Buffer *mBuf;
 *     File  :
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSonCfg
+S16 cmUnpkRgrSonCfg
 (
 RgrSonCfg   *param,
 Buffer      *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrSonCfg(param, mBuf)
-RgrSonCfg   *param;
-Buffer      *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrSonCfg)
-   CMCHKUNPK(SUnpkU32, (U32 *)&param->cfgType, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->cfgType, mBuf);
    switch(param->cfgType)
    {
       case RGR_SON_PRB_CFG :
@@ -8752,10 +7369,10 @@ Buffer      *mBuf;
          CMCHKUNPK(cmUnpkRgrSonPrbCfg, &param->u.prbCfg, mBuf);
          break;
          default :
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -8774,24 +7391,17 @@ Buffer      *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrRst
+S16 cmPkRgrRst
 (
 RgrRst *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrRst(param, mBuf)
-RgrRst *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrRst)
 
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -8811,24 +7421,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrRst
+S16 cmUnpkRgrRst
 (
 RgrRst *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrRst(param, mBuf)
-RgrRst *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrRst)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 #ifdef LTE_ADV
 /***********************************************************
@@ -8846,22 +7449,15 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PRIVATE S16 cmUnPkRgrSCellActDeactInfo
+static S16 cmUnPkRgrSCellActDeactInfo
 (
 RgrSCellActDeactInfo *param,
 Buffer *mBuf
 )
-#else
-PRIVATE S16 cmUnPkRgrSCellActInfo(param, mBuf)
-RgrSCellActDeactInfo *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmUnPkRgrSCellActDeactInfo)
 
-   CMCHKUNPK(SUnpkU8, &param->sCellIdx, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->sCellIdx, mBuf);
+   return ROK;
 }
 
 /***********************************************************
@@ -8879,31 +7475,24 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnPkRgrSCellActDeactEvnt
+S16 cmUnPkRgrSCellActDeactEvnt
 (
 RgrSCellActDeactEvnt *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnPkRgrSCellActDeactEvnt(param, mBuf)
-RgrSCellActDeactEvnt *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmUnPkRgrSCellActDeactEvnt)
 
-   U8 idx;
+   uint8_t idx;
 
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numOfSCells, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numOfSCells, mBuf);
 
    for(idx = 0; idx < param->numOfSCells;idx++)
    {
       CMCHKUNPK(cmUnPkRgrSCellActDeactInfo, &param->sCellActDeactInfo[idx],mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -8922,23 +7511,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PRIVATE S16 cmPkRgrSCellActDeactInfo
+static S16 cmPkRgrSCellActDeactInfo
 (
 RgrSCellActDeactInfo *param,
 Buffer *mBuf
 )
-#else
-PRIVATE S16 cmPkRgrSCellActDeactInfo(param, mBuf)
-RgrSCellActDeactInfo *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmPkRgrSCellActDeactInfo)
 
-   CMCHKPK(SPkU8, param->sCellIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -8956,31 +7538,24 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrSCellActDeactEvnt
+S16 cmPkRgrSCellActDeactEvnt
 (
 RgrSCellActDeactEvnt *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrSCellActDeactEvnt(param, mBuf)
-RgrSCellActDeactEvnt *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrSCellActDeactEvnt)
 
    S8 idx;
    for(idx = param->numOfSCells - 1; idx >= 0; idx--)
    {
-      CMCHKPK(cmPkRgrSCellActDeactInfo, &param->sCellActDeactInfo[(U8)idx], mBuf);
+      CMCHKPK(cmPkRgrSCellActDeactInfo, &param->sCellActDeactInfo[(uint8_t)idx], mBuf);
    }
 
-   CMCHKPK(SPkU8, param->numOfSCells, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numOfSCells, mBuf);
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -9001,20 +7576,13 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrCfgReqInfo
+S16 cmPkRgrCfgReqInfo
 (
 RgrCfgReqInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrCfgReqInfo(param, mBuf)
-RgrCfgReqInfo *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrCfgReqInfo)
 
       switch(param->action) {
          case RGR_SON_CFG:
@@ -9040,10 +7608,10 @@ Buffer *mBuf;
             break;
 #endif
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   CMCHKPK(SPkU8, param->action, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->action, mBuf);
+   return ROK;
 }
 
 
@@ -9063,22 +7631,15 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCfgReqInfo
+S16 cmUnpkRgrCfgReqInfo
 (
 RgrCfgReqInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrCfgReqInfo(param, mBuf)
-RgrCfgReqInfo *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrCfgReqInfo)
 
-   CMCHKUNPK(SUnpkU8, &param->action, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->action, mBuf);
       switch(param->action) {
          case SCH_CONFIG:
             CMCHKUNPK(cmUnpkRgrCfg, &param->u.cfgInfo, mBuf);
@@ -9103,9 +7664,9 @@ Buffer *mBuf;
             break;
 #endif /* LTE_ADV */
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 #ifdef RGR_V1
 /* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
@@ -9125,25 +7686,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeBsrTmrCfg
+S16 cmPkRgrUeBsrTmrCfg
 (
 RgrUeBsrTmrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeBsrTmrCfg(param, mBuf)
-RgrUeBsrTmrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeBsrTmrCfg)
 
-   CMCHKPK(SPkU16, param->prdBsrTmr, mBuf);
-   CMCHKPK(SPkU16, param->retxBsrTmr, mBuf);
-   CMCHKPK(SPkU8, param->isPrdBsrTmrPres, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt16, param->prdBsrTmr, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->retxBsrTmr, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isPrdBsrTmrPres, mBuf);
+   return ROK;
 }
 
 /***********************************************************
@@ -9161,25 +7715,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeBsrTmrCfg
+S16 cmUnpkRgrUeBsrTmrCfg
 (
 RgrUeBsrTmrCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeBsrTmrCfg(param, mBuf)
-RgrUeBsrTmrCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeBsrTmrCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->isPrdBsrTmrPres, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->retxBsrTmr, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->prdBsrTmr, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->isPrdBsrTmrPres, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->retxBsrTmr, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->prdBsrTmr, mBuf);
+   return ROK;
 }
 #endif /* RGR_V1 */
 /* rgr_c_001.main_4-ADD-Added for SI Enhancement. */
@@ -9200,25 +7747,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrSiCfgReq
+S16 cmPkRgrSiCfgReq
 (
 Pst* pst,
 SpId spId,
 RgrCfgTransId transId,
 RgrSiCfgReqInfo * cfgReqInfo
 )
-#else
-PUBLIC S16 cmPkRgrSiCfgReq(pst, spId, transId, cfgReqInfo)
-Pst* pst;
-SpId spId;
-RgrCfgTransId transId;
-RgrSiCfgReqInfo * cfgReqInfo;
-#endif
 {
    Buffer *mBuf = NULLP;
 
-   TRC3(cmPkRgrSiCfgReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
    {
@@ -9227,9 +7765,9 @@ RgrSiCfgReqInfo * cfgReqInfo;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR045, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, 
                  sizeof(RgrSiCfgReqInfo));
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmPkRgrSiCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -9237,10 +7775,10 @@ RgrSiCfgReqInfo * cfgReqInfo;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR046, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, 
                 sizeof(RgrSiCfgReqInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -9248,10 +7786,10 @@ RgrSiCfgReqInfo * cfgReqInfo;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR047, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, 
                sizeof(RgrSiCfgReqInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(spId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -9259,12 +7797,12 @@ RgrSiCfgReqInfo * cfgReqInfo;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR048, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, 
                sizeof(RgrSiCfgReqInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, 
+   if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, 
                sizeof(RgrSiCfgReqInfo)) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -9272,11 +7810,11 @@ RgrSiCfgReqInfo * cfgReqInfo;
             (ErrVal)ERGR049, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    pst->event = (Event) EVTRGRSICFGREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 /***********************************************************
@@ -9295,25 +7833,17 @@ RgrSiCfgReqInfo * cfgReqInfo;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSiCfgReq
+S16 cmUnpkRgrSiCfgReq
 (
 RgrSiCfgReq func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrSiCfgReq(func, pst, mBuf)
-RgrSiCfgReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SpId spId;
    RgrCfgTransId transId;
    RgrSiCfgReqInfo *cfgReqInfo;
    
-   TRC3(cmUnpkRgrSiCfgReq)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -9322,7 +7852,7 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR050, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -9331,9 +7861,9 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR051, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo,
+   if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&cfgReqInfo,
             sizeof(RgrSiCfgReqInfo))) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -9341,12 +7871,12 @@ Buffer *mBuf;
             (ErrVal)ERGR052, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   cmMemset((U8 *)cfgReqInfo, 0, sizeof(RgrSiCfgReqInfo));
+   memset(cfgReqInfo, 0, sizeof(RgrSiCfgReqInfo));
    if (pst->selector == ODU_SELECTOR_LC) 
       if (cmUnpkRgrSiCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
-         SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, 
+         SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, 
                           sizeof(RgrSiCfgReqInfo));
          SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -9354,11 +7884,11 @@ Buffer *mBuf;
                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
                (ErrVal)ERGR053, (ErrVal)0, "Packing failed");
 #endif
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    SPutMsg(mBuf);
 
-   RETVALUE((*func)(pst, spId, transId, cfgReqInfo));
+   return ((*func)(pst, spId, transId, cfgReqInfo));
 }
 
 /***********************************************************
@@ -9376,33 +7906,26 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrSiCfgReqInfo
+S16 cmPkRgrSiCfgReqInfo
 (
 RgrSiCfgReqInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrSiCfgReqInfo(param, mBuf)
-RgrSiCfgReqInfo *param;
-Buffer *mBuf;
-#endif
 {
   /* ccpu00111328: S16 is renamed as MsgLen */
    MsgLen msgLen;
 
-   TRC3(cmPkRgrSiCfgReqInfo)
 
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
    CMCHKPK(SPkS32, param->cfgType, mBuf);
-   CMCHKPK(SPkU8, param->siId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->siId, mBuf);
 
    if(NULLP != param->pdu)
    {
       if (SFndLenMsg(param->pdu, &msgLen) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
       if (SCatMsg(mBuf, param->pdu, M1M2) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
       SPutMsg(param->pdu);
       CMCHKPK(cmPkMsgLen, msgLen, mBuf);
    }
@@ -9412,7 +7935,7 @@ Buffer *mBuf;
       CMCHKPK(cmPkMsgLen, 0, mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -9430,23 +7953,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSiCfgReqInfo
+S16 cmUnpkRgrSiCfgReqInfo
 (
 RgrSiCfgReqInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrSiCfgReqInfo(param, mBuf)
-RgrSiCfgReqInfo *param;
-Buffer *mBuf;
-#endif
 {
    MsgLen  msgLen, totalMsgLen;
    /*Merge from Mohit Changes*/
    S32    cfgType;
 
-   TRC3(cmUnpkRgrSiCfgReqInfo)
 
    SFndLenMsg(mBuf, &msgLen);
    if(msgLen > 0)
@@ -9456,9 +7972,9 @@ Buffer *mBuf;
       if(msgLen > 0)
       {
          if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
-            RETVALUE(RFAILED);
+            return RFAILED;
          if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->pdu) != ROK)
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
       else
       {
@@ -9466,14 +7982,14 @@ Buffer *mBuf;
       }
    }
 
-   CMCHKUNPK(SUnpkU8, &param->siId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->siId, mBuf);
    /*CMCHKUNPK(SUnpkS32, (S32 *)&param->cfgType, mBuf);*/
    /*Merge from Mohit Changes*/
    CMCHKUNPK(SUnpkS32,(S32 *)&cfgType, mBuf);
    param->cfgType = (RgrSiCfgType) cfgType;
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -9494,25 +8010,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrWarningSiCfgReq
+S16 cmPkRgrWarningSiCfgReq
 (
 Pst* pst,
 SpId spId,
 RgrCfgTransId transId,
 RgrWarningSiCfgReqInfo * warningSiCfgReqInfo
 )
-#else
-PUBLIC S16 cmPkRgrWarningSiCfgReq(pst, spId, transId, warningSiCfgReqInfo)
-Pst* pst;
-SpId spId;
-RgrCfgTransId transId;
-RgrWarningSiCfgReqInfo * warningSiCfgReqInfo;
-#endif
 {
    Buffer *mBuf = NULLP;
 
-   TRC3(cmPkRgrWarningSiCfgReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
    {
@@ -9521,9 +8028,9 @@ RgrWarningSiCfgReqInfo * warningSiCfgReqInfo;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR061, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)warningSiCfgReqInfo, 
                  sizeof(RgrWarningSiCfgReqInfo));
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (cmPkRgrWarningSiCfgReqInfo(pst, warningSiCfgReqInfo, mBuf) != ROK) 
@@ -9533,10 +8040,10 @@ RgrWarningSiCfgReqInfo * warningSiCfgReqInfo;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR062, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)warningSiCfgReqInfo, 
                 sizeof(RgrWarningSiCfgReqInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) 
@@ -9546,10 +8053,10 @@ RgrWarningSiCfgReqInfo * warningSiCfgReqInfo;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR063, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)warningSiCfgReqInfo, 
                sizeof(RgrWarningSiCfgReqInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (SPkS16(spId, mBuf) != ROK) 
@@ -9559,15 +8066,15 @@ RgrWarningSiCfgReqInfo * warningSiCfgReqInfo;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR064, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)warningSiCfgReqInfo, 
                sizeof(RgrWarningSiCfgReqInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    /* if the application wants to retain this structure, the below 
     * code should be removed */
-   if (SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo, 
+   if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)warningSiCfgReqInfo, 
                sizeof(RgrWarningSiCfgReqInfo)) != ROK) 
    {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -9576,11 +8083,11 @@ RgrWarningSiCfgReqInfo * warningSiCfgReqInfo;
             (ErrVal)ERGR065, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    pst->event = (Event) EVTRGRWARNINGSICFGREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }/*cmPkRgrWarningSiCfgReq*/
 
 
@@ -9600,25 +8107,17 @@ RgrWarningSiCfgReqInfo * warningSiCfgReqInfo;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrWarningSiCfgReq
+S16 cmUnpkRgrWarningSiCfgReq
 (
 RgrWarningSiCfgReq func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrWarningSiCfgReq(func, pst, mBuf)
-RgrWarningSiCfgReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SpId spId;
    RgrCfgTransId transId;
    RgrWarningSiCfgReqInfo *warningSiCfgReqInfo;
    
-   TRC3(cmUnpkRgrWarningSiCfgReq)
 
    if (SUnpkS16(&spId, mBuf) != ROK) 
    {
@@ -9628,7 +8127,7 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR066, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) 
@@ -9639,10 +8138,10 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR067, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if ((SGetSBuf(pst->region, pst->pool, (Data **)&warningSiCfgReqInfo,
+   if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&warningSiCfgReqInfo,
             sizeof(RgrWarningSiCfgReqInfo))) != ROK) 
    {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -9651,7 +8150,7 @@ Buffer *mBuf;
             (ErrVal)ERGR068, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
 
@@ -9659,7 +8158,7 @@ Buffer *mBuf;
    {
       if (cmUnpkRgrWarningSiCfgReqInfo(pst, warningSiCfgReqInfo, mBuf) != ROK) 
       {
-         SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo, 
+         SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)warningSiCfgReqInfo, 
                           sizeof(RgrWarningSiCfgReqInfo));
          SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -9667,12 +8166,12 @@ Buffer *mBuf;
                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
                (ErrVal)ERGR069, (ErrVal)0, "Packing failed");
 #endif
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    SPutMsg(mBuf);
 
-   RETVALUE((*func)(pst, spId, transId, warningSiCfgReqInfo));
+   return ((*func)(pst, spId, transId, warningSiCfgReqInfo));
 } /* cmUnpkRgrWarningSiCfgReq */
 
 
@@ -9692,31 +8191,23 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrWarningSiCfgReqInfo
+S16 cmPkRgrWarningSiCfgReqInfo
 (
 Pst *pst,
 RgrWarningSiCfgReqInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrWarningSiCfgReqInfo(pst, param, mBuf)
-Pst *pst;
-RgrWarningSiCfgReqInfo *param;
-Buffer *mBuf;
-#endif
 {
    MsgLen   msgLen;
-   U32      count;
+   uint32_t      count;
    CmLList  *node, *prevNode;
    RgrSegmentInfo   *pdu;
  
-   TRC3(cmPkRgrWarningSiCfgReqInfo)
 
-   CMCHKPK(SPkU8, param->emtcEnable, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->emtcEnable, mBuf);
 
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   CMCHKPK(SPkU8, param->siId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->siId, mBuf);
 
    count = param->siPduLst.count;
    node = param->siPduLst.last;
@@ -9727,20 +8218,20 @@ Buffer *mBuf;
       if(NULLP != pdu)
       {
          if (SFndLenMsg(pdu->pdu, &msgLen) != ROK)
-            RETVALUE(RFAILED);
+            return RFAILED;
          if (SCatMsg(mBuf, pdu->pdu, M1M2) != ROK)
-            RETVALUE(RFAILED);
+            return RFAILED;
          /* The PDU is not Released. This has to be done by 
           * the caller of the packing function  */
          CMCHKPK(cmPkMsgLen, msgLen, mBuf);
          SPutMsg(pdu->pdu);
       }
       cmLListDelFrm(&param->siPduLst, node);
-      SPutSBuf(pst->region, pst->pool, (Data *)node, sizeof(RgrSegmentInfo));
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)node, sizeof(RgrSegmentInfo));
       node= prevNode;
    }
-   CMCHKPK(SPkU32, count, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt32, count, mBuf);
+   return ROK;
 }
 
 
@@ -9759,34 +8250,26 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrWarningSiCfgReqInfo
+S16 cmUnpkRgrWarningSiCfgReqInfo
 (
 Pst *pst,
 RgrWarningSiCfgReqInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrWarningSiCfgReqInfo(pst, param, mBuf)
-Pst *pst;
-RgrWarningSiCfgReqInfo *param;
-Buffer *mBuf;
-#endif
 {
    MsgLen   msgLen, totalMsgLen;
-   U32      count, loopCnt;
+   uint32_t      count, loopCnt;
    Buffer   *pdu;
    CmLList  *node;
 
-   TRC3(cmUnpkRgrWarningSiCfgReqInfo)
 
    cmLListInit(&param->siPduLst);
-   CMCHKUNPK(SUnpkU32, &count, mBuf);
+   CMCHKUNPK(oduPackUInt32, &count, mBuf);
    for (loopCnt=0; loopCnt<count; loopCnt++) 
    {
       if(SFndLenMsg(mBuf, &msgLen) != ROK)
       {
-         RETVALUE(RFAILED);
+         return RFAILED;
       } 
 
       if(msgLen > 0)
@@ -9794,29 +8277,29 @@ Buffer *mBuf;
          CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
          if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
          { 
-            RETVALUE(RFAILED);
+            return RFAILED;
          }   
          if (SSegMsg(mBuf, totalMsgLen-msgLen, &pdu) != ROK)
          {		 
-            RETVALUE(RFAILED);
+            return RFAILED;
          }   
       }
       else
       {
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
-      if ((SGetSBuf(pst->region, pst->pool, (Data **)&node,
+      if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&node,
                   sizeof(CmLList))) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
       node->node = (PTR)pdu;
       cmLListAdd2Tail(&param->siPduLst, node);
    }
 
-   CMCHKUNPK(SUnpkU8, &param->siId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->siId, mBuf);
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
-   CMCHKPK(SUnpkU8, &param->emtcEnable, mBuf);
+   CMCHKPK(oduPackUInt8, &param->emtcEnable, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -9832,25 +8315,16 @@ Buffer *mBuf;
 *
 *     File  : 
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrWarningSiStopReq
+S16 cmPkRgrWarningSiStopReq
 (
 Pst           *pst,
 SpId          spId,
 RgrCfgTransId transId,
-U8            siId
+uint8_t            siId
 )
-#else
-PUBLIC S16 cmPkRgrWarningSiStopReq(pst,spId, transId, siId)
-Pst           *pst;
-SpId          spId;
-RgrCfgTransId transId;
-U8            siId;
-#endif
 {
    Buffer *mBuf = NULLP;
 
-   TRC3(cmPkRgrWarningSiStopReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
    {
@@ -9859,10 +8333,10 @@ U8            siId;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR070, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   CMCHKPK(SPkU8, siId, mBuf);
+   CMCHKPK(oduUnpackUInt8, siId, mBuf);
 
  
    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) 
@@ -9873,7 +8347,7 @@ U8            siId;
          (ErrVal)ERGR082, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
 
@@ -9885,11 +8359,11 @@ U8            siId;
             (ErrVal)ERGR071, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    pst->event = (Event) EVTRGRWARNINGSISTOPREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }/*cmPkRgrWarningSiStopReq */
 
 
@@ -9905,25 +8379,17 @@ U8            siId;
 *
 *     File  : 
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrWarningSiStopReq
+S16 cmUnpkRgrWarningSiStopReq
 (
 RgrWarningSiStopReq func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrWarningSiStopReq(param, mBuf)
-RgrWarningSiStopReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SpId          spId;
-   U8            siId;
+   uint8_t            siId;
    RgrCfgTransId transId;
 
-   TRC3(cmUnpkRgrWarningSiStopReq)
 
   if (SUnpkS16(&spId, mBuf) != ROK)
   {
@@ -9933,7 +8399,7 @@ Buffer *mBuf;
            __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
            (ErrVal)ERGR072, (ErrVal)0, "Packing failed");
 #endif
-     RETVALUE(RFAILED);
+     return RFAILED;
   }
 
     if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) 
@@ -9944,14 +8410,14 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR083, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
  
-   CMCHKUNPK(SUnpkU8, &siId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &siId, mBuf);
 
    SPutMsg(mBuf);
 
-   RETVALUE((*func)(pst, spId, transId, siId));
+   return ((*func)(pst, spId, transId, siId));
 } /*cmUnpkRgrWarningSiStopReq */
 
 
@@ -9970,27 +8436,17 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrWarningSiCfgCfm
+S16 cmPkRgrWarningSiCfgCfm
 (
 Pst*          pst,
 SuId          suId,
 RgrCfgTransId transId,
-U8            siId,
-U8            status
+uint8_t            siId,
+uint8_t            status
 )
-#else
-PUBLIC S16 cmPkRgrWarningSiCfgCfm(pst, suId, transId, siId, status)
-Pst*          pst;
-SuId          suId;
-RgrCfgTransId transId;
-U8            siId;
-U8            status;
-#endif
 {
    Buffer *mBuf = NULLP;
 
-   TRC3(cmPkRgrWarningSiCfgCfm)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
    {
@@ -9999,10 +8455,10 @@ U8            status;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR073, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if (SPkU8(status, mBuf) != ROK)
+   if (oduUnpackUInt8(status, mBuf) != ROK)
    {
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -10010,10 +8466,10 @@ U8            status;
          (ErrVal)ERGR074, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if (SPkU8(siId, mBuf) != ROK)
+   if (oduUnpackUInt8(siId, mBuf) != ROK)
    {
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -10021,7 +8477,7 @@ U8            status;
          (ErrVal)ERGR075, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) 
@@ -10032,7 +8488,7 @@ U8            status;
          (ErrVal)ERGR076, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (SPkS16(suId, mBuf) != ROK)
@@ -10043,11 +8499,11 @@ U8            status;
          (ErrVal)ERGR077, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    pst->event = (Event) EVTRGRWARNINGSICFGCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 } /* cmPkRgrWarningSiCfgCfm */
 
 
@@ -10066,26 +8522,18 @@ U8            status;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrWarningSiCfgCfm
+S16 cmUnpkRgrWarningSiCfgCfm
 (
 RgrWarningSiCfgCfm func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrWarningSiCfgCfm(func, pst, mBuf)
-RgrWarningSiCfgCfm func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SuId          suId;
-   U8            siId;
+   uint8_t            siId;
    RgrCfgTransId transId;
-   U8            status;
+   uint8_t            status;
 
-   TRC3(cmUnpkRgrWarningSiCfgCfm)
 
    if (SUnpkS16(&suId, mBuf) != ROK) 
    {
@@ -10095,7 +8543,7 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR078, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) 
@@ -10106,10 +8554,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR079, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if (SUnpkU8(&siId, mBuf) != ROK) 
+   if (oduPackUInt8(&siId, mBuf) != ROK) 
    {
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -10117,10 +8565,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR080, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if (SUnpkU8(&status, mBuf) != ROK) 
+   if (oduPackUInt8(&status, mBuf) != ROK) 
    {
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -10128,10 +8576,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR081, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, transId, siId, status));
+   return ((*func)(pst, suId, transId, siId, status));
 }/* cmUnpkRgrwarningSiCfgCfm */
 #endif/*RGR_SI_SCH*/
 
@@ -10152,25 +8600,16 @@ Buffer *mBuf;
 *     File  :
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrLoadInfReq
+S16 cmPkRgrLoadInfReq
 (
 Pst* pst,
 SpId spId,
 RgrCfgTransId transId,
 RgrLoadInfReqInfo * loadInfReq
 )
-#else
-PUBLIC S16 cmPkRgrLoadInfReq(pst, spId, transId, loadInfReq)
-Pst* pst;
-SpId spId;
-RgrCfgTransId transId;
-RgrLoadInfReqInfo * loadInfReq;
-#endif
 {
    Buffer *mBuf = NULLP;
 
-   TRC3(cmPkRgrLoadInfReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
    {
@@ -10179,9 +8618,9 @@ RgrLoadInfReqInfo * loadInfReq;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR045, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfReq, 
                  sizeof(RgrLoadInfReqInfo));
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmPkRgrLoadInfReqInfo(loadInfReq, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -10189,10 +8628,10 @@ RgrLoadInfReqInfo * loadInfReq;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR046, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfReq, 
                 sizeof(RgrLoadInfReqInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -10200,10 +8639,10 @@ RgrLoadInfReqInfo * loadInfReq;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR047, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfReq, 
                sizeof(RgrLoadInfReqInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(spId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -10211,12 +8650,12 @@ RgrLoadInfReqInfo * loadInfReq;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR048, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfReq, 
                sizeof(RgrLoadInfReqInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq, 
+   if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfReq, 
                sizeof(RgrLoadInfReqInfo)) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -10224,11 +8663,11 @@ RgrLoadInfReqInfo * loadInfReq;
             (ErrVal)ERGR049, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    pst->event = (Event) EVTRGRLOADINFREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 /***********************************************************
@@ -10247,25 +8686,17 @@ RgrLoadInfReqInfo * loadInfReq;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLoadInfReq
+S16 cmUnpkRgrLoadInfReq
 (
 RgrLoadInfReq func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrLoadInfReq(func, pst, mBuf)
-RgrLoadInfReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SpId spId;
    RgrCfgTransId transId;
    RgrLoadInfReqInfo *loadInfReq;
    
-   TRC3(cmUnpkRgrLoadInfReq)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -10274,7 +8705,7 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR050, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
@@ -10284,10 +8715,10 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR051, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if ((SGetSBuf(pst->region, pst->pool, (Data **)&loadInfReq,
+   if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&loadInfReq,
             sizeof(RgrLoadInfReqInfo))) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -10295,14 +8726,14 @@ Buffer *mBuf;
             (ErrVal)ERGR052, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   cmMemset((U8 *)loadInfReq, 0, sizeof(RgrLoadInfReqInfo));
+   memset(loadInfReq, 0, sizeof(RgrLoadInfReqInfo));
 
    if (pst->selector == ODU_SELECTOR_LC) 
       if (cmUnpkRgrLoadInfReqInfo(loadInfReq, mBuf) != ROK) {
-         SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq, 
+         SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfReq, 
                           sizeof(RgrLoadInfReqInfo));
          SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -10310,11 +8741,11 @@ Buffer *mBuf;
                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
                (ErrVal)ERGR053, (ErrVal)0, "Packing failed");
 #endif
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    SPutMsg(mBuf);
 
-   RETVALUE((*func)(pst, spId, transId, loadInfReq));
+   return ((*func)(pst, spId, transId, loadInfReq));
 }
 
 /***********************************************************
@@ -10332,25 +8763,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrLoadInfReqInfo
+S16 cmPkRgrLoadInfReqInfo
 (
 RgrLoadInfReqInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrLoadInfReqInfo(param, mBuf)
-RgrLoadInfReqInfo *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmPkRgrLoadInfReqInfo)
 
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   CMCHKPK(SPkU8, param->rgrCcPHighStartRb, mBuf);
-   CMCHKPK(SPkU8, param->rgrCcPHighEndRb, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->rgrCcPHighStartRb, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->rgrCcPHighEndRb, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -10368,25 +8792,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLoadInfReqInfo
+S16 cmUnpkRgrLoadInfReqInfo
 (
 RgrLoadInfReqInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrLoadInfReqInfo(param, mBuf)
-RgrLoadInfReqInfo *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmUnpkRgrLoadInfReqInfo)
 
-   CMCHKUNPK(SUnpkU8, &param->rgrCcPHighEndRb, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->rgrCcPHighStartRb, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->rgrCcPHighEndRb, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->rgrCcPHighStartRb, mBuf);
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 /* LTE_ADV_FLAG_REMOVED_END */
 
@@ -10409,23 +8826,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeCqiReptCfg
+S16 cmPkRgrUeCqiReptCfg
 (
 RgrUeCqiReptCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeCqiReptCfg(param, mBuf)
-RgrUeCqiReptCfg *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmPkRgrUeCqiReptCfg)
 
-   CMCHKPK(SPkU8, param->numColltdCqiRept, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numColltdCqiRept, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -10445,23 +8855,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeCqiReptCfg
+S16 cmUnpkRgrUeCqiReptCfg
 (
 RgrUeCqiReptCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeCqiReptCfg(param, mBuf)
-RgrUeCqiReptCfg *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmUnpkRgrUeCqiReptCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->numColltdCqiRept, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numColltdCqiRept, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -10481,22 +8884,14 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrStaInd
+S16 cmPkRgrStaInd
 (
 Pst* pst,
 SuId suId,
 RgrStaIndInfo* staInd
 )
-#else
-PUBLIC S16 cmPkRgrStaInd(pst, suId, staInd)
-Pst* pst;
-SuId suId;
-RgrStaIndInfo* staInd;
-#endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkRgrStaInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
    {
@@ -10505,9 +8900,9 @@ RgrStaIndInfo* staInd;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR054, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)staInd, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd, 
                sizeof(RgrStaIndInfo));
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (cmPkRgrStaIndInfo(staInd, mBuf) != ROK) 
@@ -10517,9 +8912,9 @@ RgrStaIndInfo* staInd;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR055, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)staInd, sizeof(RgrStaIndInfo));
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd, sizeof(RgrStaIndInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    
    if (SPkS16(suId, mBuf) != ROK) 
@@ -10529,13 +8924,13 @@ RgrStaIndInfo* staInd;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR056, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)staInd, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd, 
                   sizeof(RgrStaIndInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if (SPutSBuf(pst->region, pst->pool, (Data *)staInd, 
+   if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd, 
                   sizeof(RgrStaIndInfo)) != ROK) 
    {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -10544,11 +8939,11 @@ RgrStaIndInfo* staInd;
          (ErrVal)ERGR057, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    pst->event = (Event) EVTRGRSTAIND;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 /*rgr_c_001.main_9 ADD added changes for CQI management*/
@@ -10566,24 +8961,16 @@ RgrStaIndInfo* staInd;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrStaInd
+S16 cmUnpkRgrStaInd
 (
 RgrStaInd func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrStaInd(func, pst, mBuf)
-RgrStaInd func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SuId suId;
    RgrStaIndInfo *staInd;
 
-   TRC3(cmUnpkRgrStaInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK)
    {
@@ -10593,10 +8980,10 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR058, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if ((SGetSBuf(pst->region, pst->pool, (Data **)&staInd,
+   if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&staInd,
                  sizeof(RgrStaIndInfo))) != ROK)
    {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -10605,12 +8992,12 @@ Buffer *mBuf;
             (ErrVal)ERGR059, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
 
    if (cmUnpkRgrStaIndInfo(staInd, mBuf) != ROK)
    {
-      SPutSBuf(pst->region, pst->pool, (Data *)staInd,
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd,
              sizeof(RgrStaIndInfo));
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -10618,11 +9005,11 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR060, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, staInd));
+   return ((*func)(pst, suId, staInd));
 }
 
 /*rgr_c_001.main_9 ADD added changes for CQI management*/
@@ -10640,26 +9027,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrStaIndInfo
+S16 cmPkRgrStaIndInfo
 (
 RgrStaIndInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrStaIndInfo(param, mBuf)
-RgrStaIndInfo *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrStaIndInfo)
 
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
    CMCHKPK(cmPkRgrUeCqiInfo, &param->ueCqiInfo, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 /*rgr_c_001.main_9 ADD added changes for CQI management*/
 /***********************************************************
@@ -10676,26 +9056,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrStaIndInfo
+S16 cmUnpkRgrStaIndInfo
 (
 RgrStaIndInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrStaIndInfo(param, mBuf)
-RgrStaIndInfo *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrStaIndInfo)
 
    CMCHKUNPK(cmUnpkRgrUeCqiInfo, &param->ueCqiInfo, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 /*rgr_c_001.main_9 ADD added changes for CQI management*/
 /***********************************************************
@@ -10712,29 +9085,22 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeCqiInfo
+S16 cmPkRgrUeCqiInfo
 (
 RgrUeCqiInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeCqiInfo(param, mBuf)
-RgrUeCqiInfo *param;
-Buffer *mBuf;
-#endif
 {
 
    S16 idx;
-   TRC3(cmPkRgrUeCqiInfo)
 
    for (idx = param->numCqiRept - 1; idx >= 0; idx--)
    {
       CMCHKPK(cmPkRgrUeCqiRept, &param->cqiRept[idx], mBuf);
    }
-   CMCHKPK(SPkU8, param->numCqiRept, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numCqiRept, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmPkRgrUeCqiInfo */
 
 /*rgr_c_001.main_9 ADD added changes for CQI management*/
@@ -10752,29 +9118,22 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeCqiInfo
+S16 cmUnpkRgrUeCqiInfo
 (
 RgrUeCqiInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeCqiInfo(param, mBuf)
-RgrUeCqiInfo *param;
-Buffer *mBuf;
-#endif
 {
 
-   U8  idx;
-   TRC3(cmUnpkRgrUeCqiInfo)
+   uint8_t  idx;
 
-   CMCHKUNPK(SUnpkU8, &param->numCqiRept, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numCqiRept, mBuf);
    for (idx = 0; idx < param->numCqiRept; idx++)
    {
       CMCHKUNPK(cmUnpkRgrUeCqiRept, &param->cqiRept[idx], mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmUnpkRgrUeCqiInfo */
 
 /***********************************************************
@@ -10791,26 +9150,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrSubBandCqiInfo 
+S16 cmPkRgrSubBandCqiInfo 
 (
 RgrSubBandCqiInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrSubBandCqiInfo(param, mBuf)
-RgrSubBandCqiInfo *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrSubBandCqiInfo)
 
-   CMCHKPK(SPkU8, param->cqi[0], mBuf);
-   CMCHKPK(SPkU8, param->cqi[1], mBuf);
-   CMCHKPK(SPkU8, param->subBandIdx, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
+   CMCHKPK(oduUnpackUInt8, param->cqi[1], mBuf);
+   CMCHKPK(oduUnpackUInt8, param->subBandIdx, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmPkRgrSubBandCqiInfo */
 
 /*rgr_c_001.main_9 ADD added changes for CQI management*/
@@ -10828,33 +9180,26 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeCqiRept
+S16 cmPkRgrUeCqiRept
 (
 RgrUeCqiRept *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeCqiRept(param, mBuf)
-RgrUeCqiRept *param;
-Buffer *mBuf;
-#endif
 {
    S8 idx;
-   U8 count;
+   uint8_t count;
 
-   TRC3(cmPkRgrUeCqiRept)
 
-   CMCHKPK(SPkU8, param->cqi[0], mBuf);
-   CMCHKPK(SPkU8, param->cqi[1], mBuf);
-   CMCHKPK(SPkU8, param->cqiMode, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
+   CMCHKPK(oduUnpackUInt8, param->cqi[1], mBuf);
+   CMCHKPK(oduUnpackUInt8, param->cqiMode, mBuf);
    for (idx = param->numSubBand - 1; idx >= 0; idx--)
    {
       count = idx;
       CMCHKPK(cmPkRgrSubBandCqiInfo, &param->sbCqiInfo[count], mBuf);
    }
-   CMCHKPK(SPkU8, param->numSubBand, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->numSubBand, mBuf);
+   return ROK;
 } /* cmPkRgrUeCqiRept */
 
 /***********************************************************
@@ -10871,26 +9216,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSubBandCqiInfo 
+S16 cmUnpkRgrSubBandCqiInfo 
 (
 RgrSubBandCqiInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrSubBandCqiInfo(param, mBuf)
-RgrSubBandCqiInfo *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrSubBandCqiInfo)
 
-   CMCHKUNPK(SUnpkU8, &param->subBandIdx, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->cqi[1], mBuf);
-   CMCHKUNPK(SUnpkU8, &param->cqi[0], mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->subBandIdx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cqi[1], mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cqi[0], mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmUnpkRgrSubBandCqiInfo*/
 
 /*rgr_c_001.main_9 ADD added changes for CQI management*/
@@ -10908,31 +9246,24 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeCqiRept
+S16 cmUnpkRgrUeCqiRept
 (
 RgrUeCqiRept *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeCqiRept(param, mBuf)
-RgrUeCqiRept *param;
-Buffer *mBuf;
-#endif
 {
-   U8 idx;
+   uint8_t idx;
 
-   TRC3(cmUnpkRgrUeCqiRept)
-   CMCHKUNPK(SUnpkU8, &param->numSubBand, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numSubBand, mBuf);
    for (idx = 0; idx < param->numSubBand; idx++)
    {
       CMCHKUNPK(cmUnpkRgrSubBandCqiInfo, &param->sbCqiInfo[idx], mBuf);
    }
-   CMCHKUNPK(SUnpkU8, &param->cqiMode, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->cqi[1], mBuf);
-   CMCHKUNPK(SUnpkU8, &param->cqi[0], mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cqiMode, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cqi[1], mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cqi[0], mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmUnpkRgrUeCqiRept */
 #endif /* End of ifdef RGR_CQI_REPT */
 
@@ -10952,22 +9283,14 @@ Buffer *mBuf;
 *     File  :
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrLoadInfInd
+S16 cmPkRgrLoadInfInd
 (
 Pst* pst,
 SuId suId,
 RgrLoadInfIndInfo* loadInfInd
 )
-#else
-PUBLIC S16 cmPkRgrLoadInfInd(pst, suId, loadInfInd)
-Pst* pst;
-SuId suId;
-RgrLoadInfIndInfo* loadInfInd;
-#endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkRgrLoadInfInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
    {
@@ -10976,9 +9299,9 @@ RgrLoadInfIndInfo* loadInfInd;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR054, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
             sizeof(RgrLoadInfIndInfo));
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (cmPkRgrLoadInfIndInfo(loadInfInd, mBuf) != ROK)
@@ -10988,11 +9311,11 @@ RgrLoadInfIndInfo* loadInfInd;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR055, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
             sizeof(RgrLoadInfIndInfo));
       SPutMsg(mBuf);
 
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (SPkS16(suId, mBuf) != ROK)
@@ -11002,13 +9325,13 @@ RgrLoadInfIndInfo* loadInfInd;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR056, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
             sizeof(RgrLoadInfIndInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if (SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
+   if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
                   sizeof(RgrLoadInfIndInfo)) != ROK)
    {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -11017,11 +9340,11 @@ RgrLoadInfIndInfo* loadInfInd;
             (ErrVal)ERGR057, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    pst->event = (Event) EVTRGRLOADINFIND;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 /***********************************************************
@@ -11038,24 +9361,16 @@ RgrLoadInfIndInfo* loadInfInd;
 *     File  :
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLoadInfInd
+S16 cmUnpkRgrLoadInfInd
 (
 RgrLoadInfInd func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrLoadInfInd(func, pst, mBuf)
-RgrLoadInfInd func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SuId suId;
    RgrLoadInfIndInfo *loadInfInd = NULLP; /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
 
-   TRC3(cmUnpkRgrLoadInfInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK)
    {
@@ -11065,10 +9380,10 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR058, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if ((SGetSBuf(pst->region, pst->pool, (Data **)&loadInfInd,
+   if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&loadInfInd,
                  sizeof(RgrLoadInfIndInfo))) != ROK)
    {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -11077,13 +9392,13 @@ Buffer *mBuf;
             (ErrVal)ERGR059, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
 
    /* dsfr_pal_fixes ** 22-March-2013 ** SKS */
    if (cmUnpkRgrLoadInfIndInfo(loadInfInd, pst, mBuf) != ROK)
    {
-      SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
              sizeof(RgrLoadInfIndInfo));
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -11091,11 +9406,11 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR060, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, loadInfInd));
+   return ((*func)(pst, suId, loadInfInd));
 }
 
 
@@ -11113,28 +9428,21 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrLoadInfIndInfo
+S16 cmPkRgrLoadInfIndInfo
 (
 RgrLoadInfIndInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrLoadInfIndInfo(param, mBuf)
-RgrLoadInfIndInfo *param;
-Buffer *mBuf;
-#endif
 {
-   U8                     idx;
-   TRC3(cmPkRgrLoadInfIndInfo)
+   uint8_t                     idx;
 
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   CMCHKPK(SPkU16, param->bw, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->bw, mBuf);
    if(RGR_ABS == param->type)
    {
       for(idx = 0; idx < RGR_ABS_PATTERN_LEN; idx++)
       {
-         CMCHKPK(SPkU32, param->u.absLoadInfo[idx], mBuf);
+         CMCHKPK(oduUnpackUInt32, param->u.absLoadInfo[idx], mBuf);
       }
    }
    else
@@ -11142,9 +9450,9 @@ Buffer *mBuf;
       CMCHKPK(cmPkTknStrOSXL, &param->u.rntpInfo, mBuf);
    }
 
-   CMCHKPK(SPkU32, param->type, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->type, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -11161,34 +9469,26 @@ Buffer *mBuf;
 *     File  :
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLoadInfIndInfo
+S16 cmUnpkRgrLoadInfIndInfo
 (
 RgrLoadInfIndInfo *param,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrLoadInfIndInfo(param, pst, mBuf)
-RgrLoadInfIndInfo *param;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    S8          idx;
 
    /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
    TknStrOSXL  *tknStr;
-   U16         ndx;
+   uint16_t         ndx;
 
-   TRC3(cmUnpkRgrLoadInfIndInfo)
 
-   CMCHKUNPK(SUnpkU32, &param->type, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->type, mBuf);
    if(RGR_ABS == param->type)
    {
       for(idx = RGR_ABS_PATTERN_LEN -1 ; idx >= 0; idx--)
       {
-         CMCHKUNPK(SUnpkU32, &param->u.absLoadInfo[(U8)idx], mBuf);
+         CMCHKUNPK(oduPackUInt32, &param->u.absLoadInfo[(uint8_t)idx], mBuf);
       }
    }
    else
@@ -11197,38 +9497,38 @@ Buffer *mBuf;
       /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** Start */
       tknStr = &param->u.rntpInfo;
 
-      CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+      CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
 
       if(tknStr->pres)
       {
          /* Length */
-         CMCHKUNPK(SUnpkU16, &tknStr->len, mBuf);
+         CMCHKUNPK(oduPackUInt16, &tknStr->len, mBuf);
 
-         if ((SGetSBuf(pst->region, pst->pool, (Data **)&tknStr->val,tknStr->len)) != ROK) {
+         if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&tknStr->val,tknStr->len)) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
                (ErrVal)ERGR052, (ErrVal)0, "Packing failed");
 #endif
             SPutMsg(mBuf);
-            RETVALUE(RFAILED);
+            return RFAILED;
          }
 
          /* Value */
          for (ndx = 1; ndx <= tknStr->len; ndx++)
          {
-            CMCHKUNPK(SUnpkU8, &tknStr->val[tknStr->len - ndx], mBuf);
+            CMCHKUNPK(oduPackUInt8, &tknStr->val[tknStr->len - ndx], mBuf);
          }
       }
    }
    /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** End */
 
    /* dsfr_pal_fixes ** 22-March-2013 ** SKS */
-   CMCHKUNPK(SUnpkU16, &param->bw, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->bw, mBuf);
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 /* LTE_ADV_FLAG_REMOVED_END */
 
@@ -11249,27 +9549,20 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUepACfg
+S16 cmPkRgrUepACfg
 (
 RgrUepACfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUepACfg(param, mBuf)
-RgrUepACfg *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmPkRgrUepACfg)
 
    if(param->pAPrsnt)
    {
-      CMCHKPK(SPkU32, param->pA, mBuf);
+      CMCHKPK(oduUnpackUInt32, param->pA, mBuf);
    }
-   CMCHKPK(SPkU8, param->pAPrsnt, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pAPrsnt, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -11289,29 +9582,22 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUepACfg
+S16 cmUnpkRgrUepACfg
 (
 RgrUepACfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUepACfg(param, mBuf)
-RgrUepACfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
-   TRC3(cmUnpkRgrUepACfg)
+   uint32_t tmpEnum;
 
-   CMCHKUNPK(SUnpkU8, (U8 *)&param->pAPrsnt, mBuf);
+   CMCHKUNPK(oduPackUInt8, (uint8_t *)&param->pAPrsnt, mBuf);
    if (param->pAPrsnt)
    {
-      CMCHKUNPK(SUnpkU32, (U32*)&tmpEnum, mBuf);
+      CMCHKUNPK(oduPackUInt32, (uint32_t*)&tmpEnum, mBuf);
       param->pA = (RgrUeDlPwrCntrlPaCfg) tmpEnum;
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /*rgr_c_001.main_9 ADD PDSCH ded cfg*/
@@ -11330,23 +9616,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUePdschDedCfg
+S16 cmPkRgrUePdschDedCfg
 (
 RgrUePdschDedCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUePdschDedCfg(param, mBuf)
-RgrUePdschDedCfg *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmPkRgrUePdschDedCfg)
 
    CMCHKPK(cmPkRgrUepACfg, &param->uepACfg, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -11366,23 +9645,16 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUePdschDedCfg
+S16 cmUnpkRgrUePdschDedCfg
 (
 RgrUePdschDedCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUePdschDedCfg(param, mBuf)
-RgrUePdschDedCfg *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmUnpkRgrUePdschDedCfg)
 
    CMCHKUNPK(cmUnpkRgrUepACfg, &param->uepACfg, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 #endif
 
@@ -11404,25 +9676,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PRIVATE S16 cmPkRgrUeUlPwrDedSCellCfg
+static S16 cmPkRgrUeUlPwrDedSCellCfg
 (
 RgrUeUlPwrDedSCellCfg *param,
 Buffer *mBuf
 )
-#else
-PRIVATE S16 cmPkRgrUeUlPwrDedSCellCfg(param, mBuf)
-RgrUeUlPwrDedSCellCfg *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmPkRgrUeUlPwrDedSCellCfg)
-   CMCHKPK(SPkU8, param->pSRSOffset, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->pSRSOffset, mBuf);
    CMCHKPK(SPkS8, param->p0UePusch, mBuf);
-   CMCHKPK(SPkU8, param->isDeltaMCSEnabled, mBuf);
-   CMCHKPK(SPkU8, param->isAccumulated, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isDeltaMCSEnabled, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isAccumulated, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -11440,26 +9705,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PRIVATE S16 cmUnpkRgrUeUlPwrDedSCellCfg
+static S16 cmUnpkRgrUeUlPwrDedSCellCfg
 (
 RgrUeUlPwrDedSCellCfg *param,
 Buffer *mBuf
 )
-#else
-PRIVATE S16 cmUnpkRgrUeUlPwrDedSCellCfg(param, mBuf)
-RgrUeUlPwrDedSCellCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeUlPwrDedSCellCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->isAccumulated, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isDeltaMCSEnabled, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isAccumulated, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isDeltaMCSEnabled, mBuf);
    CMCHKUNPK(SUnpkS8, &param->p0UePusch, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->pSRSOffset, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->pSRSOffset, mBuf);
+   return ROK;
 }
 
 
@@ -11480,31 +9738,25 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PRIVATE S16 cmPkRgrUeSecCellCfg
+static S16 cmPkRgrUeSecCellCfg
 (
 RgrUeSecCellCfg *param,
 Buffer *mBuf
 )
-#else
-PRIVATE S16 cmPkRgrUeSecCellCfg(param, mBuf)
-RgrUeSecCellCfg *param;
-Buffer *mBuf;
-#endif
 {
    CMCHKPK(cmPkRgrUeUlPwrDedSCellCfg,&param->ueSCellUlDedPwrCfg, mBuf);
-   CMCHKPK(SPkU8, param->isUlCaEnabled, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isUlCaEnabled, mBuf);
    CMCHKPK(cmPkRgrUeTxModeCfg, &param->txMode, mBuf);
 #ifdef TFU_UPGRADE
 /*rgr_c_001.main_9 ADD PDSCH ded cfg*/
    CMCHKPK(cmPkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
 #endif
    CMCHKPK(cmPkRgrUeDlCqiCfg,&param->ueSCellDlCqiCfg, mBuf);
-   CMCHKPK(cmPkTknU32, &param->sCellDeActTmr, mBuf);
-   CMCHKPK(SPkU16, param->sCellId, mBuf);
-   CMCHKPK(SPkU8, param->sCellIdx, mBuf);
+   CMCHKPK(cmPkTknUInt32, &param->sCellDeActTmr, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -11524,29 +9776,23 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSecCellInfo
+S16 cmPkRgrUeSecCellInfo
 (
 RgrUeSecCellInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeSecCellInfo(param, mBuf)
-RgrUeSecCellInfo *param;
-Buffer *mBuf;
-#endif
 {
    S8 idx;
    for(idx = param->numSCells - 1; idx >= 0; idx--)
    {
-      CMCHKPK(cmPkRgrUeSecCellCfg, &param->ueSCellDedCfg[(U8)idx],mBuf);
+      CMCHKPK(cmPkRgrUeSecCellCfg, &param->ueSCellDedCfg[(uint8_t)idx],mBuf);
    }
 
-   CMCHKPK(SPkU8, param->numSCells, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
 
-   CMCHKPK(SPkU8, param->useExtBSRSizes, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->useExtBSRSizes, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -11565,30 +9811,24 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PRIVATE S16 cmUnpkRgrUeSecCellCfg
+static S16 cmUnpkRgrUeSecCellCfg
 (
 RgrUeSecCellCfg *param,
 Buffer *mBuf
 )
-#else
-PRIVATE S16 cmUnpkRgrUeSecCellCfg(param, mBuf)
-RgrUeSecCellCfg *param;
-Buffer *mBuf;
-#endif
 {
-   CMCHKUNPK(SUnpkU8, &param->sCellIdx, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->sCellId, mBuf);
-   CMCHKUNPK(cmUnpkTknU32, &param->sCellDeActTmr, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->sCellIdx, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->sCellId, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt32, &param->sCellDeActTmr, mBuf);
    CMCHKUNPK(cmUnpkRgrUeDlCqiCfg, &param->ueSCellDlCqiCfg, mBuf);
 #ifdef TFU_UPGRADE
    CMCHKUNPK(cmUnpkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
 #endif
    CMCHKUNPK(cmUnpkRgrUeTxModeCfg, &param->txMode, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isUlCaEnabled, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isUlCaEnabled, mBuf);
    CMCHKUNPK(cmUnpkRgrUeUlPwrDedSCellCfg, &param->ueSCellUlDedPwrCfg, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -11609,29 +9849,23 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSecCellInfo
+S16 cmUnpkRgrUeSecCellInfo
 (
 RgrUeSecCellInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeSecCellInfo(param, mBuf)
-RgrUeSecCellInfo *param;
-Buffer *mBuf;
-#endif
 {
-   U8 idx;
+   uint8_t idx;
 
-   CMCHKUNPK(SUnpkU8, &param->useExtBSRSizes, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numSCells, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->useExtBSRSizes, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numSCells, mBuf);
 
    for(idx = 0; idx < param->numSCells;idx++)
    {
       CMCHKUNPK(cmUnpkRgrUeSecCellCfg, &param->ueSCellDedCfg[idx],mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }
 /* Sprint 3 */
 /***********************************************************
@@ -11649,56 +9883,49 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSCellAckPucchCfg
+S16 cmPkRgrUeSCellAckPucchCfg
 (
 RgrUeSCellAckPucchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeSCellAckPucchCfg(param, mBuf)
-RgrUeSCellAckPucchCfg *param;
-Buffer *mBuf;
-#endif
 {
    S8 idx;
-   TRC3(cmPkRgrUeSCellAckPucchCfg);
 
    if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS || param->pucchFormatType == RG_SCH_UCI_FORMAT1A_1B)
    { 
       for(idx = param->u.format1Bcs.sCellAckN1ResTb2Count - 1; idx >=0 ;idx--)
       {
-         CMCHKPK(SPkU16, param->u.format1Bcs.sCellAckN1ResTb2[(U8)idx], mBuf);
+         CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb2[(uint8_t)idx], mBuf);
       }
 
-      CMCHKPK(SPkU8, param->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
+      CMCHKPK(oduUnpackUInt8, param->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
 
       for(idx = param->u.format1Bcs.sCellAckN1ResTb1Count - 1; idx >=0 ;idx--)
       {
-         CMCHKPK(SPkU16, param->u.format1Bcs.sCellAckN1ResTb1[(U8)idx], mBuf);
+         CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb1[(uint8_t)idx], mBuf);
       }
 
-      CMCHKPK(SPkU8, param->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
+      CMCHKPK(oduUnpackUInt8, param->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
    }
    else
    {
       for(idx = param->u.format3.sCellAckN3ResAntP1Count - 1; idx >=0 ;idx--)
       {
-         CMCHKPK(SPkU16, param->u.format3.sCellAckN3ResAntP1[(U8)idx], mBuf);
+         CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP1[(uint8_t)idx], mBuf);
       }
 
-      CMCHKPK(SPkU8, param->u.format3.sCellAckN3ResAntP1Count, mBuf);
+      CMCHKPK(oduUnpackUInt8, param->u.format3.sCellAckN3ResAntP1Count, mBuf);
 
       for(idx = param->u.format3.sCellAckN3ResAntP0Count- 1; idx >=0 ;idx--)
       {
-         CMCHKPK(SPkU16, param->u.format3.sCellAckN3ResAntP0[(U8)idx], mBuf);
+         CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP0[(uint8_t)idx], mBuf);
       }
 
-      CMCHKPK(SPkU8, param->u.format3.sCellAckN3ResAntP0Count, mBuf);
+      CMCHKPK(oduUnpackUInt8, param->u.format3.sCellAckN3ResAntP0Count, mBuf);
    }
-   CMCHKPK(SPkU32, param->pucchFormatType, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->pucchFormatType, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -11716,58 +9943,51 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSCellAckPucchCfg
+S16 cmUnpkRgrUeSCellAckPucchCfg
 (
 RgrUeSCellAckPucchCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeSCellAckPucchCfg(param, mBuf)
-RgrUeSCellAckPucchCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U8 idx;
+   uint8_t idx;
 
-   TRC3(cmUnpkRgrUeSCellAckPucchCfg);
 
-   CMCHKUNPK(SUnpkU32, (U32*)&param->pucchFormatType, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->pucchFormatType, mBuf);
    //if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS)
    if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS || param->pucchFormatType == RG_SCH_UCI_FORMAT1A_1B)
    {
-      CMCHKUNPK(SUnpkU8, &param->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
 
       for(idx = 0; idx < param->u.format1Bcs.sCellAckN1ResTb1Count; idx++)
       {
-         CMCHKUNPK(SUnpkU16, &param->u.format1Bcs.sCellAckN1ResTb1[idx], mBuf);
+         CMCHKUNPK(oduPackUInt16, &param->u.format1Bcs.sCellAckN1ResTb1[idx], mBuf);
       }
 
-      CMCHKUNPK(SUnpkU8, &param->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
 
       for(idx = 0; idx < param->u.format1Bcs.sCellAckN1ResTb2Count; idx++)
       {
-         CMCHKUNPK(SUnpkU16, &param->u.format1Bcs.sCellAckN1ResTb2[idx], mBuf);
+         CMCHKUNPK(oduPackUInt16, &param->u.format1Bcs.sCellAckN1ResTb2[idx], mBuf);
       }
    }
    else
    {
-      CMCHKUNPK(SUnpkU8, &param->u.format3.sCellAckN3ResAntP0Count, mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->u.format3.sCellAckN3ResAntP0Count, mBuf);
 
       for(idx = 0; idx < param->u.format3.sCellAckN3ResAntP0Count; idx++)
       {
-         CMCHKUNPK(SUnpkU16, &param->u.format3.sCellAckN3ResAntP0[idx], mBuf);
+         CMCHKUNPK(oduPackUInt16, &param->u.format3.sCellAckN3ResAntP0[idx], mBuf);
       }
 
-      CMCHKUNPK(SUnpkU8, &param->u.format3.sCellAckN3ResAntP1Count, mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->u.format3.sCellAckN3ResAntP1Count, mBuf);
 
       for(idx = 0; idx < param->u.format3.sCellAckN3ResAntP1Count; idx++)
       {
-         CMCHKUNPK(SUnpkU16, &param->u.format3.sCellAckN3ResAntP1[idx], mBuf);
+         CMCHKUNPK(oduPackUInt16, &param->u.format3.sCellAckN3ResAntP1[idx], mBuf);
       }
 
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -11791,22 +10011,14 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeStaInd
+S16 cmPkRgrUeStaInd
 (
 Pst* pst,
 SuId suId,
 RgrUeStaIndInfo* ueStaInd
 )
-#else
-PUBLIC S16 cmPkRgrUeStaInd(pst, suId, ueStaInd)
-Pst* pst;
-SuId suId;
-RgrUeStaIndInfo* ueStaInd;
-#endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkRgrUeStaInd)
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
    {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -11814,9 +10026,9 @@ RgrUeStaIndInfo* ueStaInd;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR054, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd, 
                sizeof(RgrUeStaIndInfo));
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (cmPkRgrUeStaIndInfo(ueStaInd, mBuf) != ROK) 
@@ -11826,10 +10038,10 @@ RgrUeStaIndInfo* ueStaInd;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGR055, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd, 
                sizeof(RgrUeStaIndInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    
    if (SPkS16(suId, mBuf) != ROK) 
@@ -11839,13 +10051,13 @@ RgrUeStaIndInfo* ueStaInd;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR056, (ErrVal)0, "Packing failed");
 #endif
-      SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd, 
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd, 
                   sizeof(RgrUeStaIndInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if (SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd, 
+   if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd, 
                   sizeof(RgrUeStaIndInfo)) != ROK) 
    {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -11854,11 +10066,11 @@ RgrUeStaIndInfo* ueStaInd;
          (ErrVal)ERGR057, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    pst->event = (Event) EVTRGRUESTAIND;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 /*rgr_c_001.main_9 ADD added changes for CQI management*/
@@ -11876,24 +10088,16 @@ RgrUeStaIndInfo* ueStaInd;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeStaInd
+S16 cmUnpkRgrUeStaInd
 (
 RgrUeStaInd  func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeStaInd(func, pst, mBuf)
-RgrUeStaInd func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SuId suId;
    RgrUeStaIndInfo *ueStaInd;
 
-   TRC3(cmUnpkRgrUeStaInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK)
    {
@@ -11903,10 +10107,10 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR058, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if ((SGetSBuf(pst->region, pst->pool, (Data **)&ueStaInd,
+   if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&ueStaInd,
                  sizeof(RgrUeStaIndInfo))) != ROK)
    {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -11915,12 +10119,12 @@ Buffer *mBuf;
             (ErrVal)ERGR059, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
 
    if (cmUnpkRgrUeStaIndInfo(ueStaInd, mBuf) != ROK)
    {
-      SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
+      SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd,
              sizeof(RgrUeStaIndInfo));
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -11928,11 +10132,11 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGR060, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, ueStaInd));
+   return ((*func)(pst, suId, ueStaInd));
 }
 
 /***********************************************************
@@ -11949,26 +10153,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrUeStaIndInfo
+S16 cmPkRgrUeStaIndInfo
 (
 RgrUeStaIndInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrUeStaIndInfo(param, mBuf)
-RgrUeStaIndInfo *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrUeStaIndInfo)
 
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
-   CMCHKPK(SPkU8, param->status, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->status, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 /***********************************************************
 *
@@ -11984,26 +10181,19 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeStaIndInfo
+S16 cmUnpkRgrUeStaIndInfo
 (
 RgrUeStaIndInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrUeStaIndInfo(param, mBuf)
-RgrUeStaIndInfo *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrUeStaIndInfo)
 
-   CMCHKUNPK(SUnpkU8, &param->status, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->status, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -12022,25 +10212,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrCellCsgParamCfg 
+S16 cmPkRgrCellCsgParamCfg 
 (
 RgrCellCsgParamCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrCellCsgParamCfg(param, mBuf)
-RgrCellCsgParamCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmPkRgrCellCsgParamCfg)
 
-   CMCHKPK(SPkU8, param->minUlResNonCsg, mBuf);
-   CMCHKPK(SPkU8, param->minDlResNonCsg, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->minUlResNonCsg, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->minDlResNonCsg, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -12057,25 +10240,18 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCellCsgParamCfg
+S16 cmUnpkRgrCellCsgParamCfg
 (
 RgrCellCsgParamCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrCellCsgParamCfg(param, mBuf)
-RgrCellCsgParamCfg *param;
-Buffer *mBuf;
-#endif
 {
 
-   TRC3(cmUnpkRgrCellCsgParamCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->minDlResNonCsg, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->minUlResNonCsg, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->minDlResNonCsg, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->minUlResNonCsg, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -12092,35 +10268,28 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkRgrCellCntrlCmdCfg
+S16 cmPkRgrCellCntrlCmdCfg
 (
 RgrCellCntrlCmdCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmPkRgrCellCntrlCmdCfg(param, mBuf)
-RgrCellCntrlCmdCfg *param;
-Buffer *mBuf;
-#endif
 {
-   TRC3(cmPkRgrCellCntrlCmdCfg)
 
    switch(param->cmdType)
    {
       case RGR_CNTRL_CMD_RACH_OVRLD:
-         CMCHKUNPK(SPkU8, param->cmdDesc.rachOvrLd.backOffVal, mBuf);
-         CMCHKUNPK(SPkU8, param->cmdDesc.rachOvrLd.backOffEnb, mBuf);
+         CMCHKUNPK(oduUnpackUInt8, param->cmdDesc.rachOvrLd.backOffVal, mBuf);
+         CMCHKUNPK(oduUnpackUInt8, param->cmdDesc.rachOvrLd.backOffEnb, mBuf);
          break;
       case RGR_CNTRL_CMD_CPU_OVRLD:
-         CMCHKUNPK(SPkU8, param->cmdDesc.cpuOvrLd.instruction, mBuf);
+         CMCHKUNPK(oduUnpackUInt8, param->cmdDesc.cpuOvrLd.instruction, mBuf);
          break;
       default:
          break;
    }
-   CMCHKUNPK(SPkU32, param->cmdType, mBuf);
+   CMCHKUNPK(oduUnpackUInt32, param->cmdType, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 /***********************************************************
 *
@@ -12136,38 +10305,31 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCellCntrlCmdCfg
+S16 cmUnpkRgrCellCntrlCmdCfg
 (
 RgrCellCntrlCmdCfg *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 cmUnpkRgrCellCntrlCmdCfg(param, mBuf)
-RgrCellCntrlCmdCfg *param;
-Buffer *mBuf;
-#endif
 {
-   U32 tmpEnum;
+   uint32_t tmpEnum;
 
-   TRC3(cmUnpkRgrCellCntrlCmdCfg)
 
-   CMCHKUNPK(SUnpkU32, &tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt32, &tmpEnum, mBuf);
    param->cmdType = (RgrCellCntrlCmdType) tmpEnum;
    switch(param->cmdType)
    {
       case RGR_CNTRL_CMD_RACH_OVRLD:
-         CMCHKUNPK(SUnpkU8, &param->cmdDesc.rachOvrLd.backOffEnb, mBuf);
-         CMCHKUNPK(SUnpkU8, &param->cmdDesc.rachOvrLd.backOffVal, mBuf);
+         CMCHKUNPK(oduPackUInt8, &param->cmdDesc.rachOvrLd.backOffEnb, mBuf);
+         CMCHKUNPK(oduPackUInt8, &param->cmdDesc.rachOvrLd.backOffVal, mBuf);
          break;
       case RGR_CNTRL_CMD_CPU_OVRLD:
-         CMCHKUNPK(SUnpkU8, &param->cmdDesc.cpuOvrLd.instruction, mBuf);
+         CMCHKUNPK(oduPackUInt8, &param->cmdDesc.cpuOvrLd.instruction, mBuf);
          break;
       default:
          break;
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }
 #endif /* End of if defined(LCRGR) */