Clock_Ip_GetConfiguredFrequencyValue (Clock_Ip_NameType ClockName)
{
  uint32 Index;
  uint32 ReturnValue;
  uint32 D.7005;

  <bb 2> :
  # DEBUG BEGIN_STMT
  ReturnValue = 0;
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  Clock_Ip_pxConfig.19_1 = Clock_Ip_pxConfig;
  if (Clock_Ip_pxConfig.19_1 != 0B)
    goto <bb 3>; [INV]
  else
    goto <bb 8>; [INV]

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

  <bb 4> :
  # DEBUG BEGIN_STMT
  Clock_Ip_pxConfig.20_2 = Clock_Ip_pxConfig;
  _3 = Clock_Ip_pxConfig.20_2->ConfiguredFrequencies[Index].Name;
  if (ClockName == _3)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  Clock_Ip_pxConfig.21_4 = Clock_Ip_pxConfig;
  ReturnValue = Clock_Ip_pxConfig.21_4->ConfiguredFrequencies[Index].ConfiguredFrequencyValue;
  # DEBUG BEGIN_STMT
  goto <bb 8>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 7> :
  # DEBUG BEGIN_STMT
  Clock_Ip_pxConfig.22_5 = Clock_Ip_pxConfig;
  _6 = Clock_Ip_pxConfig.22_5->ConfigureFrequenciesCount;
  _7 = (long unsigned int) _6;
  if (Index < _7)
    goto <bb 4>; [INV]
  else
    goto <bb 8>; [INV]

  <bb 8> :
  # DEBUG BEGIN_STMT
  D.7005 = ReturnValue;
  return D.7005;

}


Clock_Ip_TimeoutExpired (uint32 * StartTimeInOut, uint32 * ElapsedTimeInOut, uint32 TimeoutTicks)
{
  boolean D.6999;
  long unsigned int D.6998;

  <bb 2> :
  # DEBUG BEGIN_STMT
  D.6998 = OsIf_GetElapsed (StartTimeInOut, 0);
  _1 = *ElapsedTimeInOut;
  _2 = D.6998 + _1;
  *ElapsedTimeInOut = _2;
  # DEBUG BEGIN_STMT
  _3 = *ElapsedTimeInOut;
  _4 = TimeoutTicks <= _3;
  D.6999 = (boolean) _4;
  return D.6999;

}


Clock_Ip_StartTimeout (uint32 * StartTimeOut, uint32 * ElapsedTimeOut, uint32 * TimeoutTicksOut, uint32 TimeoutUs)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = OsIf_GetCounter (0);
  *StartTimeOut = _1;
  # DEBUG BEGIN_STMT
  *ElapsedTimeOut = 0;
  # DEBUG BEGIN_STMT
  _2 = OsIf_MicrosToTicks (TimeoutUs, 0);
  *TimeoutTicksOut = _2;
  return;

}


Clock_Ip_ReportClockErrors (Clock_Ip_NotificationType Error, Clock_Ip_NameType ClockName)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  Clock_Ip_pfkNotificationsCallback.18_1 = Clock_Ip_pfkNotificationsCallback;
  Clock_Ip_pfkNotificationsCallback.18_1 (Error, ClockName);
  return;

}


Clock_Ip_EnableModuleClock (Clock_Ip_NameType ClockName)
{
  uint32 CallbackIndex;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = (int) ClockName;
  _2 = Clock_Ip_au8ClockFeatures[_1][1];
  _3 = (int) _2;
  _4 = Clock_Ip_au8GateCallbackIndex[_3];
  CallbackIndex = (uint32) _4;
  # DEBUG BEGIN_STMT
  _5 = Clock_Ip_axGateCallbacks[CallbackIndex].Update;
  _5 (ClockName, 0);
  return;

}


Clock_Ip_DisableModuleClock (Clock_Ip_NameType ClockName)
{
  uint32 CallbackIndex;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = (int) ClockName;
  _2 = Clock_Ip_au8ClockFeatures[_1][1];
  _3 = (int) _2;
  _4 = Clock_Ip_au8GateCallbackIndex[_3];
  CallbackIndex = (uint32) _4;
  # DEBUG BEGIN_STMT
  _5 = Clock_Ip_axGateCallbacks[CallbackIndex].Update;
  _5 (ClockName, 1);
  return;

}


Clock_Ip_InstallNotificationsCallback (void (*Clock_Ip_NotificationsCallbackType) (Clock_Ip_NotificationType, Clock_Ip_NameType) Callback)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  Clock_Ip_pfkNotificationsCallback = Callback;
  return;

}


