ClockTimeoutExpired (uint32 * startTimeInOut, uint32 * elapsedTimeInOut, uint32 TimeoutTicks)
{
  long unsigned int _1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _7;
  boolean _11;

  <bb 2> :
  # DEBUG BEGIN_STMT
  _7 = OsIf_GetElapsed (startTimeInOut_5(D), 0);
  _1 = *elapsedTimeInOut_8(D);
  _2 = _7 + _1;
  *elapsedTimeInOut_8(D) = _2;
  # DEBUG BEGIN_STMT
  _3 = *elapsedTimeInOut_8(D);
  _11 = TimeoutTicks_10(D) <= _3;
  return _11;

}


ClockStartTimeout (uint32 * startTimeOut, uint32 * elapsedTimeOut, uint32 * timeoutTicksOut, uint32 timeoutUs)
{
  long unsigned int _1;
  long unsigned int _2;

  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = OsIf_GetCounter (0);
  *startTimeOut_5(D) = _1;
  # DEBUG BEGIN_STMT
  *elapsedTimeOut_7(D) = 0;
  # DEBUG BEGIN_STMT
  _2 = OsIf_MicrosToTicks (timeoutUs_9(D), 0);
  *timeoutTicksOut_11(D) = _2;
  return;

}


ReportClockErrors (Clock_Ip_ClockNotificationType error, Clock_Ip_NameType clockName)
{
  void (*<T2cc>) (Clock_Ip_ClockNotificationType, Clock_Ip_NameType) clockNotificationsCallback.21_1;

  <bb 2> :
  # DEBUG BEGIN_STMT
  clockNotificationsCallback.21_1 = clockNotificationsCallback;
  clockNotificationsCallback.21_1 (error_3(D), clockName_4(D));
  return;

}


ClockNotificatonsEmptyCallback (Clock_Ip_ClockNotificationType notification, Clock_Ip_NameType clockName)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  return;

}


Clock_Ip_TimeDelay ()
{
  unsigned char ClockCalcFreqCallIdx.17_1;
  int _2;
  void (*<T4af>) (void) _3;
  unsigned char ClockCalcFreqCallIdx.18_4;
  unsigned char ClockCalcFreqCallIdx.19_5;
  unsigned char ClockCalcFreqCallIdx.20_6;
  unsigned char _7;

  <bb 2> :
  # DEBUG BEGIN_STMT
  ClockCalcFreqCallIdx.17_1 = ClockCalcFreqCallIdx;
  _2 = (int) ClockCalcFreqCallIdx.17_1;
  _3 = calcFreqCallbacks[_2];
  _3 ();
  # DEBUG BEGIN_STMT
  ClockCalcFreqCallIdx.18_4 = ClockCalcFreqCallIdx;
  if (ClockCalcFreqCallIdx.18_4 <= 33)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  ClockCalcFreqCallIdx.19_5 = ClockCalcFreqCallIdx;
  ClockCalcFreqCallIdx.20_6 = ClockCalcFreqCallIdx.19_5;
  _7 = ClockCalcFreqCallIdx.20_6 + 1;
  ClockCalcFreqCallIdx = _7;

  <bb 4> :
  return;

}


Clock_Ip_Sleep ()
{
  unsigned char ClockCalcFreqCallIdx.3_1;
  int _2;
  void (*<T4af>) (void) _3;
  unsigned char ClockCalcFreqCallIdx.4_4;
  unsigned char ClockCalcFreqCallIdx.5_5;
  unsigned char _6;
  unsigned char ClockCalcFreqCallIdx.6_7;

  <bb 2> :
  # DEBUG BEGIN_STMT
  goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  ClockCalcFreqCallIdx.3_1 = ClockCalcFreqCallIdx;
  _2 = (int) ClockCalcFreqCallIdx.3_1;
  _3 = calcFreqCallbacks[_2];
  _3 ();
  # DEBUG BEGIN_STMT
  ClockCalcFreqCallIdx.4_4 = ClockCalcFreqCallIdx;
  ClockCalcFreqCallIdx.5_5 = ClockCalcFreqCallIdx.4_4;
  _6 = ClockCalcFreqCallIdx.5_5 + 1;
  ClockCalcFreqCallIdx = _6;

  <bb 4> :
  # DEBUG BEGIN_STMT
  ClockCalcFreqCallIdx.6_7 = ClockCalcFreqCallIdx;
  if (ClockCalcFreqCallIdx.6_7 <= 33)
    goto <bb 3>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 5> :
  return;

}


Clock_Ip_GetClockFrequency (Clock_Ip_NameType clockName)
{
  uint32 frequency;
  long unsigned int _1;
  long unsigned int _2;
  uint32 (*<T4ac>) (void) _3;
  uint32 _12;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  if (clockName_6(D) > 21)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) clockName_6(D);
  _2 = _1 + 4294967274;
  _3 = consumerClockCallbacks[_2];
  frequency_11 = _3 ();
  # DEBUG frequency => frequency_11
  goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  frequency_9 = GetProducerClockFreq (clockName_6(D));
  # DEBUG frequency => frequency_9

  <bb 5> :
  # frequency_4 = PHI <frequency_11(3), frequency_9(4)>
  # DEBUG frequency => frequency_4
  # DEBUG BEGIN_STMT
  _12 = frequency_4;
  return _12;

}


