diff --git a/FSM_OOP/baseFSM/FSM.c b/FSM_OOP/baseFSM/FSM.c
index 7d65451..4489006 100644
--- a/FSM_OOP/baseFSM/FSM.c
+++ b/FSM_OOP/baseFSM/FSM.c
@@ -12,9 +12,9 @@
 
 void resetBaseFSM(FSM *pFSM)
 {
-    
+   
     if (pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState] != NULL)
-        pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState](pFSM);
+        pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState](pFSM->data);
 
     pFSM->privateVars.curState = 0;
 }
@@ -22,31 +22,44 @@ void resetBaseFSM(FSM *pFSM)
 void stepBaseFSM(FSM *pFSM)
 {
     int index = pFSM->privateVars.curState * pFSM->privateVars.numEvent + pFSM->privateVars.curEvent;
-    if (pFSM->privateVars.fcns.transitionTable[index] != NULL)
-    {
-        if (pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState] != NULL)
-            pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState](pFSM);
+    int curState = pFSM->privateVars.curState;
+    int nextState;
+    void *data = pFSM->data;
+    FSMHandler *fcns = &pFSM->privateVars.fcns;
 
-        pFSM->privateVars.curState = (*pFSM->privateVars.fcns.transitionTable[index])(pFSM);
-
-        if (pFSM->privateVars.fcns.enterActionTable[pFSM->privateVars.curState] != NULL)
-            pFSM->privateVars.fcns.enterActionTable[pFSM->privateVars.curState](pFSM);
+    if(fcns->delayActionTable[curState] != NULL ){
+        fcns->delayActionTable[curState](data);
     }