Clock_Ip_ClearClockMonitorStatus (Clock_Ip_NameType ClockName)
{
  uint32 CallbackIndex;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = (int) ClockName;
  _2 = Clock_Ip_au8ClockFeatures[_1][1];
  _3 = (int) _2;
  _4 = Clock_Ip_au8CmuCallbackIndex[_3];
  CallbackIndex = (uint32) _4;
  # DEBUG BEGIN_STMT
  _5 = Clock_Ip_axCmuCallbacks[CallbackIndex].Clear;
  _5 (ClockName);
  return;

}


Clock_Ip_GetClockMonitorStatus (Clock_Ip_NameType ClockName)
{
  uint32 CallbackIndex;
  Clock_Ip_CmuStatusType D.6996;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = (int) ClockName;
  _2 = Clock_Ip_au8ClockFeatures[_1][1];
  _3 = (int) _2;
  _4 = Clock_Ip_au8CmuCallbackIndex[_3];
  CallbackIndex = (uint32) _4;
  # DEBUG BEGIN_STMT
  _5 = Clock_Ip_axCmuCallbacks[CallbackIndex].GetStatus;
  D.6996 = _5 (ClockName);
  return D.6996;

}


Clock_Ip_DisableClockMonitor (Clock_Ip_NameType ClockName)
{
  uint32 CallbackIndex;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = (int) ClockName;
  _2 = Clock_Ip_au8ClockFeatures[_1][1];
  _3 = (int) _2;
  _4 = Clock_Ip_au8CmuCallbackIndex[_3];
  CallbackIndex = (uint32) _4;
  # DEBUG BEGIN_STMT
  _5 = Clock_Ip_axCmuCallbacks[CallbackIndex].Disable;
  _5 (ClockName);
  return;

}


Clock_Ip_DistributePll ()
{
  uint32 CallbackIndex;
  uint32 Index;

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

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

  <bb 4> :
  # DEBUG BEGIN_STMT
  Clock_Ip_pxConfig.6_2 = Clock_Ip_pxConfig;
  _3 = Clock_Ip_pxConfig.6_2->Selectors[Index].Value;
  _4 = (int) _3;
  _5 = Clock_Ip_aeSourceTypeClockName[_4];
  if (_5 == 3)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  Clock_Ip_pxConfig.7_6 = Clock_Ip_pxConfig;
  _7 = Clock_Ip_pxConfig.7_6->Selectors[Index].Name;
  _8 = (int) _7;
  _9 = Clock_Ip_au8ClockFeatures[_8][1];
  _10 = (int) _9;
  _11 = Clock_Ip_au8SelectorCallbackIndex[_10];
  CallbackIndex = (uint32) _11;
  # DEBUG BEGIN_STMT
  _12 = Clock_Ip_axSelectorCallbacks[CallbackIndex].Set;
  Clock_Ip_pxConfig.8_13 = Clock_Ip_pxConfig;
  _14 = &Clock_Ip_pxConfig.8_13->Selectors[Index];
  _12 (_14);

  <bb 6> :
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 7> :
  # DEBUG BEGIN_STMT
  Clock_Ip_pxConfig.9_15 = Clock_Ip_pxConfig;
  _16 = Clock_Ip_pxConfig.9_15->SelectorsCount;
  _17 = (long unsigned int) _16;
  if (Index < _17)
    goto <bb 4>; [INV]
  else
    goto <bb 8>; [INV]

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

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

  <bb 10> :
  # DEBUG BEGIN_STMT
  Clock_Ip_pxConfig.11_19 = Clock_Ip_pxConfig;
  _20 = Clock_Ip_pxConfig.11_19->Gates[Index].Name;
  _21 = (int) _20;
  _22 = Clock_Ip_au8ClockFeatures[_21][1];
  _23 = (int) _22;
  _24 = Clock_Ip_au8GateCallbackIndex[_23];
  CallbackIndex = (uint32) _24;
  # DEBUG BEGIN_STMT
  _25 = Clock_Ip_axGateCallbacks[CallbackIndex].Set;
  Clock_Ip_pxConfig.12_26 = Clock_Ip_pxConfig;
  _27 = &Clock_Ip_pxConfig.12_26->Gates[Index];
  _25 (_27);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 11> :
  # DEBUG BEGIN_STMT
  Clock_Ip_pxConfig.13_28 = Clock_Ip_pxConfig;
  _29 = Clock_Ip_pxConfig.13_28->GatesCount;
  _30 = (long unsigned int) _29;
  if (Index < _30)
    goto <bb 10>; [INV]
  else
    goto <bb 12>; [INV]

  <bb 12> :
  # DEBUG BEGIN_STMT
  Clock_Ip_pxConfig.14_31 = Clock_Ip_pxConfig;
  _32 = &Clock_Ip_pxConfig.14_31->SpecificPeriphalConfiguration;
  Clock_Ip_SpecificPeripheralClockInitialization (_32);
  # DEBUG BEGIN_STMT
  Index = 0;
  goto <bb 14>; [INV]

  <bb 13> :
  # DEBUG BEGIN_STMT
  Clock_Ip_pxConfig.15_33 = Clock_Ip_pxConfig;
  _34 = Clock_Ip_pxConfig.15_33->Cmus[Index].Name;
  _35 = (int) _34;
  _36 = Clock_Ip_au8ClockFeatures[_35][1];
  _37 = (int) _36;
  _38 = Clock_Ip_au8CmuCallbackIndex[_37];
  CallbackIndex = (uint32) _38;
  # DEBUG BEGIN_STMT
  _39 = Clock_Ip_axCmuCallbacks[CallbackIndex].Enable;
  Clock_Ip_pxConfig.16_40 = Clock_Ip_pxConfig;
  _41 = &Clock_Ip_pxConfig.16_40->Cmus[Index];
  _39 (_41);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 14> :
  # DEBUG BEGIN_STMT
  Clock_Ip_pxConfig.17_42 = Clock_Ip_pxConfig;
  _43 = Clock_Ip_pxConfig.17_42->CmusCount;
  _44 = (long unsigned int) _43;
  if (Index < _44)
    goto <bb 13>; [INV]
  else
    goto <bb 15>; [INV]

  <bb 15> :
  return;

}