Clock_Ip_EnableModuleClock (Clock_Ip_NameType clockName)
{
  uint32 callbackIndex;
  int _1;
  unsigned char _2;
  int _3;
  unsigned char _4;
  void (*<T489>) (Clock_Ip_NameType, boolean) _5;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = (int) clockName_6(D);
  _2 = clockFeatures[_1][1];
  _3 = (int) _2;
  _4 = gateCallbackIndex[_3];
  callbackIndex_8 = (uint32) _4;
  # DEBUG callbackIndex => callbackIndex_8
  # DEBUG BEGIN_STMT
  _5 = gateCallbacks[callbackIndex_8].Update;
  _5 (clockName_6(D), 0);
  return;

}


Clock_Ip_DisableModuleClock (Clock_Ip_NameType clockName)
{
  uint32 callbackIndex;
  int _1;
  unsigned char _2;
  int _3;
  unsigned char _4;
  void (*<T489>) (Clock_Ip_NameType, boolean) _5;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = (int) clockName_6(D);
  _2 = clockFeatures[_1][1];
  _3 = (int) _2;
  _4 = gateCallbackIndex[_3];
  callbackIndex_8 = (uint32) _4;
  # DEBUG callbackIndex => callbackIndex_8
  # DEBUG BEGIN_STMT
  _5 = gateCallbacks[callbackIndex_8].Update;
  _5 (clockName_6(D), 1);
  return;

}


Clock_Ip_InstallNotificationsCallback (void (*Clock_Ip_NotificationsCallbackType) (Clock_Ip_ClockNotificationType, Clock_Ip_NameType) callback)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  clockNotificationsCallback = callback_2(D);
  return;

}


Clock_Ip_PowerModeChangeNotification (power_modes_t powerMode, power_notification_t notification)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  UpdateFrequencies (powerMode_2(D));
  return;

}


Clock_Ip_ClearClockMonitorStatus (Clock_Ip_NameType clockName)
{
  uint32 callbackIndex;
  int _1;
  unsigned char _2;
  int _3;
  unsigned char _4;
  void (*<T498>) (Clock_Ip_NameType) _5;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = (int) clockName_6(D);
  _2 = clockFeatures[_1][1];
  _3 = (int) _2;
  _4 = cmuCallbackIndex[_3];
  callbackIndex_8 = (uint32) _4;
  # DEBUG callbackIndex => callbackIndex_8
  # DEBUG BEGIN_STMT
  _5 = cmuCallbacks[callbackIndex_8].Clear;
  _5 (clockName_6(D));
  return;

}


Clock_Ip_GetClockMonitorStatus (Clock_Ip_NameType clockName)
{
  uint32 callbackIndex;
  int _1;
  unsigned char _2;
  int _3;
  unsigned char _4;
  Clock_Ip_CmuStatusType (*<T49c>) (Clock_Ip_NameType) _5;
  Clock_Ip_CmuStatusType _10;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = (int) clockName_6(D);
  _2 = clockFeatures[_1][1];
  _3 = (int) _2;
  _4 = cmuCallbackIndex[_3];
  callbackIndex_8 = (uint32) _4;
  # DEBUG callbackIndex => callbackIndex_8
  # DEBUG BEGIN_STMT
  _5 = cmuCallbacks[callbackIndex_8].GetStatus;
  _10 = _5 (clockName_6(D));
  return _10;

}


Clock_Ip_DisableClockMonitor (Clock_Ip_NameType clockName)
{
  uint32 callbackIndex;
  int _1;
  unsigned char _2;
  int _3;
  unsigned char _4;
  void (*<T498>) (Clock_Ip_NameType) _5;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = (int) clockName_6(D);
  _2 = clockFeatures[_1][1];
  _3 = (int) _2;
  _4 = cmuCallbackIndex[_3];
  callbackIndex_8 = (uint32) _4;
  # DEBUG callbackIndex => callbackIndex_8
  # DEBUG BEGIN_STMT
  _5 = cmuCallbacks[callbackIndex_8].Disable;
  _5 (clockName_6(D));
  return;

}


