SetPllPlldvOdiv2Output (const struct Clock_Ip_DividerConfigType * config)
{
  uint32 dividerValue;
  uint32 regValue;
  uint32 instance;
  uint32 TimeoutTicks;
  uint32 ElapsedTime;
  uint32 StartTime;
  boolean TimeoutOccurred;
  <unnamed type> _1;
  int _2;
  unsigned char _3;
  struct MC_ME_Type * _4;
  long unsigned int _5;
  long unsigned int _6;
  struct MC_ME_Type * _7;
  long unsigned int _8;
  struct MC_ME_Type * _9;
  long unsigned int _10;
  struct MC_ME_Type * _11;
  long unsigned int _12;
  struct MC_ME_Type * _13;
  long unsigned int _14;
  struct MC_ME_Type * _15;
  long unsigned int _16;
  struct MC_ME_Type * _17;
  long unsigned int _18;
  struct MC_ME_Type * _19;
  struct MC_ME_Type * _20;
  long unsigned int TimeoutTicks.0_21;
  struct MC_ME_Type * _22;
  long unsigned int _23;
  long unsigned int _24;
  _Bool _25;
  <unnamed type> _26;
  long unsigned int _27;
  volatile struct PLL_Type * _28;
  long unsigned int _29;
  long unsigned int _30;
  volatile struct PLL_Type * _31;
  <unnamed type> _32;
  const long unsigned int iftmp.1_33;
  const long unsigned int iftmp.1_49;
  const long unsigned int iftmp.1_50;

  <bb 2> :
  # DEBUG BEGIN_STMT
  TimeoutOccurred_36 = 0;
  # DEBUG TimeoutOccurred => TimeoutOccurred_36
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = config_38(D)->name;
  _2 = (int) _1;
  _3 = clockFeatures[_2][0];
  instance_39 = (uint32) _3;
  # DEBUG instance => instance_39
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _4 = 1076740096B;
  _5 ={v} _4->PRTN1_COFB1_STAT;
  _6 = _5 & 16777216;
  if (_6 == 0)
    goto <bb 3>; [INV]
  else
    goto <bb 8>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _7 = 1076740096B;
  _8 ={v} _7->PRTN1_COFB1_CLKEN;
  _9 = 1076740096B;
  _10 = _8 | 16777216;
  _9->PRTN1_COFB1_CLKEN ={v} _10;
  # DEBUG BEGIN_STMT
  _11 = 1076740096B;
  _12 ={v} _11->PRTN1_PCONF;
  _13 = 1076740096B;
  _14 = _12 | 1;
  _13->PRTN1_PCONF ={v} _14;
  # DEBUG BEGIN_STMT
  _15 = 1076740096B;
  _16 ={v} _15->PRTN1_PUPD;
  _17 = 1076740096B;
  _18 = _16 | 1;
  _17->PRTN1_PUPD ={v} _18;
  # DEBUG BEGIN_STMT
  _19 = 1076740096B;
  _19->CTL_KEY ={v} 23280;
  # DEBUG BEGIN_STMT
  _20 = 1076740096B;
  _20->CTL_KEY ={v} 42255;
  # DEBUG BEGIN_STMT
  ClockStartTimeout (&StartTime, &ElapsedTime, &TimeoutTicks, 10000);

  <bb 4> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  TimeoutTicks.0_21 = TimeoutTicks;
  TimeoutOccurred_47 = ClockTimeoutExpired (&StartTime, &ElapsedTime, TimeoutTicks.0_21);
  # DEBUG TimeoutOccurred => TimeoutOccurred_47
  # DEBUG BEGIN_STMT
  _22 = 1076740096B;
  _23 ={v} _22->PRTN1_COFB1_STAT;
  _24 = _23 & 16777216;
  if (_24 == 0)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  _25 = ~TimeoutOccurred_47;
  if (_25 != 0)
    goto <bb 4>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  if (TimeoutOccurred_47 != 0)
    goto <bb 7>; [INV]
  else
    goto <bb 8>; [INV]

  <bb 7> :
  # DEBUG BEGIN_STMT
  _26 = config_38(D)->name;
  ReportClockErrors (1, _26);

  <bb 8> :
  # DEBUG BEGIN_STMT
  _27 = config_38(D)->value;
  if (_27 != 0)
    goto <bb 9>; [INV]
  else
    goto <bb 10>; [INV]

  <bb 9> :
  iftmp.1_50 = config_38(D)->value;
  goto <bb 11>; [INV]

  <bb 10> :
  iftmp.1_49 = 1;

  <bb 11> :
  # iftmp.1_33 = PHI <iftmp.1_50(9), iftmp.1_49(10)>
  dividerValue_51 = iftmp.1_33;
  # DEBUG dividerValue => dividerValue_51
  # DEBUG BEGIN_STMT
  _28 = pll[instance_39];
  regValue_52 ={v} _28->PLLDV;
  # DEBUG regValue => regValue_52
  # DEBUG BEGIN_STMT
  regValue_53 = regValue_52 & 2181038079;
  # DEBUG regValue => regValue_53
  # DEBUG BEGIN_STMT
  _29 = dividerValue_51 << 25;
  _30 = _29 & 2113929216;
  regValue_54 = regValue_53 | _30;
  # DEBUG regValue => regValue_54
  # DEBUG BEGIN_STMT
  _31 = pll[instance_39];
  _31->PLLDV ={v} regValue_54;
  # DEBUG BEGIN_STMT
  _32 = config_38(D)->name;
  UpdateClockState (_32, 255);
  StartTime ={v} {CLOBBER};
  ElapsedTime ={v} {CLOBBER};
  TimeoutTicks ={v} {CLOBBER};
  return;

}