Clock_Ip_GetPllStatus ()
{
  uint32 CallbackIndex;
  uint32 Index;
  Clock_Ip_DfsStatusType DfsStatus;
  Clock_Ip_PllStatusReturnType PllStatus;
  Clock_Ip_PllStatusType RetValue;
  Clock_Ip_PllStatusType D.6988;

  <bb 2> :
  # DEBUG BEGIN_STMT
  RetValue = 2;
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  Index = 0;
  goto <bb 8>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _1 = Clock_Ip_aeHwPllName[Index];
  _2 = (int) _1;
  _3 = Clock_Ip_au8ClockFeatures[_2][1];
  _4 = (int) _3;
  _5 = Clock_Ip_au8PllCallbackIndex[_4];
  CallbackIndex = (uint32) _5;
  # DEBUG BEGIN_STMT
  _6 = Clock_Ip_axPllCallbacks[CallbackIndex].Complete;
  _7 = Clock_Ip_aeHwPllName[Index];
  PllStatus = _6 (_7);
  # DEBUG BEGIN_STMT
  if (PllStatus == 1)
    goto <bb 4>; [INV]
  else
    goto <bb 5>; [INV]

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

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

  <bb 6> :
  # DEBUG BEGIN_STMT
  RetValue = 0;

  <bb 7> :
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 8> :
  # DEBUG BEGIN_STMT
  if (Index <= 3)
    goto <bb 3>; [INV]
  else
    goto <bb 9>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  if (RetValue == 0)
    goto <bb 10>; [INV]
  else
    goto <bb 15>; [INV]

  <bb 10> :
  # DEBUG BEGIN_STMT
  Index = 0;
  goto <bb 14>; [INV]

  <bb 11> :
  # DEBUG BEGIN_STMT
  _8 = Clock_Ip_aeHwDfsName[Index];
  _9 = (int) _8;
  _10 = Clock_Ip_au8ClockFeatures[_9][1];
  _11 = (int) _10;
  _12 = Clock_Ip_au8FractionalDividerCallbackIndex[_11];
  CallbackIndex = (uint32) _12;
  # DEBUG BEGIN_STMT
  _13 = Clock_Ip_axFracDivCallbacks[CallbackIndex].Complete;
  _14 = Clock_Ip_aeHwDfsName[Index];
  DfsStatus = _13 (_14);
  # DEBUG BEGIN_STMT
  if (DfsStatus == 1)
    goto <bb 12>; [INV]
  else
    goto <bb 13>; [INV]

  <bb 12> :
  # DEBUG BEGIN_STMT
  RetValue = 1;
  # DEBUG BEGIN_STMT
  goto <bb 15>; [INV]

  <bb 13> :
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 14> :
  # DEBUG BEGIN_STMT
  if (Index <= 11)
    goto <bb 11>; [INV]
  else
    goto <bb 15>; [INV]

  <bb 15> :
  # DEBUG BEGIN_STMT
  D.6988 = RetValue;
  return D.6988;

}