Clock_Ip_DistributePll ()
{
  uint32 callbackIndex;
  uint32 i;
  const struct Clock_Ip_ClockConfigType * clockConfig.7_1;
  const struct Clock_Ip_ClockConfigType * clockConfig.8_2;
  <unnamed type> _3;
  int _4;
  <unnamed type> _5;
  const struct Clock_Ip_ClockConfigType * clockConfig.9_6;
  <unnamed type> _7;
  int _8;
  unsigned char _9;
  int _10;
  unsigned char _11;
  void (*<T478>) (const struct Clock_Ip_SelectorConfigType *) _12;
  const struct Clock_Ip_ClockConfigType * clockConfig.10_13;
  const struct Clock_Ip_SelectorConfigType * _14;
  const struct Clock_Ip_ClockConfigType * clockConfig.11_15;
  unsigned char _16;
  long unsigned int _17;
  _Bool clockTreeIsConsumingPll.12_18;
  const struct Clock_Ip_ClockConfigType * clockConfig.13_19;
  const struct Clock_IP_SpecificPeriphConfigType * _20;
  const struct Clock_Ip_ClockConfigType * clockConfig.14_21;
  <unnamed type> _22;
  int _23;
  unsigned char _24;
  int _25;
  unsigned char _26;
  void (*<T494>) (const struct Clock_Ip_CmuConfigType *) _27;
  const struct Clock_Ip_ClockConfigType * clockConfig.15_28;
  const struct Clock_Ip_CmuConfigType * _29;
  const struct Clock_Ip_ClockConfigType * clockConfig.16_30;
  unsigned char _31;
  long unsigned int _32;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  clockConfig.7_1 = clockConfig;
  if (clockConfig.7_1 != 0B)
    goto <bb 3>; [INV]
  else
    goto <bb 12>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  i_40 = 0;
  # DEBUG i => i_40
  goto <bb 7>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  clockConfig.8_2 = clockConfig;
  _3 = clockConfig.8_2->selectors[i_33].value;
  _4 = (int) _3;
  _5 = clockName_sourceType[_4];
  if (_5 != 1)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  clockConfig.9_6 = clockConfig;
  _7 = clockConfig.9_6->selectors[i_33].name;
  _8 = (int) _7;
  _9 = clockFeatures[_8][1];
  _10 = (int) _9;
  _11 = selectorCallbackIndex[_10];
  callbackIndex_46 = (uint32) _11;
  # DEBUG callbackIndex => callbackIndex_46
  # DEBUG BEGIN_STMT
  _12 = selectorCallbacks[callbackIndex_46].Set;
  clockConfig.10_13 = clockConfig;
  _14 = &clockConfig.10_13->selectors[i_33];
  _12 (_14);

  <bb 6> :
  # DEBUG BEGIN_STMT
  i_48 = i_33 + 1;
  # DEBUG i => i_48

  <bb 7> :
  # i_33 = PHI <i_40(3), i_48(6)>
  # DEBUG i => i_33
  # DEBUG BEGIN_STMT
  clockConfig.11_15 = clockConfig;
  _16 = clockConfig.11_15->selectorsCount;
  _17 = (long unsigned int) _16;
  if (i_33 < _17)
    goto <bb 4>; [INV]
  else
    goto <bb 8>; [INV]

  <bb 8> :
  # DEBUG BEGIN_STMT
  clockTreeIsConsumingPll.12_18 = clockTreeIsConsumingPll;
  if (clockTreeIsConsumingPll.12_18 != 0)
    goto <bb 9>; [INV]
  else
    goto <bb 12>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  clockConfig.13_19 = clockConfig;
  _20 = &clockConfig.13_19->specificPeriphalConfiguration;
  SpecificPeripheralClockInitialization (_20);
  # DEBUG BEGIN_STMT
  i_42 = 0;
  # DEBUG i => i_42
  goto <bb 11>; [INV]

  <bb 10> :
  # DEBUG BEGIN_STMT
  clockConfig.14_21 = clockConfig;
  _22 = clockConfig.14_21->cmus[i_34].name;
  _23 = (int) _22;
  _24 = clockFeatures[_23][1];
  _25 = (int) _24;
  _26 = cmuCallbackIndex[_25];
  callbackIndex_43 = (uint32) _26;
  # DEBUG callbackIndex => callbackIndex_43
  # DEBUG BEGIN_STMT
  _27 = cmuCallbacks[callbackIndex_43].Set;
  clockConfig.15_28 = clockConfig;
  _29 = &clockConfig.15_28->cmus[i_34];
  _27 (_29);
  # DEBUG BEGIN_STMT
  i_45 = i_34 + 1;
  # DEBUG i => i_45

  <bb 11> :
  # i_34 = PHI <i_42(9), i_45(10)>
  # DEBUG i => i_34
  # DEBUG BEGIN_STMT
  clockConfig.16_30 = clockConfig;
  _31 = clockConfig.16_30->cmusCount;
  _32 = (long unsigned int) _31;
  if (i_34 < _32)
    goto <bb 10>; [INV]
  else
    goto <bb 12>; [INV]

  <bb 12> :
  # DEBUG BEGIN_STMT
  UpdateFrequencies (0);
  return;

}


Clock_Ip_GetPllStatus ()
{
  uint32 callbackIndex;
  uint32 i;
  clock_pll_status_t pllStatus;
  Clock_Ip_PllStatusType retValue;
  <unnamed type> _1;
  int _2;
  unsigned char _3;
  int _4;
  unsigned char _5;
  clock_pll_status_t (*<T46d>) (Clock_Ip_NameType) _6;
  <unnamed type> _7;
  Clock_Ip_PllStatusType _23;

  <bb 2> :
  # DEBUG BEGIN_STMT
  retValue_14 = 2;
  # DEBUG retValue => retValue_14
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  i_15 = 0;
  # DEBUG i => i_15
  goto <bb 8>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _1 = HwPllName[i_11];
  _2 = (int) _1;
  _3 = clockFeatures[_2][1];
  _4 = (int) _3;
  _5 = pllCallbackIndex[_4];
  callbackIndex_17 = (uint32) _5;
  # DEBUG callbackIndex => callbackIndex_17
  # DEBUG BEGIN_STMT
  _6 = pllCallbacks[callbackIndex_17].Complete;
  _7 = HwPllName[i_11];
  pllStatus_19 = _6 (_7);
  # DEBUG pllStatus => pllStatus_19
  # DEBUG BEGIN_STMT
  if (pllStatus_19 == 1)
    goto <bb 4>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  retValue_22 = 1;
  # DEBUG retValue => retValue_22
  # DEBUG BEGIN_STMT
  goto <bb 9>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  if (pllStatus_19 == 2)
    goto <bb 6>; [INV]
  else
    goto <bb 7>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  retValue_20 = 0;
  # DEBUG retValue => retValue_20

  <bb 7> :
  # retValue_8 = PHI <retValue_9(5), retValue_20(6)>
  # DEBUG retValue => retValue_8
  # DEBUG BEGIN_STMT
  i_21 = i_11 + 1;
  # DEBUG i => i_21

  <bb 8> :
  # retValue_9 = PHI <retValue_14(2), retValue_8(7)>
  # i_11 = PHI <i_15(2), i_21(7)>
  # DEBUG i => i_11
  # DEBUG retValue => retValue_9
  # DEBUG BEGIN_STMT
  if (i_11 == 0)
    goto <bb 3>; [INV]
  else
    goto <bb 9>; [INV]

  <bb 9> :
  # retValue_10 = PHI <retValue_22(4), retValue_9(8)>
  # DEBUG retValue => retValue_10
  # DEBUG BEGIN_STMT
  _23 = retValue_10;
  return _23;

}


