//first line
/*This file is generated from StateMGen.java */

#include "ExampleSimpleData.h"
#include <stdio.h>
#include "exampleSimpleStates.h"

//all entry-prototypes:
void entry_Off_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_Ready_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_Running1_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_Running21_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_Running2_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_Running_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_Finit_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_Active1_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_On_a_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_On_b_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_RemainOn_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_ShouldOff_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_Active2_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_Active_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void entry_Work_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);

void exit_Off_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_Ready_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_Running1_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_Running21_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_Running2_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_Running_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_Finit_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_Active1_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_On_a_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_On_b_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_RemainOn_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_ShouldOff_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_Active2_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_Active_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);
void exit_Work_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event);





static void entry_Off_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  thiz->state.statetop = kOff_State_ExampleSimpleData;
  thiz->work = 0;
    
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry Off;\n");
  #endif
}

INLINE_Fwc void exit_Off_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit Off;\n");
  #endif
  
}



INLINE_Fwc int trans_Off_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  if(thiz->on_ready) {
    exit_Off_ExampleSimpleData(thiz, event);
    thiz->work = 1;
    entry_Work_ExampleSimpleData(thiz, event);
    entry_Ready_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  if(thiz->on_cont) {
    exit_Off_ExampleSimpleData(thiz, event);
    
    entry_Work_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  { //StateMGen: action in state. No transition switched.
    thiz->counter +=1;
    
  }
  return trans;
}






static void entry_Ready_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  thiz->state.stateWork = kReady_State_ExampleSimpleData;
  
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry Ready;\n");
  #endif
}

INLINE_Fwc void exit_Ready_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit Ready;\n");
  #endif
  
}



INLINE_Fwc int trans_Ready_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  if(event == kStart_Event_ExampleSimple) {
    exit_Ready_ExampleSimpleData(thiz, event);
    
    entry_Active_ExampleSimpleData(thiz, event);
    entry_Active1_ExampleSimpleData(thiz, event);
    entry_Active2_ExampleSimpleData(thiz, event);
    entry_Running_ExampleSimpleData(thiz, event);
    entry_RemainOn_ExampleSimpleData(thiz, event);
    entry_Running2_ExampleSimpleData(thiz, event);
    entry_Running21_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}






static void entry_Running1_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  thiz->state.stateActive1 = kRunning1_State_ExampleSimpleData;
  
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry Running1;\n");
  #endif
}

INLINE_Fwc void exit_Running1_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit Running1;\n");
  #endif
  
}



INLINE_Fwc int trans_Running1_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  //genStateM: no transitions.
  //genStateM: transitions of enclosing state: Running
  if(thiz->state.timerActive1 <0) {
    exit_Running_ExampleSimpleData(thiz, event);
    
    entry_Finit_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}






static void entry_Running21_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  thiz->state.stateActive1 = kRunning21_State_ExampleSimpleData;
  
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry Running21;\n");
  #endif
}

INLINE_Fwc void exit_Running21_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit Running21;\n");
  #endif
  
}



INLINE_Fwc int trans_Running21_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  //genStateM: no transitions.
  //genStateM: transitions of enclosing state: Running2
  //genStateM: no transitions.
  //genStateM: transitions of enclosing state: Running
  if(thiz->state.timerActive1 <0) {
    exit_Running_ExampleSimpleData(thiz, event);
    
    entry_Finit_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}






static void entry_Running2_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  thiz->state.stateActive1 = kRunning2_State_ExampleSimpleData;
  
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry Running2;\n");
  #endif
}

INLINE_Fwc void exit_Running2_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit Running2;\n");
  #endif
  
}



INLINE_Fwc int trans_Running2_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  //genStateM: no transitions.
  //genStateM: transitions of enclosing state: Running
  if(thiz->state.timerActive1 <0) {
    exit_Running_ExampleSimpleData(thiz, event);
    
    entry_Finit_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}






static void entry_Running_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  thiz->state.stateActive1 = kRunning_State_ExampleSimpleData;
  thiz->state.timerActive1 = thiz->delay;
  thiz->out = 3; 
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry Running;\n");
  #endif
}