Clock_Ip_InitClock (const struct Clock_Ip_ClockConfigType * Config)
{
  uint32 Index;
  uint32 CallbackIndex;

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

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

  <bb 4> :
  # DEBUG BEGIN_STMT
  _2 = Config->Cmus[Index].Name;
  _3 = (int) _2;
  _4 = Clock_Ip_au8ClockFeatures[_3][1];
  _5 = (int) _4;
  _6 = Clock_Ip_au8CmuCallbackIndex[_5];
  CallbackIndex = (uint32) _6;
  # DEBUG BEGIN_STMT
  _7 = Clock_Ip_axCmuCallbacks[CallbackIndex].Reset;
  _8 = &Config->Cmus[Index];
  _7 (_8);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 5> :
  # DEBUG BEGIN_STMT
  _9 = Config->CmusCount;
  _10 = (long unsigned int) _9;
  if (Index < _10)
    goto <bb 4>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  Clock_Ip_ResetClockConfiguration (Config);
  # DEBUG BEGIN_STMT
  Index = 0;
  goto <bb 8>; [INV]

  <bb 7> :
  # DEBUG BEGIN_STMT
  _11 = Config->Ircoscs[Index].Name;
  _12 = (int) _11;
  _13 = Clock_Ip_au8ClockFeatures[_12][1];
  _14 = (int) _13;
  _15 = Clock_Ip_au8IrcoscCallbackIndex[_14];
  CallbackIndex = (uint32) _15;
  # DEBUG BEGIN_STMT
  _16 = Clock_Ip_axIntOscCallbacks[CallbackIndex].Set;
  _17 = &Config->Ircoscs[Index];
  _16 (_17);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 8> :
  # DEBUG BEGIN_STMT
  _18 = Config->IrcoscsCount;
  _19 = (long unsigned int) _18;
  if (Index < _19)
    goto <bb 7>; [INV]
  else
    goto <bb 9>; [INV]

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

  <bb 10> :
  # DEBUG BEGIN_STMT
  _20 = Config->Xoscs[Index].Name;
  _21 = (int) _20;
  _22 = Clock_Ip_au8ClockFeatures[_21][1];
  _23 = (int) _22;
  _24 = Clock_Ip_au8XoscCallbackIndex[_23];
  CallbackIndex = (uint32) _24;
  # DEBUG BEGIN_STMT
  _25 = Clock_Ip_axExtOscCallbacks[CallbackIndex].Set;
  _26 = &Config->Xoscs[Index];
  _25 (_26);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 11> :
  # DEBUG BEGIN_STMT
  _27 = Config->XoscsCount;
  _28 = (long unsigned int) _27;
  if (Index < _28)
    goto <bb 10>; [INV]
  else
    goto <bb 12>; [INV]

  <bb 12> :
  # DEBUG BEGIN_STMT
  Clock_Ip_UpdateDriverContext (Config);
  # DEBUG BEGIN_STMT
  Index = 0;
  goto <bb 14>; [INV]

  <bb 13> :
  # DEBUG BEGIN_STMT
  _29 = Config->Pcfs[Index].Name;
  _30 = (int) _29;
  _31 = Clock_Ip_au8ClockFeatures[_30][1];
  _32 = (int) _31;
  _33 = Clock_Ip_au8PcfsCallbackIndex[_32];
  CallbackIndex = (uint32) _33;
  # DEBUG BEGIN_STMT
  _34 = Clock_Ip_axPcfsCallbacks[CallbackIndex].Set;
  _35 = &Config->Pcfs[Index];
  _34 (_35);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 14> :
  # DEBUG BEGIN_STMT
  _36 = Config->PcfsCount;
  _37 = (long unsigned int) _36;
  if (Index < _37)
    goto <bb 13>; [INV]
  else
    goto <bb 15>; [INV]

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

  <bb 16> :
  # DEBUG BEGIN_STMT
  _38 = Config->DividerTriggers[Index].Name;
  _39 = (int) _38;
  _40 = Clock_Ip_au8ClockFeatures[_39][1];
  _41 = (int) _40;
  _42 = Clock_Ip_au8DividerTriggerCallbackIndex[_41];
  CallbackIndex = (uint32) _42;
  # DEBUG BEGIN_STMT
  _43 = Clock_Ip_axDividerTriggerCallbacks[CallbackIndex].Configure;
  _44 = &Config->DividerTriggers[Index];
  _43 (_44);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 17> :
  # DEBUG BEGIN_STMT
  _45 = Config->DividerTriggersCount;
  _46 = (long unsigned int) _45;
  if (Index < _46)
    goto <bb 16>; [INV]
  else
    goto <bb 18>; [INV]

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

  <bb 19> :
  # DEBUG BEGIN_STMT
  _47 = Config->Dividers[Index].Name;
  _48 = (int) _47;
  _49 = Clock_Ip_au8ClockFeatures[_48][1];
  _50 = (int) _49;
  _51 = Clock_Ip_au8DividerCallbackIndex[_50];
  CallbackIndex = (uint32) _51;
  # DEBUG BEGIN_STMT
  _52 = Clock_Ip_axDividerCallbacks[CallbackIndex].Set;
  _53 = &Config->Dividers[Index];
  _52 (_53);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 20> :
  # DEBUG BEGIN_STMT
  _54 = Config->DividersCount;
  _55 = (long unsigned int) _54;
  if (Index < _55)
    goto <bb 19>; [INV]
  else
    goto <bb 21>; [INV]

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

  <bb 22> :
  # DEBUG BEGIN_STMT
  _56 = Config->DividerTriggers[Index].Name;
  _57 = (int) _56;
  _58 = Clock_Ip_au8ClockFeatures[_57][1];
  _59 = (int) _58;
  _60 = Clock_Ip_au8DividerTriggerCallbackIndex[_59];
  CallbackIndex = (uint32) _60;
  # DEBUG BEGIN_STMT
  _61 = Clock_Ip_axDividerTriggerCallbacks[CallbackIndex].TriggerUpdate;
  _62 = &Config->DividerTriggers[Index];
  _61 (_62);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 23> :
  # DEBUG BEGIN_STMT
  _63 = Config->DividerTriggersCount;
  _64 = (long unsigned int) _63;
  if (Index < _64)
    goto <bb 22>; [INV]
  else
    goto <bb 24>; [INV]

  <bb 24> :
  # DEBUG BEGIN_STMT
  Index = 0;
  goto <bb 26>; [INV]

  <bb 25> :
  # DEBUG BEGIN_STMT
  _65 = Config->Plls[Index].Name;
  _66 = (int) _65;
  _67 = Clock_Ip_au8ClockFeatures[_66][1];
  _68 = (int) _67;
  _69 = Clock_Ip_au8PllCallbackIndex[_68];
  CallbackIndex = (uint32) _69;
  # DEBUG BEGIN_STMT
  _70 = Clock_Ip_axPllCallbacks[CallbackIndex].Set;
  _71 = &Config->Plls[Index];
  _70 (_71);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 26> :
  # DEBUG BEGIN_STMT
  _72 = Config->PllsCount;
  _73 = (long unsigned int) _72;
  if (Index < _73)
    goto <bb 25>; [INV]
  else
    goto <bb 27>; [INV]

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

  <bb 28> :
  # DEBUG BEGIN_STMT
  _74 = Config->Cmus[Index].Name;
  _75 = (int) _74;
  _76 = Clock_Ip_au8ClockFeatures[_75][1];
  _77 = (int) _76;
  _78 = Clock_Ip_au8CmuCallbackIndex[_77];
  CallbackIndex = (uint32) _78;
  # DEBUG BEGIN_STMT
  _79 = Clock_Ip_axCmuCallbacks[CallbackIndex].Set;
  _80 = &Config->Cmus[Index];
  _79 (_80);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 29> :
  # DEBUG BEGIN_STMT
  _81 = Config->CmusCount;
  _82 = (long unsigned int) _81;
  if (Index < _82)
    goto <bb 28>; [INV]
  else
    goto <bb 30>; [INV]

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

  <bb 31> :
  # DEBUG BEGIN_STMT
  _83 = Config->Xoscs[Index].Name;
  _84 = (int) _83;
  _85 = Clock_Ip_au8ClockFeatures[_84][1];
  _86 = (int) _85;
  _87 = Clock_Ip_au8XoscCallbackIndex[_86];
  CallbackIndex = (uint32) _87;
  # DEBUG BEGIN_STMT
  _88 = Clock_Ip_axExtOscCallbacks[CallbackIndex].Complete;
  _89 = &Config->Xoscs[Index];
  _88 (_89);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 32> :
  # DEBUG BEGIN_STMT
  _90 = Config->XoscsCount;
  _91 = (long unsigned int) _90;
  if (Index < _91)
    goto <bb 31>; [INV]
  else
    goto <bb 33>; [INV]

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

  <bb 34> :
  # DEBUG BEGIN_STMT
  _92 = Config->Plls[Index].Name;
  _93 = (int) _92;
  _94 = Clock_Ip_au8ClockFeatures[_93][1];
  _95 = (int) _94;
  _96 = Clock_Ip_au8PllCallbackIndex[_95];
  CallbackIndex = (uint32) _96;
  # DEBUG BEGIN_STMT
  _97 = Clock_Ip_axPllCallbacks[CallbackIndex].Enable;
  _98 = &Config->Plls[Index];
  _97 (_98);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 35> :
  # DEBUG BEGIN_STMT
  _99 = Config->PllsCount;
  _100 = (long unsigned int) _99;
  if (Index < _100)
    goto <bb 34>; [INV]
  else
    goto <bb 36>; [INV]

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

  <bb 37> :
  # DEBUG BEGIN_STMT
  _101 = Config->FracDivs[Index].Name;
  _102 = (int) _101;
  _103 = Clock_Ip_au8ClockFeatures[_102][1];
  _104 = (int) _103;
  _105 = Clock_Ip_au8FractionalDividerCallbackIndex[_104];
  CallbackIndex = (uint32) _105;
  # DEBUG BEGIN_STMT
  _106 = Clock_Ip_axFracDivCallbacks[CallbackIndex].Set;
  _107 = &Config->FracDivs[Index];
  _106 (_107);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 38> :
  # DEBUG BEGIN_STMT
  _108 = Config->FracDivsCount;
  _109 = (long unsigned int) _108;
  if (Index < _109)
    goto <bb 37>; [INV]
  else
    goto <bb 39>; [INV]

  <bb 39> :
  # DEBUG BEGIN_STMT
  Clock_Ip_bClockTreeIsConsumingPll = 0;
  # DEBUG BEGIN_STMT
  Index = 0;
  goto <bb 44>; [INV]

  <bb 40> :
  # DEBUG BEGIN_STMT
  _110 = Config->Selectors[Index].Value;
  _111 = (int) _110;
  _112 = Clock_Ip_aeSourceTypeClockName[_111];
  if (_112 != 3)
    goto <bb 41>; [INV]
  else
    goto <bb 42>; [INV]

  <bb 41> :
  # DEBUG BEGIN_STMT
  _113 = Config->Selectors[Index].Name;
  _114 = (int) _113;
  _115 = Clock_Ip_au8ClockFeatures[_114][1];
  _116 = (int) _115;
  _117 = Clock_Ip_au8SelectorCallbackIndex[_116];
  CallbackIndex = (uint32) _117;
  # DEBUG BEGIN_STMT
  _118 = Clock_Ip_axSelectorCallbacks[CallbackIndex].Set;
  _119 = &Config->Selectors[Index];
  _118 (_119);
  goto <bb 43>; [INV]

  <bb 42> :
  # DEBUG BEGIN_STMT
  Clock_Ip_bClockTreeIsConsumingPll = 1;

  <bb 43> :
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 44> :
  # DEBUG BEGIN_STMT
  _120 = Config->SelectorsCount;
  _121 = (long unsigned int) _120;
  if (Index < _121)
    goto <bb 40>; [INV]
  else
    goto <bb 45>; [INV]

  <bb 45> :
  # DEBUG BEGIN_STMT
  Clock_Ip_bClockTreeIsConsumingPll.2_122 = Clock_Ip_bClockTreeIsConsumingPll;
  if (Clock_Ip_bClockTreeIsConsumingPll.2_122 == 0)
    goto <bb 46>; [INV]
  else
    goto <bb 52>; [INV]

  <bb 46> :
  # DEBUG BEGIN_STMT
  Index = 0;
  goto <bb 48>; [INV]

  <bb 47> :
  # DEBUG BEGIN_STMT
  _123 = Config->Gates[Index].Name;
  _124 = (int) _123;
  _125 = Clock_Ip_au8ClockFeatures[_124][1];
  _126 = (int) _125;
  _127 = Clock_Ip_au8GateCallbackIndex[_126];
  CallbackIndex = (uint32) _127;
  # DEBUG BEGIN_STMT
  _128 = Clock_Ip_axGateCallbacks[CallbackIndex].Set;
  _129 = &Config->Gates[Index];
  _128 (_129);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 48> :
  # DEBUG BEGIN_STMT
  _130 = Config->GatesCount;
  _131 = (long unsigned int) _130;
  if (Index < _131)
    goto <bb 47>; [INV]
  else
    goto <bb 49>; [INV]

  <bb 49> :
  # DEBUG BEGIN_STMT
  _132 = &Config->SpecificPeriphalConfiguration;
  Clock_Ip_SpecificPeripheralClockInitialization (_132);
  # DEBUG BEGIN_STMT
  Index = 0;
  goto <bb 51>; [INV]

  <bb 50> :
  # DEBUG BEGIN_STMT
  _133 = Config->Cmus[Index].Name;
  _134 = (int) _133;
  _135 = Clock_Ip_au8ClockFeatures[_134][1];
  _136 = (int) _135;
  _137 = Clock_Ip_au8CmuCallbackIndex[_136];
  CallbackIndex = (uint32) _137;
  # DEBUG BEGIN_STMT
  _138 = Clock_Ip_axCmuCallbacks[CallbackIndex].Enable;
  _139 = &Config->Cmus[Index];
  _138 (_139);
  # DEBUG BEGIN_STMT
  Index = Index + 1;

  <bb 51> :
  # DEBUG BEGIN_STMT
  _140 = Config->CmusCount;
  _141 = (long unsigned int) _140;
  if (Index < _141)
    goto <bb 50>; [INV]
  else
    goto <bb 52>; [INV]

  <bb 52> :
  # DEBUG BEGIN_STMT
  return;

}