-    else if(pFSM->privateVars.curState == 0){
-        pFSM->privateVars.curState = pFSM->privateVars.defaultState;
-        if (pFSM->privateVars.fcns.enterActionTable[pFSM->privateVars.curState] != NULL)
-            pFSM->privateVars.fcns.enterActionTable[pFSM->privateVars.curState](pFSM);
+
+    if (fcns->transitionTable[index] != NULL)
+    {
+        if (fcns->exitActionTable[curState] != NULL)
+            fcns->exitActionTable[curState](data);
+
+        nextState = (*fcns->transitionTable[index])(data, curState);
+
+        if (fcns->enterActionTable[nextState] != NULL)
+            fcns->enterActionTable[nextState](data);
+
+        pFSM->privateVars.curState = nextState;
+    }
+    else if(curState == 0){
+        nextState = pFSM->privateVars.defaultState;
+        if (fcns->enterActionTable[nextState] != NULL)
+            fcns->enterActionTable[nextState](data);
+        pFSM->privateVars.curState = nextState;
     }
     else
     {
-        if (pFSM->privateVars.fcns.duringActionTable[pFSM->privateVars.curState] != NULL)
-            pFSM->privateVars.fcns.duringActionTable[pFSM->privateVars.curState](pFSM);
+        if (fcns->duringActionTable[curState] != NULL)
+            fcns->duringActionTable[curState](data);
     }
 }
 
 FSM*  newBaseFSM(int numState, int numEvent, int defaultState){
-    typedef void (*StateFuncPtr)(FSM* pFSM);
-    typedef int (*TransitionFuncPtr)(FSM* pFSM);
+    typedef void (*StateFuncPtr)(void *data); 
+    typedef void (*ChildFSMStepFuncPtr)(FSM **cFSM); 
+    typedef int (*TransitionFuncPtr)(void *data, int currentState);
 
     FSM *pFSM = calloc(1, sizeof(FSM));
     pFSM->privateVars.curEvent = 0;
@@ -56,9 +69,12 @@ FSM*  newBaseFSM(int numState, int numEvent, int defaultState){
     pFSM->privateVars.numChild = 0;
 
     pFSM->privateVars.fcns.duringActionTable = calloc(numState,  sizeof(StateFuncPtr));
+    pFSM->privateVars.fcns.delayActionTable = calloc(numState,  sizeof(StateFuncPtr));
     pFSM->privateVars.fcns.enterActionTable = calloc(numState, sizeof(StateFuncPtr));
     pFSM->privateVars.fcns.exitActionTable = calloc(numState, sizeof(StateFuncPtr));
+    
     pFSM->privateVars.fcns.transitionTable = calloc(numState * numEvent, sizeof(TransitionFuncPtr));
+    pFSM->privateVars.fcns.childFSMStepTable = calloc(numState * numEvent, sizeof(ChildFSMStepFuncPtr));
 
     FSMVtbl vtbl = {
         .reset = resetBaseFSM,
diff --git a/FSM_OOP/baseFSM/FSM_protected.h b/FSM_OOP/baseFSM/FSM_protected.h
index 9ff2e41..9a0c155 100644
--- a/FSM_OOP/baseFSM/FSM_protected.h
+++ b/FSM_OOP/baseFSM/FSM_protected.h
@@ -3,15 +3,20 @@
 
 #include "FSM_public.h"
 
-#define     NDEBUG
-// #define     FSM_LOG_ON
+#ifdef      DSP28377
+    #define     NDEBUG
+#else
+    #define     FSM_LOG_ON
+#endif
+
+
 #ifdef          FSM_LOG_ON
     #define     FSM_LOG(...)   printf(__VA_ARGS__)
 #else
     #define     FSM_LOG(...)   ((void)0)
 #endif
 
-
+#define     delay   delay
 #define     during  during
 #define     enter   enter
 #define     exit    exit
@@ -21,32 +26,36 @@
 #define     index(state, event)     (state*Count_Event + event)
 
 typedef struct _FSMHandler FSMHandler;
-typedef void (*Avoid_WARNING_void_FSM)(FSM *pFSM);
-typedef int (*Avoid_WARNING_int_FSM)(FSM *pFSM);
-typedef int (*Avoid_WARNING_int_data)(void *data);
+typedef void (*Avoid_WARNING_State_Fcns)(void *data);
+typedef int (*Avoid_WARNING_Transition_Handler)(void *data, int curState);
+typedef void (*Avoid_WARNING_Overrider_Fcns)(FSM *pFsm);
+typedef int (*Avoid_WARNING_SelectEvent)(void *data);
 typedef void (*Avoid_WARNING_void_fcns)(FSMHandler *fcns);
 
                 
-#define     addStateActionFcn(type, state)                fcns->type##ActionTable[state] = (Avoid_WARNING_void_FSM)actionFcn(type, state)
-#define     addTransitionHandler(state, event)            fcns->transitionTable[index(state, event)] = (Avoid_WARNING_int_FSM)transitionHandler(event)
+#define     addStateActionFcn(type, state)                fcns->type##ActionTable[state] = (Avoid_WARNING_State_Fcns)actionFcn(type, state)
+#define     addTransitionHandler(state, event)            fcns->transitionTable[index(state, event)] = (Avoid_WARNING_Transition_Handler)transitionHandler(event)
 
 
 typedef struct _FSM FSM;
 typedef struct _FSMHandler{
-    int (**transitionTable)(FSM *pFSM);
-    void (**enterActionTable)(FSM *pFSM);
-    void (**duringActionTable)(FSM *pFSM);
-    void (**exitActionTable)(FSM *pFSM);
+    int (**transitionTable)(void *data, int currentState);
+
+    void (**enterActionTable)(void *data);
+    void (**delayActionTable)(void *data);
+    void (**duringActionTable)(void *data);
+    void (**exitActionTable)(void *data);
+
+    void (**childFSMStepTable)(FSM **cFSM);
 }FSMHandler;
 
 
 typedef struct _FSMPrivateVars
 {
     int curState;    
-    int defaultState; // Idle状态不能停留，必须指定一个初始状态
     int curEvent;
+    int defaultState; // Idle状态不能停留，必须指定一个初始状态
     int numEvent;
-
     int numChild;
     FSM **childFSM;
 
@@ -64,14 +73,13 @@ typedef struct _FSM
     FMSPrivateVars privateVars;
 
     // protected
+
     void *data;
 
 } FSM;
 
 
 // protected, 子类能用, 外界用不了
-int getFSMCurState(FSM *pFSM);
-int getFSMCurEvent(FSM *pFSM);
 void constructFSM(FSM* pFSM);
 
 // 继承的函数
diff --git a/FSM_OOP/baseFSM/FSM_public.h b/FSM_OOP/baseFSM/FSM_public.h
index b9b3cb0..7829675 100644
--- a/FSM_OOP/baseFSM/FSM_public.h
+++ b/FSM_OOP/baseFSM/FSM_public.h
@@ -1,15 +1,15 @@
 #ifndef __FSM_PUBLIC_H_
 #define __FSM_PUBLIC_H_
 
-
-
-
-#define     BASE_FSM(ptr)          ((FSM *)(ptr))
-#define     BASE_PTR               (FSM *)
+// #define     BASE_FSM(ptr)          ((FSM *)(ptr))
+// #define     BASE_PTR               (FSM *)
 
 typedef struct _FSM FSM;
 typedef FSM * FSM_Ptr;
 
+#define     SetEvent(FSM)           setEvent((FSM_Ptr)FSM)
+#define     Step(FSM)               vptrFSM((FSM_Ptr)FSM)->step((FSM_Ptr)FSM)
+
 typedef struct _FSMHandler FSMHandler;
 // 这几个函数可认为是虚函数, 构造函数里不会初始化FSMVtbl, 必须由子类重新实现
 typedef struct _FSMVtbl {
@@ -22,7 +22,8 @@ typedef struct _FSMVtbl {
 }FSMVtbl;
 
 
-
+int getFSMCurState(FSM *pFSM);
+int getFSMCurEvent(FSM *pFSM);
 void setEvent(FSM* pFSM);
 void setChildNum(FSM *pFSM, int num);
 void registerChildFSM(FSM *parent, FSM *child, int index);
diff --git a/FSM_OOP/template/templateFSM.c b/FSM_OOP/template/templateFSM.c
index 404537f..6dd06b7 100644
--- a/FSM_OOP/template/templateFSM.c
+++ b/FSM_OOP/template/templateFSM.c
@@ -40,19 +40,19 @@ static void initData(TemplateFSM *pFSM){   // 必须重新实现
 }
 
 static void setupHandler(FSMHandler* fcns){ // 必须重新实现
-    fcns->duringActionTable[E] = (Avoid_WARNING_void_FSM)actionFcn(during, E);
-    fcns->duringActionTable[D] = (Avoid_WARNING_void_FSM)actionFcn(during, D);
+    fcns->duringActionTable[E] = (Avoid_WARNING_State_Fcns)actionFcn(during, E);
+    fcns->duringActionTable[D] = (Avoid_WARNING_State_Fcns)actionFcn(during, D);
 
-    fcns->enterActionTable[D] = (Avoid_WARNING_void_FSM)actionFcn(enter, D);
-    fcns->enterActionTable[E] = (Avoid_WARNING_void_FSM)actionFcn(enter, E);
+    fcns->enterActionTable[D] = (Avoid_WARNING_State_Fcns)actionFcn(enter, D);
+    fcns->enterActionTable[E] = (Avoid_WARNING_State_Fcns)actionFcn(enter, E);
 
-    fcns->exitActionTable[D] = (Avoid_WARNING_void_FSM)D_exitAction;
-    fcns->exitActionTable[E] = (Avoid_WARNING_void_FSM)E_exitAction;
+    fcns->exitActionTable[D] = (Avoid_WARNING_State_Fcns)D_exitAction;
+    fcns->exitActionTable[E] = (Avoid_WARNING_State_Fcns)E_exitAction;
 
-    fcns->transitionTable[index(Idle, Idle2D)] = (Avoid_WARNING_int_FSM)transitionHandler(Idle2D);
-    fcns->transitionTable[index(Idle, Idle2E)] = (Avoid_WARNING_int_FSM)transitionHandler(Idle2E);
-    fcns->transitionTable[index(D, D2E)] = (Avoid_WARNING_int_FSM)transitionHandler(D2E);
-    fcns->transitionTable[index(E, E2D)] = (Avoid_WARNING_int_FSM)transitionHandler(E2D);
+    fcns->transitionTable[index(Idle, Idle2D)] = (Avoid_WARNING_Transition_Handler)transitionHandler(Idle2D);
+    fcns->transitionTable[index(Idle, Idle2E)] = (Avoid_WARNING_Transition_Handler)transitionHandler(Idle2E);
+    fcns->transitionTable[index(D, D2E)] = (Avoid_WARNING_Transition_Handler)transitionHandler(D2E);
+    fcns->transitionTable[index(E, E2D)] = (Avoid_WARNING_Transition_Handler)transitionHandler(E2D);
 }
 
 /* 
@@ -64,9 +64,9 @@ TemplateFSM *createTemplateFSM(){
     TemplateFSM *pFSM;
     pFSM = (TemplateFSM *)newBaseFSM(Count_State, Count_Event, DEFAULT_STATE);
 
-    pFSM->base.vtbl.step = (Avoid_WARNING_void_FSM)step;
+    pFSM->base.vtbl.step = (Avoid_WARNING_State_Fcns)step;
     pFSM->base.vtbl.selectEvent = (Avoid_WARNING_int_data)selectEvent;
-    pFSM->base.vtbl.initData = (Avoid_WARNING_void_FSM)initData;
+    pFSM->base.vtbl.initData = (Avoid_WARNING_State_Fcns)initData;
     pFSM->base.vtbl.setupHandler = (Avoid_WARNING_void_fcns)setupHandler;
 
     constructFSM((FSM_Ptr)pFSM);
diff --git a/FSM_OOP/usr/keyFSM.c b/FSM_OOP/usr/keyFSM.c
index adf2053..faf13a7 100644
--- a/FSM_OOP/usr/keyFSM.c
+++ b/FSM_OOP/usr/keyFSM.c
@@ -28,7 +28,7 @@ static Event selectEvent(KeyFSMData *data){   // 必须重新实现
 
 static void step(KeyFSM* pFSM){
     printFSM(pFSM);
-    stepBaseFSM(BASE_FSM(pFSM));
+    stepBaseFSM((FSM_Ptr)pFSM);
 
     KeyFSMData * data = pFSM->base.data;
 
@@ -48,21 +48,15 @@ static void initData(KeyFSM *pFSM){   // 必须重新实现
 static void setupHandler(FSMHandler* fcns){ // 必须重新实现
     addStateActionFcn(enter, Waiting);
     addStateActionFcn(during, DownDebouncing);
-    addStateActionFcn(exit, DownDebouncing);
     addStateActionFcn(during, Downing);
-    addStateActionFcn(exit, Downing);
+    addStateActionFcn(delay, Downing);
     addStateActionFcn(during, UpDebouncing);
-    addStateActionFcn(exit, UpDebouncing);
     addStateActionFcn(during, Holding);
     addStateActionFcn(exit, Holding);
     addStateActionFcn(during, MultiDownWaiting);
-    addStateActionFcn(exit, MultiDownWaiting);
-    addStateActionFcn(during, MultiDowning);
-    addStateActionFcn(exit, MultiDowning);
+    addStateActionFcn(delay, MultiDowning);
     addStateActionFcn(during, HoldUpDebouncing);
-    addStateActionFcn(exit, HoldUpDebouncing);
     addStateActionFcn(during, MultiDownDebouncing);
-    addStateActionFcn(exit, MultiDownDebouncing);
 
 
     addTransitionHandler(Waiting, PhsicalDown);
@@ -91,9 +85,12 @@ KeyFSM *createKeyFSM(){
     KeyFSM *pFSM;
     pFSM = (KeyFSM *)newBaseFSM(Count_State, Count_Event, DEFAULT_STATE);
 
-    pFSM->base.vtbl.step = (Avoid_WARNING_void_FSM)step;
-    pFSM->base.vtbl.selectEvent = (Avoid_WARNING_int_data)selectEvent;
-    pFSM->base.vtbl.initData = (Avoid_WARNING_void_FSM)initData;
+#ifndef DSP28377
+    pFSM->base.vtbl.step = (Avoid_WARNING_Overrider_Fcns)step;
+#endif
+
+    pFSM->base.vtbl.selectEvent = (Avoid_WARNING_SelectEvent)selectEvent;
+    pFSM->base.vtbl.initData = (Avoid_WARNING_Overrider_Fcns)initData;
     pFSM->base.vtbl.setupHandler = (Avoid_WARNING_void_fcns)setupHandler;
 
     constructFSM((FSM_Ptr)pFSM);
diff --git a/FSM_OOP/usr/keyFSM_private.h b/FSM_OOP/usr/keyFSM_private.h
index 1791681..a3d6bf3 100644
--- a/FSM_OOP/usr/keyFSM_private.h
+++ b/FSM_OOP/usr/keyFSM_private.h
@@ -37,117 +37,79 @@ typedef enum _State
 #define     DEFAULT_STATE       Waiting
 
 
-static void actionFcn(enter, Waiting)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
+static void actionFcn(enter, Waiting)(KeyFSMData* data){
+ 
     data->out = Idle;
     data->countDelay = 0;
     data->countMultiDown = 0;
 }
 
 
-static void actionFcn(during, DownDebouncing)(KeyFSM *pFSM)
+static void actionFcn(during, DownDebouncing)(KeyFSMData* data)
 {
-    KeyFSMData * data = pFSM->base.data;
+ 
     data->countDelay++;
     FSM_LOG(" during开启消抖 ");
 }
-static void actionFcn(exit, DownDebouncing)(KeyFSM *pFSM)
+
+static void actionFcn(delay, Downing)(KeyFSMData* data)
 {
-    KeyFSMData * data = pFSM->base.data;
-    data->countDelay = 0;
+    data->out = Idle;
 }
-
-
-
-static void actionFcn(during, Downing)(KeyFSM *pFSM)
+static void actionFcn(during, Downing)(KeyFSMData* data)
 {
-    KeyFSMData * data = pFSM->base.data;
+ 
     data->countDelay++;
     data->out = Idle;
 }
-static void actionFcn(exit, Downing)(KeyFSM *pFSM)
-{
-    KeyFSMData * data = pFSM->base.data;
-    data->countDelay = 0;
-    data->out = Idle;
-}
 
 
 
-static void actionFcn(during, UpDebouncing)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
+static void actionFcn(during, UpDebouncing)(KeyFSMData* data){
+ 
     data->countDelay++;
     FSM_LOG(" during松开消抖 ");
 }
-static void actionFcn(exit, UpDebouncing)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
-    data->countDelay = 0;
-}
 
 
-static void actionFcn(during, Holding)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
+static void actionFcn(during, Holding)(KeyFSMData* data){
+    data->out = Idle;
     data->countDelay++;
     if(data->countDelay == 2){
         data->out = Hold;
         data->countDelay = 0;
     }
-    else{
-        data->out = Idle;
-    }
 }
 
-static void actionFcn(exit, Holding)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
-    data->countDelay = 0;
+static void actionFcn(exit, Holding)(KeyFSMData* data){
     data->out = Idle;
 }
 
 
 
-static void actionFcn(during, MultiDownWaiting)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
+static void actionFcn(during, MultiDownWaiting)(KeyFSMData* data){
     data->countDelay++;
     FSM_LOG(" during多击等待 ");
 }
-static void actionFcn(exit, MultiDownWaiting)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
-    data->countDelay = 0;
-}
 
 
-static void actionFcn(during, MultiDowning)(KeyFSM *pFSM)
+static void actionFcn(delay, MultiDowning)(KeyFSMData* data)
 {
-    KeyFSMData * data = pFSM->base.data;
     data->out = Idle;
 }
 
-static void actionFcn(exit, MultiDowning)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
-    data->out = Idle;
-}
 
-static void actionFcn(during, HoldUpDebouncing)(KeyFSM *pFSM)
+static void actionFcn(during, HoldUpDebouncing)(KeyFSMData* data)
 {
-    KeyFSMData * data = pFSM->base.data;
     data->countDelay++;
 }
-static void actionFcn(exit, HoldUpDebouncing)(KeyFSM *pFSM)
-{
-    KeyFSMData * data = pFSM->base.data;
-    data->countDelay = 0;
-}
 
-static void actionFcn(during, MultiDownDebouncing)(KeyFSM *pFSM)
+
+static void actionFcn(during, MultiDownDebouncing)(KeyFSMData* data)
 {
-    KeyFSMData * data = pFSM->base.data;
     data->countDelay++;
 }
-static void actionFcn(exit, MultiDownDebouncing)(KeyFSM *pFSM)
-{
-    KeyFSMData * data = pFSM->base.data;
-    data->countDelay = 0;
-}
+
 
 
 
@@ -165,11 +127,12 @@ typedef enum _Event{
     Count_Event,
 }Event;
 
-static State transitionHandler(PhsicalDown)(KeyFSM *pFSM)
+static State transitionHandler(PhsicalDown)(KeyFSMData* data, State curState)
 {
     FSM_LOG(" 物理按键按下 ");
-    KeyFSMData * data = pFSM->base.data;
-    switch (pFSM->base.privateVars.curState)
+    data->countDelay = 0;
+ 
+    switch (curState)
     {
     case Waiting:
         return DownDebouncing;
@@ -194,11 +157,12 @@ static State transitionHandler(PhsicalDown)(KeyFSM *pFSM)
     }
 }
 
-static State transitionHandler(PhsicalUp)(KeyFSM *pFSM)
+static State transitionHandler(PhsicalUp)(KeyFSMData* data, State curState)
 {
     FSM_LOG(" 物理按键松开 ");
-    KeyFSMData * data = pFSM->base.data;
-    switch (pFSM->base.privateVars.curState)
+    data->countDelay = 0;
+ 
+    switch (curState)
     {
     case DownDebouncing:
         if(data->countMultiDown){
@@ -221,11 +185,11 @@ static State transitionHandler(PhsicalUp)(KeyFSM *pFSM)
     }
 }
 
-static State transitionHandler(DelayCount3)(KeyFSM *pFSM){
+static State transitionHandler(DelayCount3)(KeyFSMData* data, State curState){
     FSM_LOG(" 延迟计数到3 ");
-    KeyFSMData * data = pFSM->base.data;
+    data->countDelay = 0;
     
-    switch (pFSM->base.privateVars.curState)
+    switch (curState)
     {
     case DownDebouncing:
         data->out = Down;
@@ -269,9 +233,10 @@ static State transitionHandler(DelayCount3)(KeyFSM *pFSM){
 }
 
 
-static State transitionHandler(HoldCount4)(KeyFSM *pFSM){
+static State transitionHandler(HoldCount4)(KeyFSMData* data, State curState){
     FSM_LOG(" 计数到2进入长按模式 ");
-    KeyFSMData * data = pFSM->base.data;
+    data->countDelay = 0;
+ 
     data->out = Hold;
     return Holding;
 }
@@ -302,7 +267,7 @@ const static char *eventStr[] = {
     "HoldCount4",
 };
 static void printFSM(KeyFSM* pFSM){
-    KeyFSMData * data = pFSM->base.data;
+    KeyFSMData* data = pFSM->base.data;
     FSM_LOG("KeyFSM: ");
     FSM_LOG("%d, 当前状态:%s, \t当前事件:%s \t转移：",  data->countDelay, stateStr[getFSMCurState((FSM_Ptr)pFSM)], eventStr[getFSMCurEvent((FSM_Ptr)pFSM)]);
 }
diff --git a/main.c b/main.c
index 175ee8f..5052178 100644
--- a/main.c
+++ b/main.c
@@ -19,6 +19,12 @@ KeyIn testin[NUM] = {
     pDown,pDown,pDown,pDown
 };
 
+typedef void (*fcn)();
+
+void printtest(){
+    printf("fcn\n");
+}
+
 
 int main(){
 
@@ -29,8 +35,9 @@ int main(){
         printf("第%d次: ",i+1);
         KeyFSMData* data = getData((FSM_Ptr)keyFSM);
         data->in = testin[i];
-        setEvent((FSM_Ptr)keyFSM);
-        vptrFSM((FSM_Ptr)keyFSM)->step((FSM_Ptr)keyFSM);
+
+        SetEvent(keyFSM);
+        Step(keyFSM);
 
         if(data->out){
             printf("\t\t\t\t%d", data->out);    
@@ -41,7 +48,9 @@ int main(){
     }
 
 
-    printf("hello world, 你好世界");
+    printf("hello world, 你好世界\n");
 
+    fcn fcnptr = printtest;
+    (fcnptr == NULL) ? :  fcnptr();
     return 0;
 }
\ No newline at end of file