INLINE_Fwc void exit_Running_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit Running;\n");
  #endif
  thiz->out = 5; 
}



INLINE_Fwc int trans_Running_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  if(thiz->state.timerActive1 <0) {
    exit_Running_ExampleSimpleData(thiz, event);
    
    entry_Finit_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}






static void entry_Finit_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  thiz->state.stateActive1 = kFinit_State_ExampleSimpleData;
  
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry Finit;\n");
  #endif
}

INLINE_Fwc void exit_Finit_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit Finit;\n");
  #endif
  
}



INLINE_Fwc int trans_Finit_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  //genStateM: no transitions.
  //StateMGen: join transition
  if(true && thiz->state.stateActive1 == kFinit_State_ExampleSimpleData && thiz->state.stateActive2 == kShouldOff_State_ExampleSimpleData ) {
    exit_Finit_ExampleSimpleData(thiz, event);
    exit_ShouldOff_ExampleSimpleData(thiz, event);
    exit_Active1_ExampleSimpleData(thiz, event);
    exit_Active2_ExampleSimpleData(thiz, event);
    exit_Active_ExampleSimpleData(thiz, event);
    exit_Work_ExampleSimpleData(thiz, event);
    
    entry_Off_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}






static void entry_Active1_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry Active1;\n");
  #endif
}

INLINE_Fwc void exit_Active1_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit Active1;\n");
  #endif
  
}



INLINE_Fwc int trans_Active1_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  //genStateM: no transitions.
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}






static void entry_On_a_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  thiz->state.stateActive2 = kOn_a_State_ExampleSimpleData;
  
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry On_a;\n");
  #endif
}

INLINE_Fwc void exit_On_a_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit On_a;\n");
  #endif
  
}



INLINE_Fwc int trans_On_a_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  if(thiz->bit_a) {
    exit_On_a_ExampleSimpleData(thiz, event);
    
    entry_On_b_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  //genStateM: transitions of enclosing state: RemainOn
  if(thiz->offAfterRunning) {
    exit_RemainOn_ExampleSimpleData(thiz, event);
    
    entry_ShouldOff_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}






static void entry_On_b_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  thiz->state.stateActive2 = kOn_b_State_ExampleSimpleData;
  
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry On_b;\n");
  #endif
}

INLINE_Fwc void exit_On_b_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit On_b;\n");
  #endif
  
}



INLINE_Fwc int trans_On_b_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  if(thiz->bit_b) {
    exit_On_b_ExampleSimpleData(thiz, event);
    
    entry_On_a_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  //genStateM: transitions of enclosing state: RemainOn
  if(thiz->offAfterRunning) {
    exit_RemainOn_ExampleSimpleData(thiz, event);
    
    entry_ShouldOff_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}






static void entry_RemainOn_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  thiz->state.stateActive2 = kRemainOn_State_ExampleSimpleData;
  
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry RemainOn;\n");
  #endif
}

INLINE_Fwc void exit_RemainOn_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit RemainOn;\n");
  #endif
  
}



INLINE_Fwc int trans_RemainOn_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  if(thiz->offAfterRunning) {
    exit_RemainOn_ExampleSimpleData(thiz, event);
    
    entry_ShouldOff_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}






static void entry_ShouldOff_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  thiz->state.stateActive2 = kShouldOff_State_ExampleSimpleData;
  
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry ShouldOff;\n");
  #endif
}

INLINE_Fwc void exit_ShouldOff_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit ShouldOff;\n");
  #endif
  
}