Clock_Ip_Init (const struct Clock_Ip_ClockConfigType * Config)
{
  Clock_Ip_PllStatusType PllStatus;
  Clock_Ip_StatusType ClockStatus;
  Clock_Ip_StatusType D.6966;

  <bb 2> :
  # DEBUG BEGIN_STMT
  ClockStatus = 1;
  # 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);
  # DEBUG BEGIN_STMT
  Clock_Ip_bClockTreeIsConsumingPll.0_1 = Clock_Ip_bClockTreeIsConsumingPll;
  if (Clock_Ip_bClockTreeIsConsumingPll.0_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 5>; [INV]

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

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

  <bb 5> :
  # DEBUG BEGIN_STMT
  ClockStatus = 0;

  <bb 6> :
  # DEBUG BEGIN_STMT
  D.6966 = ClockStatus;
  return D.6966;

}


Clock_Ip_ResetClockConfiguration (const struct Clock_Ip_ClockConfigType * Config)
{
  uint32 Index;
  uint32 CallbackIndex;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = Config->SelectorsCount;
  Index = (uint32) _1;
  goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _2 = Index + 4294967295;
  _3 = Config->Selectors[_2].Name;
  _4 = (int) _3;
  _5 = Clock_Ip_au8ClockFeatures[_4][1];
  _6 = (int) _5;
  _7 = Clock_Ip_au8SelectorCallbackIndex[_6];
  CallbackIndex = (uint32) _7;
  # DEBUG BEGIN_STMT
  _8 = Clock_Ip_axSelectorCallbacks[CallbackIndex].Reset;
  _9 = Index + 4294967295;
  _10 = &Config->Selectors[_9];
  _8 (_10);
  # DEBUG BEGIN_STMT
  Index = Index + 4294967295;

  <bb 4> :
  # DEBUG BEGIN_STMT
  if (Index != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  _11 = Config->FracDivsCount;
  Index = (uint32) _11;
  goto <bb 7>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  _12 = Index + 4294967295;
  _13 = Config->FracDivs[_12].Name;
  _14 = (int) _13;
  _15 = Clock_Ip_au8ClockFeatures[_14][1];
  _16 = (int) _15;
  _17 = Clock_Ip_au8FractionalDividerCallbackIndex[_16];
  CallbackIndex = (uint32) _17;
  # DEBUG BEGIN_STMT
  _18 = Clock_Ip_axFracDivCallbacks[CallbackIndex].Reset;
  _19 = Index + 4294967295;
  _20 = &Config->FracDivs[_19];
  _18 (_20);
  # DEBUG BEGIN_STMT
  Index = Index + 4294967295;

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

  <bb 8> :
  # DEBUG BEGIN_STMT
  _21 = Config->PllsCount;
  Index = (uint32) _21;
  goto <bb 10>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  _22 = Index + 4294967295;
  _23 = Config->Plls[_22].Name;
  _24 = (int) _23;
  _25 = Clock_Ip_au8ClockFeatures[_24][1];
  _26 = (int) _25;
  _27 = Clock_Ip_au8PllCallbackIndex[_26];
  CallbackIndex = (uint32) _27;
  # DEBUG BEGIN_STMT
  _28 = Clock_Ip_axPllCallbacks[CallbackIndex].Reset;
  _29 = Index + 4294967295;
  _30 = &Config->Plls[_29];
  _28 (_30);
  # DEBUG BEGIN_STMT
  Index = Index + 4294967295;

  <bb 10> :
  # DEBUG BEGIN_STMT
  if (Index != 0)
    goto <bb 9>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 11> :
  # DEBUG BEGIN_STMT
  _31 = Config->XoscsCount;
  Index = (uint32) _31;
  goto <bb 13>; [INV]

  <bb 12> :
  # DEBUG BEGIN_STMT
  _32 = Index + 4294967295;
  _33 = Config->Xoscs[_32].Name;
  _34 = (int) _33;
  _35 = Clock_Ip_au8ClockFeatures[_34][1];
  _36 = (int) _35;
  _37 = Clock_Ip_au8XoscCallbackIndex[_36];
  CallbackIndex = (uint32) _37;
  # DEBUG BEGIN_STMT
  _38 = Clock_Ip_axExtOscCallbacks[CallbackIndex].Reset;
  _39 = Index + 4294967295;
  _40 = &Config->Xoscs[_39];
  _38 (_40);
  # DEBUG BEGIN_STMT
  Index = Index + 4294967295;

  <bb 13> :
  # DEBUG BEGIN_STMT
  if (Index != 0)
    goto <bb 12>; [INV]
  else
    goto <bb 14>; [INV]

  <bb 14> :
  return;

}


Clock_Ip_CallEmptyCallbacks ()
{
  static boolean FunctionWasCalled = 0;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  FunctionWasCalled.4_1 = FunctionWasCalled;
  if (FunctionWasCalled.4_1 == 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  FunctionWasCalled = 1;
  # DEBUG BEGIN_STMT
  _2 = Clock_Ip_axCmuCallbacks[0].Set;
  _2 (0B);
  # DEBUG BEGIN_STMT
  _3 = Clock_Ip_axCmuCallbacks[0].Disable;
  _3 (184);
  # DEBUG BEGIN_STMT
  _4 = Clock_Ip_axCmuCallbacks[0].Clear;
  _4 (184);
  # DEBUG BEGIN_STMT
  _5 = Clock_Ip_axCmuCallbacks[0].GetStatus;
  _5 (184);
  # DEBUG BEGIN_STMT
  _6 = Clock_Ip_axDividerCallbacks[0].Set;
  _6 (0B);
  # DEBUG BEGIN_STMT
  _7 = Clock_Ip_axDividerTriggerCallbacks[0].Configure;
  _7 (0B);
  # DEBUG BEGIN_STMT
  _8 = Clock_Ip_axExtOscCallbacks[0].Reset;
  _8 (0B);
  # DEBUG BEGIN_STMT
  _9 = Clock_Ip_axFracDivCallbacks[0].Set;
  _9 (0B);
  # DEBUG BEGIN_STMT
  _10 = Clock_Ip_axFracDivCallbacks[0].Complete;
  _10 (184);
  # DEBUG BEGIN_STMT
  _11 = Clock_Ip_axGateCallbacks[0].Set;
  _11 (0B);
  # DEBUG BEGIN_STMT
  _12 = Clock_Ip_axGateCallbacks[0].Update;
  _12 (184, 0);
  # DEBUG BEGIN_STMT
  _13 = Clock_Ip_axIntOscCallbacks[0].Set;
  _13 (0B);
  # DEBUG BEGIN_STMT
  _14 = Clock_Ip_axPllCallbacks[0].Set;
  _14 (0B);
  # DEBUG BEGIN_STMT
  _15 = Clock_Ip_axPllCallbacks[0].Complete;
  _15 (184);
  # DEBUG BEGIN_STMT
  _16 = Clock_Ip_axSelectorCallbacks[0].Set;
  _16 (0B);
  # DEBUG BEGIN_STMT
  _17 = Clock_Ip_axPcfsCallbacks[0].Set;
  _17 (0B);

  <bb 4> :
  return;

}


Clock_Ip_UpdateDriverContext (const struct Clock_Ip_ClockConfigType * Config)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  Clock_Ip_bObjectsAreInitialized.3_1 = Clock_Ip_bObjectsAreInitialized;
  if (Clock_Ip_bObjectsAreInitialized.3_1 == 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  Clock_Ip_bObjectsAreInitialized = 1;

  <bb 4> :
  # DEBUG BEGIN_STMT
  Clock_Ip_CallEmptyCallbacks ();
  return;

}


Clock_Ip_NotificatonsEmptyCallback (Clock_Ip_NotificationType Notification, Clock_Ip_NameType ClockName)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  return;

}