Clock_Ip_InitClock (const struct Clock_Ip_ClockConfigType * config)
{
  uint32 i;
  uint32 callbackIndex;
  const struct Clock_Ip_ClockConfigType * clockConfig.1_1;
  <unnamed type> _2;
  int _3;
  unsigned char _4;
  int _5;
  unsigned char _6;
  void (*<T494>) (const struct Clock_Ip_CmuConfigType *) _7;
  const struct Clock_Ip_CmuConfigType * _8;
  unsigned char _9;
  long unsigned int _10;
  <unnamed type> _11;
  int _12;
  unsigned char _13;
  int _14;
  unsigned char _15;
  void (*<T478>) (const struct Clock_Ip_SelectorConfigType *) _16;
  const struct Clock_Ip_SelectorConfigType * _17;
  unsigned char _18;
  long unsigned int _19;
  <unnamed type> _20;
  int _21;
  unsigned char _22;
  int _23;
  unsigned char _24;
  void (*<T456>) (const struct Clock_Ip_FracDivConfigType *) _25;
  const struct Clock_Ip_FracDivConfigType * _26;
  unsigned char _27;
  long unsigned int _28;
  <unnamed type> _29;
  int _30;
  unsigned char _31;
  int _32;
  unsigned char _33;
  void (*<T467>) (const struct Clock_Ip_PllConfigType *) _34;
  const struct Clock_Ip_PllConfigType * _35;
  unsigned char _36;
  long unsigned int _37;
  <unnamed type> _38;
  int _39;
  unsigned char _40;
  int _41;
  unsigned char _42;
  void (*<T433>) (const struct Clock_Ip_XoscConfigType *) _43;
  const struct Clock_Ip_XoscConfigType * _44;
  unsigned char _45;
  long unsigned int _46;
  <unnamed type> _47;
  int _48;
  unsigned char _49;
  int _50;
  unsigned char _51;
  void (*<T428>) (const struct Clock_Ip_IrcoscConfigType *) _52;
  const struct Clock_Ip_IrcoscConfigType * _53;
  unsigned char _54;
  long unsigned int _55;
  <unnamed type> _56;
  int _57;
  unsigned char _58;
  int _59;
  unsigned char _60;
  void (*<T433>) (const struct Clock_Ip_XoscConfigType *) _61;
  const struct Clock_Ip_XoscConfigType * _62;
  unsigned char _63;
  long unsigned int _64;
  <unnamed type> _65;
  int _66;
  unsigned char _67;
  int _68;
  unsigned char _69;
  void (*<T4a7>) (const struct Clock_Ip_PcfsConfigType *) _70;
  const struct Clock_Ip_PcfsConfigType * _71;
  unsigned char _72;
  long unsigned int _73;
  <unnamed type> _74;
  int _75;
  unsigned char _76;
  int _77;
  unsigned char _78;
  void (*<T44a>) (const struct Clock_Ip_DividerTriggerConfigType *) _79;
  const struct Clock_Ip_DividerTriggerConfigType * _80;
  unsigned char _81;
  long unsigned int _82;
  <unnamed type> _83;
  int _84;
  unsigned char _85;
  int _86;
  unsigned char _87;
  void (*<T43f>) (const struct Clock_Ip_DividerConfigType *) _88;
  const struct Clock_Ip_DividerConfigType * _89;
  unsigned char _90;
  long unsigned int _91;
  <unnamed type> _92;
  int _93;
  unsigned char _94;
  int _95;
  unsigned char _96;
  void (*<T44a>) (const struct Clock_Ip_DividerTriggerConfigType *) _97;
  const struct Clock_Ip_DividerTriggerConfigType * _98;
  unsigned char _99;
  long unsigned int _100;
  <unnamed type> _101;
  int _102;
  unsigned char _103;
  int _104;
  unsigned char _105;
  void (*<T467>) (const struct Clock_Ip_PllConfigType *) _106;
  const struct Clock_Ip_PllConfigType * _107;
  unsigned char _108;
  long unsigned int _109;
  <unnamed type> _110;
  int _111;
  unsigned char _112;
  int _113;
  unsigned char _114;
  void (*<T456>) (const struct Clock_Ip_FracDivConfigType *) _115;
  const struct Clock_Ip_FracDivConfigType * _116;
  unsigned char _117;
  long unsigned int _118;
  <unnamed type> _119;
  int _120;
  <unnamed type> _121;
  <unnamed type> _122;
  int _123;
  unsigned char _124;
  int _125;
  unsigned char _126;
  void (*<T478>) (const struct Clock_Ip_SelectorConfigType *) _127;
  const struct Clock_Ip_SelectorConfigType * _128;
  unsigned char _129;
  long unsigned int _130;
  <unnamed type> _131;
  int _132;
  unsigned char _133;
  int _134;
  unsigned char _135;
  void (*<T484>) (const struct Clock_Ip_GateConfigType *) _136;
  const struct Clock_Ip_GateConfigType * _137;
  unsigned char _138;
  long unsigned int _139;
  _Bool clockTreeIsConsumingPll.2_140;
  _Bool _141;
  const struct Clock_IP_SpecificPeriphConfigType * _142;
  <unnamed type> _143;
  int _144;
  unsigned char _145;
  int _146;
  unsigned char _147;
  void (*<T494>) (const struct Clock_Ip_CmuConfigType *) _148;
  const struct Clock_Ip_CmuConfigType * _149;
  unsigned char _150;
  long unsigned int _151;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  ClockCalcFreqCallIdx = 0;
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  clockConfig.1_1 = clockConfig;
  if (clockConfig.1_1 != 0B)
    goto <bb 3>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  i_189 = 0;
  # DEBUG i => i_189
  goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _2 = config_190(D)->cmus[i_152].name;
  _3 = (int) _2;
  _4 = clockFeatures[_3][1];
  _5 = (int) _4;
  _6 = cmuCallbackIndex[_5];
  callbackIndex_191 = (uint32) _6;
  # DEBUG callbackIndex => callbackIndex_191
  # DEBUG BEGIN_STMT
  _7 = cmuCallbacks[callbackIndex_191].Reset;
  _8 = &config_190(D)->cmus[i_152];
  _7 (_8);
  # DEBUG BEGIN_STMT
  i_193 = i_152 + 1;
  # DEBUG i => i_193

  <bb 5> :
  # i_152 = PHI <i_189(3), i_193(4)>
  # DEBUG i => i_152
  # DEBUG BEGIN_STMT
  _9 = config_190(D)->cmusCount;
  _10 = (long unsigned int) _9;
  if (i_152 < _10)
    goto <bb 4>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  clockConfig = config_190(D);
  # DEBUG BEGIN_STMT
  SpecificPlatformInitClock (config_190(D));
  # DEBUG BEGIN_STMT
  i_196 = 0;
  # DEBUG i => i_196
  goto <bb 8>; [INV]

  <bb 7> :
  # DEBUG BEGIN_STMT
  _11 = config_190(D)->selectors[i_153].name;
  _12 = (int) _11;
  _13 = clockFeatures[_12][1];
  _14 = (int) _13;
  _15 = selectorCallbackIndex[_14];
  callbackIndex_258 = (uint32) _15;
  # DEBUG callbackIndex => callbackIndex_258
  # DEBUG BEGIN_STMT
  _16 = selectorCallbacks[callbackIndex_258].Reset;
  _17 = &config_190(D)->selectors[i_153];
  _16 (_17);
  # DEBUG BEGIN_STMT
  i_260 = i_153 + 1;
  # DEBUG i => i_260

  <bb 8> :
  # i_153 = PHI <i_196(6), i_260(7)>
  # DEBUG i => i_153
  # DEBUG BEGIN_STMT
  _18 = config_190(D)->selectorsCount;
  _19 = (long unsigned int) _18;
  if (i_153 < _19)
    goto <bb 7>; [INV]
  else
    goto <bb 9>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  i_197 = 0;
  # DEBUG i => i_197
  goto <bb 11>; [INV]

  <bb 10> :
  # DEBUG BEGIN_STMT
  _20 = config_190(D)->fracDivs[i_154].name;
  _21 = (int) _20;
  _22 = clockFeatures[_21][1];
  _23 = (int) _22;
  _24 = fractional_dividerCallbackIndex[_23];
  callbackIndex_255 = (uint32) _24;
  # DEBUG callbackIndex => callbackIndex_255
  # DEBUG BEGIN_STMT
  _25 = fracDivCallbacks[callbackIndex_255].Reset;
  _26 = &config_190(D)->fracDivs[i_154];
  _25 (_26);
  # DEBUG BEGIN_STMT
  i_257 = i_154 + 1;
  # DEBUG i => i_257

  <bb 11> :
  # i_154 = PHI <i_197(9), i_257(10)>
  # DEBUG i => i_154
  # DEBUG BEGIN_STMT
  _27 = config_190(D)->fracDivsCount;
  _28 = (long unsigned int) _27;
  if (i_154 < _28)
    goto <bb 10>; [INV]
  else
    goto <bb 12>; [INV]

  <bb 12> :
  # DEBUG BEGIN_STMT
  i_198 = 0;
  # DEBUG i => i_198
  goto <bb 14>; [INV]

  <bb 13> :
  # DEBUG BEGIN_STMT
  _29 = config_190(D)->plls[i_155].name;
  _30 = (int) _29;
  _31 = clockFeatures[_30][1];
  _32 = (int) _31;
  _33 = pllCallbackIndex[_32];
  callbackIndex_252 = (uint32) _33;
  # DEBUG callbackIndex => callbackIndex_252
  # DEBUG BEGIN_STMT
  _34 = pllCallbacks[callbackIndex_252].Reset;
  _35 = &config_190(D)->plls[i_155];
  _34 (_35);
  # DEBUG BEGIN_STMT
  i_254 = i_155 + 1;
  # DEBUG i => i_254

  <bb 14> :
  # i_155 = PHI <i_198(12), i_254(13)>
  # DEBUG i => i_155
  # DEBUG BEGIN_STMT
  _36 = config_190(D)->pllsCount;
  _37 = (long unsigned int) _36;
  if (i_155 < _37)
    goto <bb 13>; [INV]
  else
    goto <bb 15>; [INV]

  <bb 15> :
  # DEBUG BEGIN_STMT
  i_199 = 0;
  # DEBUG i => i_199
  goto <bb 17>; [INV]

  <bb 16> :
  # DEBUG BEGIN_STMT
  _38 = config_190(D)->xoscs[i_156].name;
  _39 = (int) _38;
  _40 = clockFeatures[_39][1];
  _41 = (int) _40;
  _42 = xoscCallbackIndex[_41];
  callbackIndex_249 = (uint32) _42;
  # DEBUG callbackIndex => callbackIndex_249
  # DEBUG BEGIN_STMT
  _43 = extOscCallbacks[callbackIndex_249].Reset;
  _44 = &config_190(D)->xoscs[i_156];
  _43 (_44);
  # DEBUG BEGIN_STMT
  i_251 = i_156 + 1;
  # DEBUG i => i_251

  <bb 17> :
  # i_156 = PHI <i_199(15), i_251(16)>
  # DEBUG i => i_156
  # DEBUG BEGIN_STMT
  _45 = config_190(D)->xoscsCount;
  _46 = (long unsigned int) _45;
  if (i_156 < _46)
    goto <bb 16>; [INV]
  else
    goto <bb 18>; [INV]

  <bb 18> :
  # DEBUG BEGIN_STMT
  i_200 = 0;
  # DEBUG i => i_200
  goto <bb 20>; [INV]

  <bb 19> :
  # DEBUG BEGIN_STMT
  _47 = config_190(D)->ircoscs[i_157].name;
  _48 = (int) _47;
  _49 = clockFeatures[_48][1];
  _50 = (int) _49;
  _51 = ircoscCallbackIndex[_50];
  callbackIndex_246 = (uint32) _51;
  # DEBUG callbackIndex => callbackIndex_246
  # DEBUG BEGIN_STMT
  _52 = intOscCallbacks[callbackIndex_246].Set;
  _53 = &config_190(D)->ircoscs[i_157];
  _52 (_53);
  # DEBUG BEGIN_STMT
  i_248 = i_157 + 1;
  # DEBUG i => i_248

  <bb 20> :
  # i_157 = PHI <i_200(18), i_248(19)>
  # DEBUG i => i_157
  # DEBUG BEGIN_STMT
  _54 = config_190(D)->ircoscsCount;
  _55 = (long unsigned int) _54;
  if (i_157 < _55)
    goto <bb 19>; [INV]
  else
    goto <bb 21>; [INV]

  <bb 21> :
  # DEBUG BEGIN_STMT
  i_201 = 0;
  # DEBUG i => i_201
  goto <bb 23>; [INV]

  <bb 22> :
  # DEBUG BEGIN_STMT
  _56 = config_190(D)->xoscs[i_158].name;
  _57 = (int) _56;
  _58 = clockFeatures[_57][1];
  _59 = (int) _58;
  _60 = xoscCallbackIndex[_59];
  callbackIndex_243 = (uint32) _60;
  # DEBUG callbackIndex => callbackIndex_243
  # DEBUG BEGIN_STMT
  _61 = extOscCallbacks[callbackIndex_243].Set;
  _62 = &config_190(D)->xoscs[i_158];
  _61 (_62);
  # DEBUG BEGIN_STMT
  i_245 = i_158 + 1;
  # DEBUG i => i_245

  <bb 23> :
  # i_158 = PHI <i_201(21), i_245(22)>
  # DEBUG i => i_158
  # DEBUG BEGIN_STMT
  _63 = config_190(D)->xoscsCount;
  _64 = (long unsigned int) _63;
  if (i_158 < _64)
    goto <bb 22>; [INV]
  else
    goto <bb 24>; [INV]

  <bb 24> :
  # DEBUG BEGIN_STMT
  Clock_Ip_Sleep ();
  # DEBUG BEGIN_STMT
  i_203 = 0;
  # DEBUG i => i_203
  goto <bb 26>; [INV]

  <bb 25> :
  # DEBUG BEGIN_STMT
  _65 = config_190(D)->pcfs[i_159].name;
  _66 = (int) _65;
  _67 = clockFeatures[_66][1];
  _68 = (int) _67;
  _69 = pcfsCallbackIndex[_68];
  callbackIndex_240 = (uint32) _69;
  # DEBUG callbackIndex => callbackIndex_240
  # DEBUG BEGIN_STMT
  _70 = pcfsCallbacks[callbackIndex_240].Set;
  _71 = &config_190(D)->pcfs[i_159];
  _70 (_71);
  # DEBUG BEGIN_STMT
  i_242 = i_159 + 1;
  # DEBUG i => i_242

  <bb 26> :
  # i_159 = PHI <i_203(24), i_242(25)>
  # DEBUG i => i_159
  # DEBUG BEGIN_STMT
  _72 = config_190(D)->pcfsCount;
  _73 = (long unsigned int) _72;
  if (i_159 < _73)
    goto <bb 25>; [INV]
  else
    goto <bb 27>; [INV]

  <bb 27> :
  # DEBUG BEGIN_STMT
  i_204 = 0;
  # DEBUG i => i_204
  goto <bb 29>; [INV]

  <bb 28> :
  # DEBUG BEGIN_STMT
  _74 = config_190(D)->dividerTriggers[i_160].name;
  _75 = (int) _74;
  _76 = clockFeatures[_75][1];
  _77 = (int) _76;
  _78 = dividertriggerCallbackIndex[_77];
  callbackIndex_237 = (uint32) _78;
  # DEBUG callbackIndex => callbackIndex_237
  # DEBUG BEGIN_STMT
  _79 = dividerTriggerCallbacks[callbackIndex_237].Configure;
  _80 = &config_190(D)->dividerTriggers[i_160];
  _79 (_80);
  # DEBUG BEGIN_STMT
  i_239 = i_160 + 1;
  # DEBUG i => i_239

  <bb 29> :
  # i_160 = PHI <i_204(27), i_239(28)>
  # DEBUG i => i_160
  # DEBUG BEGIN_STMT
  _81 = config_190(D)->dividerTriggersCount;
  _82 = (long unsigned int) _81;
  if (i_160 < _82)
    goto <bb 28>; [INV]
  else
    goto <bb 30>; [INV]

  <bb 30> :
  # DEBUG BEGIN_STMT
  i_205 = 0;
  # DEBUG i => i_205
  goto <bb 32>; [INV]

  <bb 31> :
  # DEBUG BEGIN_STMT
  _83 = config_190(D)->dividers[i_161].name;
  _84 = (int) _83;
  _85 = clockFeatures[_84][1];
  _86 = (int) _85;
  _87 = dividerCallbackIndex[_86];
  callbackIndex_234 = (uint32) _87;
  # DEBUG callbackIndex => callbackIndex_234
  # DEBUG BEGIN_STMT
  _88 = dividerCallbacks[callbackIndex_234].Set;
  _89 = &config_190(D)->dividers[i_161];
  _88 (_89);
  # DEBUG BEGIN_STMT
  i_236 = i_161 + 1;
  # DEBUG i => i_236

  <bb 32> :
  # i_161 = PHI <i_205(30), i_236(31)>
  # DEBUG i => i_161
  # DEBUG BEGIN_STMT
  _90 = config_190(D)->dividersCount;
  _91 = (long unsigned int) _90;
  if (i_161 < _91)
    goto <bb 31>; [INV]
  else
    goto <bb 33>; [INV]

  <bb 33> :
  # DEBUG BEGIN_STMT
  i_206 = 0;
  # DEBUG i => i_206
  goto <bb 35>; [INV]

  <bb 34> :
  # DEBUG BEGIN_STMT
  _92 = config_190(D)->dividerTriggers[i_162].name;
  _93 = (int) _92;
  _94 = clockFeatures[_93][1];
  _95 = (int) _94;
  _96 = dividertriggerCallbackIndex[_95];
  callbackIndex_231 = (uint32) _96;
  # DEBUG callbackIndex => callbackIndex_231
  # DEBUG BEGIN_STMT
  _97 = dividerTriggerCallbacks[callbackIndex_231].TriggerUpdate;
  _98 = &config_190(D)->dividerTriggers[i_162];
  _97 (_98);
  # DEBUG BEGIN_STMT
  i_233 = i_162 + 1;
  # DEBUG i => i_233

  <bb 35> :
  # i_162 = PHI <i_206(33), i_233(34)>
  # DEBUG i => i_162
  # DEBUG BEGIN_STMT
  _99 = config_190(D)->dividerTriggersCount;
  _100 = (long unsigned int) _99;
  if (i_162 < _100)
    goto <bb 34>; [INV]
  else
    goto <bb 36>; [INV]

  <bb 36> :
  # DEBUG BEGIN_STMT
  i_207 = 0;
  # DEBUG i => i_207
  goto <bb 38>; [INV]

  <bb 37> :
  # DEBUG BEGIN_STMT
  _101 = config_190(D)->plls[i_163].name;
  _102 = (int) _101;
  _103 = clockFeatures[_102][1];
  _104 = (int) _103;
  _105 = pllCallbackIndex[_104];
  callbackIndex_228 = (uint32) _105;
  # DEBUG callbackIndex => callbackIndex_228
  # DEBUG BEGIN_STMT
  _106 = pllCallbacks[callbackIndex_228].Set;
  _107 = &config_190(D)->plls[i_163];
  _106 (_107);
  # DEBUG BEGIN_STMT
  i_230 = i_163 + 1;
  # DEBUG i => i_230

  <bb 38> :
  # i_163 = PHI <i_207(36), i_230(37)>
  # DEBUG i => i_163
  # DEBUG BEGIN_STMT
  _108 = config_190(D)->pllsCount;
  _109 = (long unsigned int) _108;
  if (i_163 < _109)
    goto <bb 37>; [INV]
  else
    goto <bb 39>; [INV]

  <bb 39> :
  # DEBUG BEGIN_STMT
  i_208 = 0;
  # DEBUG i => i_208
  goto <bb 41>; [INV]

  <bb 40> :
  # DEBUG BEGIN_STMT
  _110 = config_190(D)->fracDivs[i_164].name;
  _111 = (int) _110;
  _112 = clockFeatures[_111][1];
  _113 = (int) _112;
  _114 = fractional_dividerCallbackIndex[_113];
  callbackIndex_225 = (uint32) _114;
  # DEBUG callbackIndex => callbackIndex_225
  # DEBUG BEGIN_STMT
  _115 = fracDivCallbacks[callbackIndex_225].Set;
  _116 = &config_190(D)->fracDivs[i_164];
  _115 (_116);
  # DEBUG BEGIN_STMT
  i_227 = i_164 + 1;
  # DEBUG i => i_227

  <bb 41> :
  # i_164 = PHI <i_208(39), i_227(40)>
  # DEBUG i => i_164
  # DEBUG BEGIN_STMT
  _117 = config_190(D)->fracDivsCount;
  _118 = (long unsigned int) _117;
  if (i_164 < _118)
    goto <bb 40>; [INV]
  else
    goto <bb 42>; [INV]

  <bb 42> :
  # DEBUG BEGIN_STMT
  clockTreeIsConsumingPll = 0;
  # DEBUG BEGIN_STMT
  i_210 = 0;
  # DEBUG i => i_210
  goto <bb 47>; [INV]

  <bb 43> :
  # DEBUG BEGIN_STMT
  _119 = config_190(D)->selectors[i_165].value;
  _120 = (int) _119;
  _121 = clockName_sourceType[_120];
  if (_121 == 1)
    goto <bb 44>; [INV]
  else
    goto <bb 45>; [INV]

  <bb 44> :
  # DEBUG BEGIN_STMT
  _122 = config_190(D)->selectors[i_165].name;
  _123 = (int) _122;
  _124 = clockFeatures[_123][1];
  _125 = (int) _124;
  _126 = selectorCallbackIndex[_125];
  callbackIndex_222 = (uint32) _126;
  # DEBUG callbackIndex => callbackIndex_222
  # DEBUG BEGIN_STMT
  _127 = selectorCallbacks[callbackIndex_222].Set;
  _128 = &config_190(D)->selectors[i_165];
  _127 (_128);
  goto <bb 46>; [INV]

  <bb 45> :
  # DEBUG BEGIN_STMT
  clockTreeIsConsumingPll = 1;

  <bb 46> :
  # DEBUG BEGIN_STMT
  i_224 = i_165 + 1;
  # DEBUG i => i_224

  <bb 47> :
  # i_165 = PHI <i_210(42), i_224(46)>
  # DEBUG i => i_165
  # DEBUG BEGIN_STMT
  _129 = config_190(D)->selectorsCount;
  _130 = (long unsigned int) _129;
  if (i_165 < _130)
    goto <bb 43>; [INV]
  else
    goto <bb 48>; [INV]

  <bb 48> :
  # DEBUG BEGIN_STMT
  i_211 = 0;
  # DEBUG i => i_211
  goto <bb 50>; [INV]

  <bb 49> :
  # DEBUG BEGIN_STMT
  _131 = config_190(D)->gates[i_166].name;
  _132 = (int) _131;
  _133 = clockFeatures[_132][1];
  _134 = (int) _133;
  _135 = gateCallbackIndex[_134];
  callbackIndex_218 = (uint32) _135;
  # DEBUG callbackIndex => callbackIndex_218
  # DEBUG BEGIN_STMT
  _136 = gateCallbacks[callbackIndex_218].Set;
  _137 = &config_190(D)->gates[i_166];
  _136 (_137);
  # DEBUG BEGIN_STMT
  i_220 = i_166 + 1;
  # DEBUG i => i_220

  <bb 50> :
  # i_166 = PHI <i_211(48), i_220(49)>
  # DEBUG i => i_166
  # DEBUG BEGIN_STMT
  _138 = config_190(D)->gatesCount;
  _139 = (long unsigned int) _138;
  if (i_166 < _139)
    goto <bb 49>; [INV]
  else
    goto <bb 51>; [INV]

  <bb 51> :
  # DEBUG BEGIN_STMT
  clockTreeIsConsumingPll.2_140 = clockTreeIsConsumingPll;
  _141 = ~clockTreeIsConsumingPll.2_140;
  if (_141 != 0)
    goto <bb 52>; [INV]
  else
    goto <bb 55>; [INV]

  <bb 52> :
  # DEBUG BEGIN_STMT
  _142 = &config_190(D)->specificPeriphalConfiguration;
  SpecificPeripheralClockInitialization (_142);
  # DEBUG BEGIN_STMT
  i_213 = 0;
  # DEBUG i => i_213
  goto <bb 54>; [INV]

  <bb 53> :
  # DEBUG BEGIN_STMT
  _143 = config_190(D)->cmus[i_167].name;
  _144 = (int) _143;
  _145 = clockFeatures[_144][1];
  _146 = (int) _145;
  _147 = cmuCallbackIndex[_146];
  callbackIndex_214 = (uint32) _147;
  # DEBUG callbackIndex => callbackIndex_214
  # DEBUG BEGIN_STMT
  _148 = cmuCallbacks[callbackIndex_214].Set;
  _149 = &config_190(D)->cmus[i_167];
  _148 (_149);
  # DEBUG BEGIN_STMT
  i_216 = i_167 + 1;
  # DEBUG i => i_216

  <bb 54> :
  # i_167 = PHI <i_213(52), i_216(53)>
  # DEBUG i => i_167
  # DEBUG BEGIN_STMT
  _150 = config_190(D)->cmusCount;
  _151 = (long unsigned int) _150;
  if (i_167 < _151)
    goto <bb 53>; [INV]
  else
    goto <bb 55>; [INV]

  <bb 55> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  UpdateFrequencies (0);
  return;

}