SetPllPll0divDeDivOutput (const struct Clock_Ip_DividerConfigType * config)
{
  uint32 regValue;
  uint32 dividerIndex;
  uint32 instance;
  uint32 TimeoutTicks;
  uint32 ElapsedTime;
  uint32 StartTime;
  boolean TimeoutOccurred;
  <unnamed type> _1;
  int _2;
  unsigned char _3;
  <unnamed type> _4;
  int _5;
  unsigned char _6;
  struct MC_ME_Type * _7;
  long unsigned int _8;
  long unsigned int _9;
  struct MC_ME_Type * _10;
  long unsigned int _11;
  struct MC_ME_Type * _12;
  long unsigned int _13;
  struct MC_ME_Type * _14;
  long unsigned int _15;
  struct MC_ME_Type * _16;
  long unsigned int _17;
  struct MC_ME_Type * _18;
  long unsigned int _19;
  struct MC_ME_Type * _20;
  long unsigned int _21;
  struct MC_ME_Type * _22;
  struct MC_ME_Type * _23;
  long unsigned int TimeoutTicks.2_24;
  struct MC_ME_Type * _25;
  long unsigned int _26;
  long unsigned int _27;
  _Bool _28;
  <unnamed type> _29;
  volatile struct PLL_Type * _30;
  long unsigned int _31;
  volatile struct PLL_Type * _32;
  long unsigned int _33;
  long unsigned int _34;
  volatile struct PLL_Type * _35;
  long unsigned int _36;
  long unsigned int _37;
  long unsigned int _38;
  long unsigned int _39;
  volatile struct PLL_Type * _40;
  <unnamed type> _41;
  <unnamed type> _42;
  <unnamed type> _43;
  <unnamed type> _44;

  <bb 2> :
  # DEBUG BEGIN_STMT
  TimeoutOccurred_48 = 0;
  # DEBUG TimeoutOccurred => TimeoutOccurred_48
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = config_50(D)->name;
  _2 = (int) _1;
  _3 = clockFeatures[_2][0];
  instance_51 = (uint32) _3;
  # DEBUG instance => instance_51
  # DEBUG BEGIN_STMT
  _4 = config_50(D)->name;
  _5 = (int) _4;
  _6 = clockFeatures[_5][3];
  dividerIndex_52 = (uint32) _6;
  # DEBUG dividerIndex => dividerIndex_52
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _7 = 1076740096B;
  _8 ={v} _7->PRTN1_COFB1_STAT;
  _9 = _8 & 16777216;
  if (_9 == 0)
    goto <bb 3>; [INV]
  else
    goto <bb 8>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _10 = 1076740096B;
  _11 ={v} _10->PRTN1_COFB1_CLKEN;
  _12 = 1076740096B;
  _13 = _11 | 16777216;
  _12->PRTN1_COFB1_CLKEN ={v} _13;
  # DEBUG BEGIN_STMT
  _14 = 1076740096B;
  _15 ={v} _14->PRTN1_PCONF;
  _16 = 1076740096B;
  _17 = _15 | 1;
  _16->PRTN1_PCONF ={v} _17;
  # DEBUG BEGIN_STMT
  _18 = 1076740096B;
  _19 ={v} _18->PRTN1_PUPD;
  _20 = 1076740096B;
  _21 = _19 | 1;
  _20->PRTN1_PUPD ={v} _21;
  # DEBUG BEGIN_STMT
  _22 = 1076740096B;
  _22->CTL_KEY ={v} 23280;
  # DEBUG BEGIN_STMT
  _23 = 1076740096B;
  _23->CTL_KEY ={v} 42255;
  # DEBUG BEGIN_STMT
  ClockStartTimeout (&StartTime, &ElapsedTime, &TimeoutTicks, 10000);

  <bb 4> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  TimeoutTicks.2_24 = TimeoutTicks;
  TimeoutOccurred_60 = ClockTimeoutExpired (&StartTime, &ElapsedTime, TimeoutTicks.2_24);
  # DEBUG TimeoutOccurred => TimeoutOccurred_60
  # DEBUG BEGIN_STMT
  _25 = 1076740096B;
  _26 ={v} _25->PRTN1_COFB1_STAT;
  _27 = _26 & 16777216;
  if (_27 == 0)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  _28 = ~TimeoutOccurred_60;
  if (_28 != 0)
    goto <bb 4>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  if (TimeoutOccurred_60 != 0)
    goto <bb 7>; [INV]
  else
    goto <bb 8>; [INV]

  <bb 7> :
  # DEBUG BEGIN_STMT
  _29 = config_50(D)->name;
  ReportClockErrors (1, _29);

  <bb 8> :
  # DEBUG BEGIN_STMT
  _30 = pll[instance_51];
  _31 ={v} _30->PLLODIV[dividerIndex_52];
  _32 = pll[instance_51];
  _33 = _31 & 2147483647;
  _32->PLLODIV[dividerIndex_52] ={v} _33;
  # DEBUG BEGIN_STMT
  _34 = config_50(D)->value;
  if (_34 != 0)
    goto <bb 9>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  _35 = pll[instance_51];
  regValue_64 ={v} _35->PLLODIV[dividerIndex_52];
  # DEBUG regValue => regValue_64
  # DEBUG BEGIN_STMT
  regValue_65 = regValue_64 | 2147483648;
  # DEBUG regValue => regValue_65
  # DEBUG BEGIN_STMT
  regValue_66 = regValue_65 & 4293984255;
  # DEBUG regValue => regValue_66
  # DEBUG BEGIN_STMT
  _36 = config_50(D)->value;
  _37 = _36 + 4294967295;
  _38 = _37 << 16;
  _39 = _38 & 983040;
  regValue_67 = regValue_66 | _39;
  # DEBUG regValue => regValue_67
  # DEBUG BEGIN_STMT
  _40 = pll[instance_51];
  _40->PLLODIV[dividerIndex_52] ={v} regValue_67;
  # DEBUG BEGIN_STMT
  _41 = config_50(D)->name;
  _42 = GetClockState (_41);
  if (_42 == 0)
    goto <bb 10>; [INV]
  else
    goto <bb 12>; [INV]

  <bb 10> :
  # DEBUG BEGIN_STMT
  _43 = config_50(D)->name;
  UpdateClockState (_43, 255);
  goto <bb 12>; [INV]

  <bb 11> :
  # DEBUG BEGIN_STMT
  _44 = config_50(D)->name;
  UpdateClockState (_44, 0);

  <bb 12> :
  StartTime ={v} {CLOBBER};
  ElapsedTime ={v} {CLOBBER};
  TimeoutTicks ={v} {CLOBBER};
  return;

}