INLINE_Fwc int trans_ShouldOff_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  if(false /*join:Finit */) {
    exit_ShouldOff_ExampleSimpleData(thiz, event);
    exit_Active2_ExampleSimpleData(thiz, event);
    exit_Active_ExampleSimpleData(thiz, event);
    exit_Work_ExampleSimpleData(thiz, event);
    
    entry_Off_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  if(thiz->abort) {
    exit_ShouldOff_ExampleSimpleData(thiz, event);
    exit_Active2_ExampleSimpleData(thiz, event);
    exit_Active_ExampleSimpleData(thiz, event);
    exit_Work_ExampleSimpleData(thiz, event);
    
    entry_Off_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  //StateMGen: join transition
  if(true && thiz->state.stateActive1 == kFinit_State_ExampleSimpleData && thiz->state.stateActive2 == kShouldOff_State_ExampleSimpleData ) {
    exit_Finit_ExampleSimpleData(thiz, event);
    exit_ShouldOff_ExampleSimpleData(thiz, event);
    exit_Active1_ExampleSimpleData(thiz, event);
    exit_Active2_ExampleSimpleData(thiz, event);
    exit_Active_ExampleSimpleData(thiz, event);
    exit_Work_ExampleSimpleData(thiz, event);
    
    entry_Off_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}






static void entry_Active2_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry Active2;\n");
  #endif
}

INLINE_Fwc void exit_Active2_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit Active2;\n");
  #endif
  
}



INLINE_Fwc int trans_Active2_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  //genStateM: no transitions.
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}





//genStateM: stateParallel
static void entry_Active_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateParallel.
  thiz->state.stateWork = kActive_State_ExampleSimpleData;
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry Active; parallel\n");
  #endif
}


INLINE_Fwc void exit_Active_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: it is a parallelState , it is its own rootstate: Work
  //thiz->state.stateActive = 0;  //if a parallel state has a history, set bit and preserve state nr
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit Active;\n");
  #endif
}


INLINE_Fwc int trans_Active_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: parallelState
  //TODO transitions
  return 0;
}






static void entry_Work_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ //genStateM: entry StateComposite or StateSimple. 
  thiz->state.statetop = kWork_State_ExampleSimpleData;
  thiz->work = 1;
    
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf(" entry Work;\n");
  #endif
}

INLINE_Fwc void exit_Work_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{
  #ifdef __DEBUG_entryprintf_States_Fwc__
    printf("   exit Work;\n");
  #endif
  //It is a composite state with a history state. Mark the state number with the inactive bit:
  thiz->state.stateWork |= 0x80000000; 
  thiz->work = 0;
    
}



INLINE_Fwc int trans_Work_ExampleSimpleData(struct ExampleSimpleData_t* thiz, int event)
{ int trans = 0;
  //genStateM: check all conditions of transitions, return on transition with != 0
  //xxx trans = switchStates_WorkState_ExampleSimpleData(thiz, event);
  if(thiz->off) {
    exit_Work_ExampleSimpleData(thiz, event);
    
    entry_Off_ExampleSimpleData(thiz, event);
    trans = mTransit_States_Fwc; 
  }
  else 
  { //StateMGen: action in state. No transition switched.
    
  }
  return trans;
}



//This method should be called in any step time. It decrements all timer which are set.
//
void stepStateTimer_State_ExampleSimpleData( struct ExampleSimpleData_t* thiz, int event )
{
  if(thiz->state.timerActive1 >=0) {
    thiz->state.timerActive1 -=1;
  }

}