Clock_Ip_Init (const struct Clock_Ip_ClockConfigType * config)
{
  Clock_Ip_PllStatusType pllStatus;
  Clock_Ip_StatusType clockStatus;
  _Bool clockTreeIsConsumingPll.0_1;
  Clock_Ip_StatusType _13;

  <bb 2> :
  # DEBUG BEGIN_STMT
  clockStatus_4 = 1;
  # DEBUG clockStatus => clockStatus_4
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  Clock_Ip_InitClock (config_6(D));
  # DEBUG BEGIN_STMT
  clockTreeIsConsumingPll.0_1 = clockTreeIsConsumingPll;
  if (clockTreeIsConsumingPll.0_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  pllStatus_10 = Clock_Ip_GetPllStatus ();
  # DEBUG pllStatus => pllStatus_10
  # DEBUG BEGIN_STMT
  if (pllStatus_10 == 0)
    goto <bb 4>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  Clock_Ip_DistributePll ();
  # DEBUG BEGIN_STMT
  clockStatus_12 = 0;
  # DEBUG clockStatus => clockStatus_12
  goto <bb 6>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  clockStatus_8 = 0;
  # DEBUG clockStatus => clockStatus_8

  <bb 6> :
  # clockStatus_2 = PHI <clockStatus_12(4), clockStatus_8(5), clockStatus_4(3)>
  # DEBUG clockStatus => clockStatus_2
  # DEBUG BEGIN_STMT
  _13 = clockStatus_2;
  return _13;

}