SetCgmXDeDivStatWithPhase (const struct Clock_Ip_DividerConfigType * config)
{
  boolean immediateTriggerIsUpdated;
  uint32 DividerStatus;
  uint32 TimeoutTicks;
  uint32 ElapsedTime;
  uint32 StartTime;
  boolean TimeoutOccurred;
  uint32 regValue;
  uint32 triggerFeat;
  uint32 dividerIndex;
  uint32 selectorIndex;
  uint32 instance;
  <unnamed type> _1;
  int _2;
  unsigned char _3;
  <unnamed type> _4;
  int _5;
  unsigned char _6;
  <unnamed type> _7;
  int _8;
  unsigned char _9;
  <unnamed type> _10;
  int _11;
  unsigned char _12;
  long unsigned int _13;
  volatile struct cgmMux_Type * _14;
  long unsigned int _15;
  long unsigned int _16;
  long unsigned int _17;
  long unsigned int _18;
  volatile struct cgmMux_Type * _19;
  volatile struct cgmMux_Type * _20;
  long unsigned int _21;
  long unsigned int _22;
  volatile struct cgmMux_Type * _23;
  long unsigned int _24;
  long unsigned int TimeoutTicks.3_25;
  _Bool _26;
  _Bool _27;
  volatile struct cgmMux_Type * _28;
  long unsigned int _29;
  volatile struct cgmMux_Type * _30;
  long unsigned int _31;
  <unnamed type> _32;
  volatile struct cgmMux_Type * _33;
  long unsigned int _34;
  long unsigned int TimeoutTicks.4_35;
  _Bool _36;
  _Bool _37;
  volatile struct cgmMux_Type * _38;
  unsigned char _39;
  long unsigned int _40;
  volatile struct cgmMux_Type * _41;
  <unnamed type> _42;
  long unsigned int _43;
  volatile struct cgmMux_Type * _44;
  long unsigned int _45;
  volatile struct cgmMux_Type * _46;
  long unsigned int _47;
  <unnamed type> _48;
  <unnamed type> _49;
  <unnamed type> _50;
  <unnamed type> _51;

  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = config_61(D)->name;
  _2 = (int) _1;
  _3 = clockFeatures[_2][0];
  instance_62 = (uint32) _3;
  # DEBUG instance => instance_62
  # DEBUG BEGIN_STMT
  _4 = config_61(D)->name;
  _5 = (int) _4;
  _6 = clockFeatures[_5][2];
  selectorIndex_63 = (uint32) _6;
  # DEBUG selectorIndex => selectorIndex_63
  # DEBUG BEGIN_STMT
  _7 = config_61(D)->name;
  _8 = (int) _7;
  _9 = clockFeatures[_8][3];
  dividerIndex_64 = (uint32) _9;
  # DEBUG dividerIndex => dividerIndex_64
  # DEBUG BEGIN_STMT
  _10 = config_61(D)->name;
  _11 = (int) _10;
  _12 = clockFeatures[_11][5];
  triggerFeat_65 = (uint32) _12;
  # DEBUG triggerFeat => triggerFeat_65
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  TimeoutOccurred_66 = 0;
  # DEBUG TimeoutOccurred => TimeoutOccurred_66
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  immediateTriggerIsUpdated_67 = 1;
  # DEBUG immediateTriggerIsUpdated => immediateTriggerIsUpdated_67
  # DEBUG BEGIN_STMT
  _13 = config_61(D)->value;
  if (_13 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _14 = cgm[instance_62][selectorIndex_63];
  regValue_68 ={v} _14->divider[dividerIndex_64];
  # DEBUG regValue => regValue_68
  # DEBUG BEGIN_STMT
  regValue_69 = regValue_68 & 4290838527;
  # DEBUG regValue => regValue_69
  # DEBUG BEGIN_STMT
  _15 = config_61(D)->value;
  _16 = _15 + 4294967295;
  _17 = _16 << 16;
  _18 = _17 & 4128768;
  regValue_70 = regValue_69 | _18;
  # DEBUG regValue => regValue_70
  # DEBUG BEGIN_STMT
  _19 = cgm[instance_62][selectorIndex_63];
  _19->divider[dividerIndex_64] ={v} regValue_70;

  <bb 4> :
  # DEBUG BEGIN_STMT
  if (triggerFeat_65 == 1)
    goto <bb 5>; [INV]
  else
    goto <bb 7>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  _20 = cgm[instance_62][selectorIndex_63];
  _21 ={v} _20->MUX_DIV_TRIG_CTRL;
  _22 = _21 & 1;
  if (_22 == 1)
    goto <bb 6>; [INV]
  else
    goto <bb 7>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  immediateTriggerIsUpdated_72 = 0;
  # DEBUG immediateTriggerIsUpdated => immediateTriggerIsUpdated_72

  <bb 7> :
  # immediateTriggerIsUpdated_53 = PHI <immediateTriggerIsUpdated_67(4), immediateTriggerIsUpdated_67(5), immediateTriggerIsUpdated_72(6)>
  # DEBUG immediateTriggerIsUpdated => immediateTriggerIsUpdated_53
  # DEBUG BEGIN_STMT
  if (immediateTriggerIsUpdated_53 != 0)
    goto <bb 8>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 8> :
  # DEBUG BEGIN_STMT
  ClockStartTimeout (&StartTime, &ElapsedTime, &TimeoutTicks, 10000);

  <bb 9> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _23 = cgm[instance_62][selectorIndex_63];
  _24 ={v} _23->MUX_DIV_UPD_STAT;
  DividerStatus_74 = _24 & 1;
  # DEBUG DividerStatus => DividerStatus_74
  # DEBUG BEGIN_STMT
  TimeoutTicks.3_25 = TimeoutTicks;
  TimeoutOccurred_76 = ClockTimeoutExpired (&StartTime, &ElapsedTime, TimeoutTicks.3_25);
  # DEBUG TimeoutOccurred => TimeoutOccurred_76
  # DEBUG BEGIN_STMT
  if (DividerStatus_74 == 1)
    goto <bb 10>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 10> :
  _26 = ~TimeoutOccurred_76;
  if (_26 != 0)
    goto <bb 9>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 11> :
  # TimeoutOccurred_52 = PHI <TimeoutOccurred_66(7), TimeoutOccurred_76(9), TimeoutOccurred_76(10)>
  # DEBUG TimeoutOccurred => TimeoutOccurred_52
  # DEBUG BEGIN_STMT
  _27 = ~TimeoutOccurred_52;
  if (_27 != 0)
    goto <bb 12>; [INV]
  else
    goto <bb 21>; [INV]

  <bb 12> :
  # DEBUG BEGIN_STMT
  _28 = cgm[instance_62][selectorIndex_63];
  _29 ={v} _28->divider[dividerIndex_64];
  _30 = cgm[instance_62][selectorIndex_63];
  _31 = _29 & 2147483647;
  _30->divider[dividerIndex_64] ={v} _31;
  # DEBUG BEGIN_STMT
  _32 = config_61(D)->name;
  UpdateClockState (_32, 0);
  # DEBUG BEGIN_STMT
  ClockStartTimeout (&StartTime, &ElapsedTime, &TimeoutTicks, 10000);

  <bb 13> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _33 = cgm[instance_62][selectorIndex_63];
  _34 ={v} _33->MUX_DIV_UPD_STAT;
  DividerStatus_81 = _34 & 1;
  # DEBUG DividerStatus => DividerStatus_81
  # DEBUG BEGIN_STMT
  TimeoutTicks.4_35 = TimeoutTicks;
  TimeoutOccurred_83 = ClockTimeoutExpired (&StartTime, &ElapsedTime, TimeoutTicks.4_35);
  # DEBUG TimeoutOccurred => TimeoutOccurred_83
  # DEBUG BEGIN_STMT
  if (DividerStatus_81 == 1)
    goto <bb 14>; [INV]
  else
    goto <bb 15>; [INV]

  <bb 14> :
  _36 = ~TimeoutOccurred_83;
  if (_36 != 0)
    goto <bb 13>; [INV]
  else
    goto <bb 15>; [INV]

  <bb 15> :
  # DEBUG BEGIN_STMT
  _37 = ~TimeoutOccurred_83;
  if (_37 != 0)
    goto <bb 16>; [INV]
  else
    goto <bb 17>; [INV]

  <bb 16> :
  # DEBUG BEGIN_STMT
  _38 = cgm[instance_62][selectorIndex_63];
  regValue_85 ={v} _38->divider[dividerIndex_64];
  # DEBUG regValue => regValue_85
  # DEBUG BEGIN_STMT
  regValue_86 = regValue_85 & 4294967040;
  # DEBUG regValue => regValue_86
  # DEBUG BEGIN_STMT
  _39 = config_61(D)->options[0];
  _40 = (long unsigned int) _39;
  regValue_87 = regValue_86 | _40;
  # DEBUG regValue => regValue_87
  # DEBUG BEGIN_STMT
  _41 = cgm[instance_62][selectorIndex_63];
  _41->divider[dividerIndex_64] ={v} regValue_87;
  goto <bb 18>; [INV]

  <bb 17> :
  # DEBUG BEGIN_STMT
  _42 = config_61(D)->name;
  ReportClockErrors (1, _42);

  <bb 18> :
  # DEBUG BEGIN_STMT
  _43 = config_61(D)->value;
  if (_43 != 0)
    goto <bb 19>; [INV]
  else
    goto <bb 22>; [INV]

  <bb 19> :
  # DEBUG BEGIN_STMT
  _44 = cgm[instance_62][selectorIndex_63];
  _45 ={v} _44->divider[dividerIndex_64];
  _46 = cgm[instance_62][selectorIndex_63];
  _47 = _45 | 2147483648;
  _46->divider[dividerIndex_64] ={v} _47;
  # DEBUG BEGIN_STMT
  _48 = config_61(D)->name;
  _49 = GetClockState (_48);
  if (_49 == 0)
    goto <bb 20>; [INV]
  else
    goto <bb 22>; [INV]

  <bb 20> :
  # DEBUG BEGIN_STMT
  _50 = config_61(D)->name;
  UpdateClockState (_50, 255);
  goto <bb 22>; [INV]

  <bb 21> :
  # DEBUG BEGIN_STMT
  _51 = config_61(D)->name;
  ReportClockErrors (1, _51);

  <bb 22> :
  StartTime ={v} {CLOBBER};
  ElapsedTime ={v} {CLOBBER};
  TimeoutTicks ={v} {CLOBBER};
  return;

}


SetCgmXDeDivStatWithoutPhase (const struct Clock_Ip_DividerConfigType * config)
{
  boolean immediateTriggerIsUpdated;
  uint32 DividerStatus;
  uint32 TimeoutTicks;
  uint32 ElapsedTime;
  uint32 StartTime;
  boolean TimeoutOccurred;
  uint32 regValue;
  uint32 triggerFeat;
  uint32 dividerIndex;
  uint32 selectorIndex;
  uint32 instance;
  <unnamed type> _1;
  int _2;
  unsigned char _3;
  <unnamed type> _4;
  int _5;
  unsigned char _6;
  <unnamed type> _7;
  int _8;
  unsigned char _9;
  <unnamed type> _10;
  int _11;
  unsigned char _12;
  long unsigned int _13;
  volatile struct cgmMux_Type * _14;
  long unsigned int _15;
  long unsigned int _16;
  long unsigned int _17;
  long unsigned int _18;
  volatile struct cgmMux_Type * _19;
  volatile struct cgmMux_Type * _20;
  long unsigned int _21;
  long unsigned int _22;
  volatile struct cgmMux_Type * _23;
  long unsigned int _24;
  long unsigned int TimeoutTicks.5_25;
  _Bool _26;
  _Bool _27;
  long unsigned int _28;
  volatile struct cgmMux_Type * _29;
  long unsigned int _30;
  volatile struct cgmMux_Type * _31;
  long unsigned int _32;
  <unnamed type> _33;
  <unnamed type> _34;
  <unnamed type> _35;
  volatile struct cgmMux_Type * _36;
  long unsigned int _37;
  volatile struct cgmMux_Type * _38;
  long unsigned int _39;
  <unnamed type> _40;
  <unnamed type> _41;

  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = config_49(D)->name;
  _2 = (int) _1;
  _3 = clockFeatures[_2][0];
  instance_50 = (uint32) _3;
  # DEBUG instance => instance_50
  # DEBUG BEGIN_STMT
  _4 = config_49(D)->name;
  _5 = (int) _4;
  _6 = clockFeatures[_5][2];
  selectorIndex_51 = (uint32) _6;
  # DEBUG selectorIndex => selectorIndex_51
  # DEBUG BEGIN_STMT
  _7 = config_49(D)->name;
  _8 = (int) _7;
  _9 = clockFeatures[_8][3];
  dividerIndex_52 = (uint32) _9;
  # DEBUG dividerIndex => dividerIndex_52
  # DEBUG BEGIN_STMT
  _10 = config_49(D)->name;
  _11 = (int) _10;
  _12 = clockFeatures[_11][5];
  triggerFeat_53 = (uint32) _12;
  # DEBUG triggerFeat => triggerFeat_53
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  TimeoutOccurred_54 = 0;
  # DEBUG TimeoutOccurred => TimeoutOccurred_54
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  immediateTriggerIsUpdated_55 = 1;
  # DEBUG immediateTriggerIsUpdated => immediateTriggerIsUpdated_55
  # DEBUG BEGIN_STMT
  _13 = config_49(D)->value;
  if (_13 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _14 = cgm[instance_50][selectorIndex_51];
  regValue_56 ={v} _14->divider[dividerIndex_52];
  # DEBUG regValue => regValue_56
  # DEBUG BEGIN_STMT
  regValue_57 = regValue_56 & 4290838527;
  # DEBUG regValue => regValue_57
  # DEBUG BEGIN_STMT
  _15 = config_49(D)->value;
  _16 = _15 + 4294967295;
  _17 = _16 << 16;
  _18 = _17 & 4128768;
  regValue_58 = regValue_57 | _18;
  # DEBUG regValue => regValue_58
  # DEBUG BEGIN_STMT
  _19 = cgm[instance_50][selectorIndex_51];
  _19->divider[dividerIndex_52] ={v} regValue_58;

  <bb 4> :
  # DEBUG BEGIN_STMT
  if (triggerFeat_53 == 1)
    goto <bb 5>; [INV]
  else
    goto <bb 7>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  _20 = cgm[instance_50][selectorIndex_51];
  _21 ={v} _20->MUX_DIV_TRIG_CTRL;
  _22 = _21 & 1;
  if (_22 == 1)
    goto <bb 6>; [INV]
  else
    goto <bb 7>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  immediateTriggerIsUpdated_60 = 0;
  # DEBUG immediateTriggerIsUpdated => immediateTriggerIsUpdated_60

  <bb 7> :
  # immediateTriggerIsUpdated_43 = PHI <immediateTriggerIsUpdated_55(4), immediateTriggerIsUpdated_55(5), immediateTriggerIsUpdated_60(6)>
  # DEBUG immediateTriggerIsUpdated => immediateTriggerIsUpdated_43
  # DEBUG BEGIN_STMT
  if (immediateTriggerIsUpdated_43 != 0)
    goto <bb 8>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 8> :
  # DEBUG BEGIN_STMT
  ClockStartTimeout (&StartTime, &ElapsedTime, &TimeoutTicks, 10000);

  <bb 9> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _23 = cgm[instance_50][selectorIndex_51];
  _24 ={v} _23->MUX_DIV_UPD_STAT;
  DividerStatus_62 = _24 & 1;
  # DEBUG DividerStatus => DividerStatus_62
  # DEBUG BEGIN_STMT
  TimeoutTicks.5_25 = TimeoutTicks;
  TimeoutOccurred_64 = ClockTimeoutExpired (&StartTime, &ElapsedTime, TimeoutTicks.5_25);
  # DEBUG TimeoutOccurred => TimeoutOccurred_64
  # DEBUG BEGIN_STMT
  if (DividerStatus_62 == 1)
    goto <bb 10>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 10> :
  _26 = ~TimeoutOccurred_64;
  if (_26 != 0)
    goto <bb 9>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 11> :
  # TimeoutOccurred_42 = PHI <TimeoutOccurred_54(7), TimeoutOccurred_64(9), TimeoutOccurred_64(10)>
  # DEBUG TimeoutOccurred => TimeoutOccurred_42
  # DEBUG BEGIN_STMT
  _27 = ~TimeoutOccurred_42;
  if (_27 != 0)
    goto <bb 12>; [INV]
  else
    goto <bb 16>; [INV]

  <bb 12> :
  # DEBUG BEGIN_STMT
  _28 = config_49(D)->value;
  if (_28 != 0)
    goto <bb 13>; [INV]
  else
    goto <bb 15>; [INV]

  <bb 13> :
  # DEBUG BEGIN_STMT
  _29 = cgm[instance_50][selectorIndex_51];
  _30 ={v} _29->divider[dividerIndex_52];
  _31 = cgm[instance_50][selectorIndex_51];
  _32 = _30 | 2147483648;
  _31->divider[dividerIndex_52] ={v} _32;
  # DEBUG BEGIN_STMT
  _33 = config_49(D)->name;
  _34 = GetClockState (_33);
  if (_34 == 0)
    goto <bb 14>; [INV]
  else
    goto <bb 17>; [INV]

  <bb 14> :
  # DEBUG BEGIN_STMT
  _35 = config_49(D)->name;
  UpdateClockState (_35, 255);
  goto <bb 17>; [INV]

  <bb 15> :
  # DEBUG BEGIN_STMT
  _36 = cgm[instance_50][selectorIndex_51];
  _37 ={v} _36->divider[dividerIndex_52];
  _38 = cgm[instance_50][selectorIndex_51];
  _39 = _37 & 2147483647;
  _38->divider[dividerIndex_52] ={v} _39;
  # DEBUG BEGIN_STMT
  _40 = config_49(D)->name;
  UpdateClockState (_40, 0);
  goto <bb 17>; [INV]

  <bb 16> :
  # DEBUG BEGIN_STMT
  _41 = config_49(D)->name;
  ReportClockErrors (1, _41);

  <bb 17> :
  StartTime ={v} {CLOBBER};
  ElapsedTime ={v} {CLOBBER};
  TimeoutTicks ={v} {CLOBBER};
  return;

}


Callback_DividerEmpty (const struct Clock_Ip_DividerConfigType * config)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  return;

}