int stepStates_State_ExampleSimpleData( struct ExampleSimpleData_t* thiz, int event )
{ int trans = 0;                //set to true if transition has fired.
  int ctSwitchState = 10;     //prevent too many transitions - a endless loop
  do {
    trans &= ~mTransit_States_Fwc;
    switch(thiz->state.statetop) {
               //if the state was entried newly without define an inner state, then the statedefault will be entered now.
               //Note that the default state cannot be entered on entry action because it is unknown in that time
               //whether there will be an entry to a designated state.
      case 0: entry_Off_ExampleSimpleData(thiz, event); //without break, do trans:
      //switch to the current state:
      case kOff_State_ExampleSimpleData: trans |= trans_Off_ExampleSimpleData(thiz, event); break;
      case kWork_State_ExampleSimpleData: { 
        int ctSwitchState = 10;     //prevent too many transitions - a endless loop
        do {
          trans &= ~mTransit_States_Fwc;
          switch(thiz->state.stateWork) {
                     //if the state was entried newly without define an inner state, then the statedefault will be entered now.
                     //Note that the default state cannot be entered on entry action because it is unknown in that time
                     //whether there will be an entry to a designated state.
            case 0: entry_Ready_ExampleSimpleData(thiz, event); //without break, do trans:
            //switch to the current state:
            case kReady_State_ExampleSimpleData: trans |= trans_Ready_ExampleSimpleData(thiz, event); break;
            case kActive_State_ExampleSimpleData: {
               { //genStateM: Parallel state switch
                  int ctSwitchState = 10;     //prevent too many transitions - a endless loop
                  do {
                    trans &= ~mTransit_States_Fwc;
                    switch(thiz->state.stateActive1) {
                               //if the state was entried newly without define an inner state, then the statedefault will be entered now.
                               //Note that the default state cannot be entered on entry action because it is unknown in that time
                               //whether there will be an entry to a designated state.
                      case 0: entry_Running_ExampleSimpleData(thiz, event); //without break, do trans:
                      //switch to the current state:
                      case kRunning1_State_ExampleSimpleData: trans |= trans_Running1_ExampleSimpleData(thiz, event); break;
                      case kRunning21_State_ExampleSimpleData: trans |= trans_Running21_ExampleSimpleData(thiz, event); break;
                      case kFinit_State_ExampleSimpleData: trans |= trans_Finit_ExampleSimpleData(thiz, event); break;
                    } //switch
                  } while((trans & mTransit_States_Fwc)    //continue checking transitions if one of the has fired, it is run to completion.
                      && thiz->state.stateActive1 !=0  //don't continue if the composite is inactive now.
                      && --ctSwitchState >0);     //don't execute too may loops, only a safety check. 
                  //
                  //for all parallel states: switch only if this state is the active one still. Regard a leave of the state from any substate.
               }
               { //genStateM: Parallel state switch
                  int ctSwitchState = 10;     //prevent too many transitions - a endless loop
                  do {
                    trans &= ~mTransit_States_Fwc;
                    switch(thiz->state.stateActive2) {
                               //if the state was entried newly without define an inner state, then the statedefault will be entered now.
                               //Note that the default state cannot be entered on entry action because it is unknown in that time
                               //whether there will be an entry to a designated state.
                      case 0: entry_RemainOn_ExampleSimpleData(thiz, event); //without break, do trans:
                      //switch to the current state:
                      case kOn_a_State_ExampleSimpleData: trans |= trans_On_a_ExampleSimpleData(thiz, event); break;
                      case kOn_b_State_ExampleSimpleData: trans |= trans_On_b_ExampleSimpleData(thiz, event); break;
                      case kShouldOff_State_ExampleSimpleData: trans |= trans_ShouldOff_ExampleSimpleData(thiz, event); break;
                    } //switch
                  } while((trans & mTransit_States_Fwc)    //continue checking transitions if one of the has fired, it is run to completion.
                      && thiz->state.stateActive2 !=0  //don't continue if the composite is inactive now.
                      && --ctSwitchState >0);     //don't execute too may loops, only a safety check. 
                  //
                  //for all parallel states: switch only if this state is the active one still. Regard a leave of the state from any substate.
               }
              trans |= trans_Active_ExampleSimpleData(thiz, event);
            } break; 
          } //switch
        } while((trans & mTransit_States_Fwc)    //continue checking transitions if one of the has fired, it is run to completion.
            && thiz->state.stateWork !=0  //don't continue if the composite is inactive now.
            && --ctSwitchState >0);     //don't execute too may loops, only a safety check. 
        //
        //for all parallel states: switch only if this state is the active one still. Regard a leave of the state from any substate.
      } break; //composite state
    } //switch
  } while((trans & mTransit_States_Fwc)    //continue checking transitions if one of the has fired, it is run to completion.
      && thiz->state.statetop !=0  //don't continue if the composite is inactive now.
      && --ctSwitchState >0);     //don't execute too may loops, only a safety check. 
  //
  //for all parallel states: switch only if this state is the active one still. Regard a leave of the state from any substate.
  return trans;
}
