ADM/GW/Debug_FLASH/RTD/src/Lpi2c_Ip.c.017i.build_ssa_passes

Lpi2c_Ip_SetMasterHighSpeedMode (uint32 u32Instance, boolean bHighSpeedEnabled)
{
  struct Lpi2c_Ip_MasterStateType * master;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[u32Instance];
  # DEBUG BEGIN_STMT
  if (bHighSpeedEnabled != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  master->operatingMode = 3;
  goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  master->operatingMode = 0;

  <bb 5> :
  return;

}


Lpi2c_Ip_SetSlaveCallback (uint32 u32Instance, void (*Lpi2c_Ip_SlaveCallbackType) (Lpi2c_Ip_SlaveEventType, uint8) slaveCallback)
{
  struct Lpi2c_Ip_SlaveStateType * slave;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  slave = g_lpi2cSlaveStatePtr[u32Instance];
  # DEBUG BEGIN_STMT
  slave->slaveCallback = slaveCallback;
  return;

}


Lpi2c_Ip_SetMasterCallback (uint32 u32Instance, void (*Lpi2c_Ip_MasterCallbackType) (Lpi2c_Ip_MasterEventType, uint8) masterCallback)
{
  struct Lpi2c_Ip_MasterStateType * master;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[u32Instance];
  # DEBUG BEGIN_STMT
  master->masterCallback = masterCallback;
  return;

}


Lpi2c_Ip_ModuleIRQHandler (uint32 instance)
{
  uint32 u32SlaveIsrStatus;
  uint32 u32SlaveIsrEnable;
  uint32 u32MasterIsrStatus;
  uint32 u32MasterIsrEnable;
  struct LPI2C_Type * baseAddr;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  u32MasterIsrEnable = 0;
  # DEBUG BEGIN_STMT
  u32MasterIsrStatus = 0;
  # DEBUG BEGIN_STMT
  u32SlaveIsrEnable = 0;
  # DEBUG BEGIN_STMT
  u32SlaveIsrStatus = 0;
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  _1 = g_lpi2cSlaveStatePtr[instance];
  if (_1 != 0B)
    goto <bb 4>; [INV]
  else
    goto <bb 3>; [INV]

  <bb 3> :
  _2 = g_lpi2cMasterStatePtr[instance];
  if (_2 != 0B)
    goto <bb 4>; [INV]
  else
    goto <bb 12>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _3 = baseAddr->MIER;
  u32MasterIsrEnable = _3 & 32515;
  # DEBUG BEGIN_STMT
  _4 = baseAddr->MSR;
  u32MasterIsrStatus = _4 & 32515;
  # DEBUG BEGIN_STMT
  _5 = baseAddr->SIER;
  u32SlaveIsrEnable = _5 & 65295;
  # DEBUG BEGIN_STMT
  _6 = baseAddr->SSR;
  u32SlaveIsrStatus = _6 & 65295;
  # DEBUG BEGIN_STMT
  if (u32MasterIsrEnable != 0)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  if (u32MasterIsrStatus != 0)
    goto <bb 8>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 6> :
  if (u32SlaveIsrEnable != 0)
    goto <bb 7>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 7> :
  if (u32SlaveIsrStatus != 0)
    goto <bb 8>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 8> :
  # DEBUG BEGIN_STMT
  _7 = g_lpi2cSlaveStatePtr[instance];
  if (_7 == 0B)
    goto <bb 9>; [INV]
  else
    goto <bb 10>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterIRQHandler (instance);
  goto <bb 13>; [INV]

  <bb 10> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveIRQHandler (instance);
  goto <bb 13>; [INV]

  <bb 11> :
  # DEBUG BEGIN_STMT
  _8 = baseAddr->MSR;
  baseAddr->MSR = _8;
  # DEBUG BEGIN_STMT
  _9 = baseAddr->SSR;
  baseAddr->SSR = _9;
  goto <bb 13>; [INV]

  <bb 12> :
  # DEBUG BEGIN_STMT
  _10 = baseAddr->MSR;
  baseAddr->MSR = _10;
  # DEBUG BEGIN_STMT
  _11 = baseAddr->SSR;
  baseAddr->SSR = _11;

  <bb 13> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  return;

}


Lpi2c_Ip_SlaveIRQHandler (uint32 instance)
{
  boolean repeatStartDetect;
  boolean stopDetect;
  struct Lpi2c_Ip_SlaveStateType * slave;
  struct LPI2C_Type * baseAddr;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  stopDetect = 0;
  repeatStartDetect = 0;
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  slave = g_lpi2cSlaveStatePtr[instance];
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveCheckDataEvent (instance, baseAddr, slave);
  # DEBUG BEGIN_STMT
  stopDetect = LPI2C_Get_SlaveSTOPDetectEvent (baseAddr);
  # DEBUG BEGIN_STMT
  repeatStartDetect = LPI2C_Get_SlaveRepeatedStartEvent (baseAddr);
  # DEBUG BEGIN_STMT
  if (repeatStartDetect != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _1 = slave->repeatedStarts;
  _2 = _1;
  _3 = _2 + 1;
  slave->repeatedStarts = _3;
  # DEBUG BEGIN_STMT
  _4 = slave->repeatedStarts;
  if (_4 == 1)
    goto <bb 4>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 4> :
  _5 = slave->is10bitAddress;
  if (_5 != 0)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  repeatStartDetect = 0;
  # DEBUG BEGIN_STMT
  LPI2C_Clear_SlaveRepeatedStartEvent (baseAddr);

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

  <bb 7> :
  if (repeatStartDetect != 0)
    goto <bb 8>; [INV]
  else
    goto <bb 10>; [INV]

  <bb 8> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveStopDetectHandler (baseAddr, slave);
  # DEBUG BEGIN_STMT
  if (stopDetect != 0)
    goto <bb 9>; [INV]
  else
    goto <bb 10>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  slave->repeatedStarts = 0;

  <bb 10> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveCheckErrorEvent (baseAddr, slave);
  return;

}


Lpi2c_Ip_SlaveCheckErrorEvent (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_SlaveStateType * slave)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = LPI2C_Get_SlaveBitErrorEvent (baseAddr);
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveBitErrorEventHandler (baseAddr, slave);

  <bb 4> :
  return;

}


Lpi2c_Ip_SlaveBitErrorEventHandler (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_SlaveStateType * slave)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  slave->status = 1;
  # DEBUG BEGIN_STMT
  LPI2C_Clear_SlaveBitErrorEvent (baseAddr);
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveInt (baseAddr, 1, 0);
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveEndTransferHandler (slave, baseAddr);
  return;

}


Lpi2c_Ip_SlaveStopDetectHandler (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_SlaveStateType * slave)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  LPI2C_Clear_SlaveSTOPDetectEvent (baseAddr);
  # DEBUG BEGIN_STMT
  LPI2C_Clear_SlaveRepeatedStartEvent (baseAddr);
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveInt (baseAddr, 1, 0);
  # DEBUG BEGIN_STMT
  _1 = slave->status;
  if (_1 == 2)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  slave->status = 0;

  <bb 4> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveEndTransferHandler (slave, baseAddr);
  return;

}


Lpi2c_Ip_SlaveCheckDataEvent (uint32 instance, struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_SlaveStateType * slave)
{
  boolean slaveInterrupt;

  <bb 2> :
  # DEBUG BEGIN_STMT
  slaveInterrupt = 0;
  # DEBUG BEGIN_STMT
  _1 = LPI2C_Get_SlaveAddressValidEvent (baseAddr);
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveHandleAddressValidEvent (instance, baseAddr, slave);

  <bb 4> :
  # DEBUG BEGIN_STMT
  _2 = LPI2C_Get_SlaveTransmitDataEvent (baseAddr);
  if (_2 != 0)
    goto <bb 5>; [INV]
  else
    goto <bb 7>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  slaveInterrupt = LPI2C_Get_SlaveInt (baseAddr, 1);
  # DEBUG BEGIN_STMT
  if (slaveInterrupt != 0)
    goto <bb 6>; [INV]
  else
    goto <bb 7>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveHandleTransmitDataEvent (baseAddr, slave);

  <bb 7> :
  # DEBUG BEGIN_STMT
  _3 = LPI2C_Get_SlaveReceiveDataEvent (baseAddr);
  if (_3 != 0)
    goto <bb 8>; [INV]
  else
    goto <bb 10>; [INV]

  <bb 8> :
  # DEBUG BEGIN_STMT
  slaveInterrupt = LPI2C_Get_SlaveInt (baseAddr, 2);
  # DEBUG BEGIN_STMT
  if (slaveInterrupt != 0)
    goto <bb 9>; [INV]
  else
    goto <bb 10>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveHandleReceiveDataEvent (baseAddr, slave);

  <bb 10> :
  return;

}


Lpi2c_Ip_SlaveEndTransferHandler (const struct Lpi2c_Ip_SlaveStateType * slave, struct LPI2C_Type * baseAddr)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = slave->slaveListening;
  _2 = ~_1;
  if (_2 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveEndTransfer (baseAddr);

  <bb 4> :
  # DEBUG BEGIN_STMT
  _3 = slave->slaveCallback;
  if (_3 != 0B)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  _4 = slave->slaveCallback;
  _5 = slave->callbackParam;
  _4 (7, _5);

  <bb 6> :
  # DEBUG BEGIN_STMT
  return;

}


Lpi2c_Ip_SlaveEndTransfer (struct LPI2C_Type * baseAddr)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveInt (baseAddr, 3847, 0);
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveEnable (baseAddr, 0);
  return;

}


Lpi2c_Ip_SlaveGetTransferStatus (uint32 instance, uint32 * bytesRemaining)
{
  const struct Lpi2c_Ip_SlaveStateType * slave;
  Lpi2c_Ip_StatusType D.5520;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  slave = g_lpi2cSlaveStatePtr[instance];
  # DEBUG BEGIN_STMT
  if (bytesRemaining != 0B)
    goto <bb 3>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 3> :
  _1 = slave->transferType;
  if (_1 == 1)
    goto <bb 4>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _2 = slave->bufferSize;
  *bytesRemaining = _2;

  <bb 5> :
  # DEBUG BEGIN_STMT
  D.5520 = slave->status;
  return D.5520;

}


Lpi2c_Ip_SlaveSetBuffer (uint32 instance, uint8 * dataBuff, uint32 dataSize)
{
  struct Lpi2c_Ip_SlaveStateType * slave;
  Lpi2c_Ip_StatusType D.5514;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  slave = g_lpi2cSlaveStatePtr[instance];
  # DEBUG BEGIN_STMT
  slave->dataBuffer = dataBuff;
  # DEBUG BEGIN_STMT
  slave->bufferSize = dataSize;
  # DEBUG BEGIN_STMT
  D.5514 = 0;
  return D.5514;

}


Lpi2c_Ip_SlaveDeinit (uint32 instance)
{
  const struct Lpi2c_Ip_SlaveStateType * slave;
  struct LPI2C_Type * baseAddr;
  Lpi2c_Ip_StatusType D.5504;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  slave = g_lpi2cSlaveStatePtr[instance];
  # DEBUG BEGIN_STMT
  _1 = slave->transferType;
  if (_1 == 0)
    goto <bb 3>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 3> :
  _2 = slave->slaveListening;
  if (_2 != 0)
    goto <bb 4>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveRxDMA (baseAddr, 0);
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveTxDMA (baseAddr, 0);

  <bb 5> :
  # DEBUG BEGIN_STMT
  g_lpi2cSlaveStatePtr[instance] = 0B;
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveEnable (baseAddr, 0);
  # DEBUG BEGIN_STMT
  D.5504 = 0;
  return D.5504;

}


Lpi2c_Ip_StartListening (uint32 u32Instance)
{
  const struct Lpi2c_Ip_SlaveStateType * slave;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  slave = g_lpi2cSlaveStatePtr[u32Instance];
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveActivateEvents (u32Instance);
  # DEBUG BEGIN_STMT
  return;

}


Lpi2c_Ip_SlaveInit (uint32 instance, const struct Lpi2c_Ip_SlaveConfigType * userConfigPtr)
{
  struct Lpi2c_Ip_SlaveStateType * slave;
  struct LPI2C_Type * baseAddr;
  Lpi2c_Ip_StatusType D.5466;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  _1 = userConfigPtr->slaveState;
  g_lpi2cSlaveStatePtr[instance] = _1;
  # DEBUG BEGIN_STMT
  slave = g_lpi2cSlaveStatePtr[instance];
  # DEBUG BEGIN_STMT
  slave->status = 0;
  # DEBUG BEGIN_STMT
  _2 = userConfigPtr->slaveCallback;
  slave->slaveCallback = _2;
  # DEBUG BEGIN_STMT
  _3 = userConfigPtr->callbackParam;
  slave->callbackParam = _3;
  # DEBUG BEGIN_STMT
  slave->dataBuffer = 0B;
  # DEBUG BEGIN_STMT
  slave->bufferSize = 0;
  # DEBUG BEGIN_STMT
  slave->direction = 0;
  # DEBUG BEGIN_STMT
  _4 = userConfigPtr->transferType;
  slave->transferType = _4;
  # DEBUG BEGIN_STMT
  _5 = userConfigPtr->dmaTxChannel;
  slave->dmaTxChannel = _5;
  # DEBUG BEGIN_STMT
  _6 = userConfigPtr->dmaRxChannel;
  slave->dmaRxChannel = _6;
  # DEBUG BEGIN_STMT
  slave->isTransferInProgress = 0;
  # DEBUG BEGIN_STMT
  _7 = userConfigPtr->is10bitAddr;
  slave->is10bitAddress = _7;
  # DEBUG BEGIN_STMT
  slave->repeatedStarts = 0;
  # DEBUG BEGIN_STMT
  _8 = userConfigPtr->slaveListening;
  slave->slaveListening = _8;
  # DEBUG BEGIN_STMT
  LPI2C_Init (baseAddr);
  # DEBUG BEGIN_STMT
  _9 = userConfigPtr->slaveAddress;
  _10 = userConfigPtr->is10bitAddr;
  Lpi2c_Ip_SlaveConigureAddress (baseAddr, _9, _10);
  # DEBUG BEGIN_STMT
  _11 = userConfigPtr->operatingMode;
  Lpi2c_Ip_SlaveSetOperatingMode (instance, _11);
  # DEBUG BEGIN_STMT
  _12 = userConfigPtr->u32GlitchFilterSDA;
  _13 = userConfigPtr->u32GlitchFilterSCL;
  Lpi2c_Ip_SlaveConfigureGlitchFilter (baseAddr, _12, _13);
  # DEBUG BEGIN_STMT
  _14 = slave->slaveListening;
  if (_14 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveActivateEvents (instance);

  <bb 4> :
  # DEBUG BEGIN_STMT
  D.5466 = 0;
  return D.5466;

}


Lpi2c_Ip_SlaveConfigureGlitchFilter (struct LPI2C_Type * baseAddr, uint32 u32GlitchFilterSDA, uint32 u32GlitchFilterSCL)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveGlitchFilterSDA (baseAddr, u32GlitchFilterSDA);
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveGlitchFilterSCL (baseAddr, u32GlitchFilterSCL);
  return;

}


Lpi2c_Ip_SlaveConigureAddress (struct LPI2C_Type * baseAddr, uint16 slaveAddr, boolean is10bitAddr)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveAddr0 (baseAddr, slaveAddr);
  # DEBUG BEGIN_STMT
  if (is10bitAddr != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveAddrConfig (baseAddr, 1);
  goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveAddrConfig (baseAddr, 0);

  <bb 5> :
  return;

}


Lpi2c_Ip_SlaveActivateEvents (uint32 instance)
{
  const struct Lpi2c_Ip_SlaveStateType * slave;
  struct LPI2C_Type * baseAddr;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  slave = g_lpi2cSlaveStatePtr[instance];
  # DEBUG BEGIN_STMT
  _1 = slave->transferType;
  if (_1 == 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveInt (baseAddr, 3844, 1);

  <bb 4> :
  # DEBUG BEGIN_STMT
  _2 = slave->transferType;
  if (_2 == 1)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveInt (baseAddr, 3846, 1);

  <bb 6> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveEnable (baseAddr, 1);
  return;

}


Lpi2c_Ip_MasterIRQHandler (uint32 instance)
{
  struct Lpi2c_Ip_MasterStateType * master;
  struct LPI2C_Type * baseAddr;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterCheckDataTxRxEvent (baseAddr, master);
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterCheckErrorEvents (baseAddr, master);
  # DEBUG BEGIN_STMT
  _1 = LPI2C_Get_MasterPinLowTimeoutEvent (baseAddr);
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _2 = master->masterCallback;
  if (_2 != 0B)
    goto <bb 4>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _3 = master->masterCallback;
  _4 = master->callbackParam;
  _3 (12, _4);

  <bb 5> :
  # DEBUG BEGIN_STMT
  LPI2C_Clear_MasterPinLowTimeoutEvent (baseAddr);

  <bb 6> :
  return;

}


Lpi2c_Ip_MasterCheckDataTxRxEvent (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = LPI2C_Get_MasterTransmitDataRequestEvent (baseAddr);
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterHandleTransmitDataRequest (baseAddr, master);

  <bb 4> :
  # DEBUG BEGIN_STMT
  _2 = LPI2C_Get_MasterReceiveDataReadyEvent (baseAddr);
  if (_2 != 0)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterHandleReceiveDataReadyEvent (baseAddr, master);

  <bb 6> :
  return;

}


Lpi2c_Ip_MasterGetTransferStatus (uint32 instance, uint32 * bytesRemaining)
{
  const struct Lpi2c_Ip_MasterStateType * master;
  Lpi2c_Ip_StatusType D.5431;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  if (bytesRemaining != 0B)
    goto <bb 3>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 3> :
  _1 = master->transferType;
  if (_1 == 1)
    goto <bb 4>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _2 = master->bufferSize;
  *bytesRemaining = _2;

  <bb 5> :
  # DEBUG BEGIN_STMT
  D.5431 = master->status;
  return D.5431;

}


Lpi2c_Ip_MasterReceiveDataBlocking (uint32 instance, uint8 * rxBuff, uint32 rxSize, boolean sendStop, uint32 timeout)
{
  Lpi2c_Ip_StatusType retStatus;
  uint32 TimeoutTicks;
  uint32 ElapsedTicks;
  uint32 CurrentTicks;
  struct Lpi2c_Ip_MasterStateType * master;
  Lpi2c_Ip_StatusType D.5405;
  long unsigned int D.5401;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  CurrentTicks = 0;
  # DEBUG BEGIN_STMT
  ElapsedTicks = 0;
  # DEBUG BEGIN_STMT
  TimeoutTicks = OsIf_MicrosToTicks (timeout, 1);
  # DEBUG BEGIN_STMT
  retStatus = 2;
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  _1 = master->i2cIdle;
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 9>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  master->bufferSize = rxSize;
  # DEBUG BEGIN_STMT
  master->dataBuffer = rxBuff;
  # DEBUG BEGIN_STMT
  master->direction = 1;
  # DEBUG BEGIN_STMT
  master->sendStop = sendStop;
  # DEBUG BEGIN_STMT
  master->i2cIdle = 0;
  # DEBUG BEGIN_STMT
  master->status = 2;
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterInterruptReceiveInit (instance, rxSize);
  # DEBUG BEGIN_STMT
  _2 = OsIf_GetCounter (1);
  CurrentTicks = _2;

  <bb 4> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterReceive (instance);
  # DEBUG BEGIN_STMT
  D.5401 = OsIf_GetElapsed (&CurrentTicks, 1);
  ElapsedTicks = D.5401 + ElapsedTicks;
  # DEBUG BEGIN_STMT
  _3 = Lpi2c_Ip_MasterGetTransferStatus (instance, 0B);
  if (_3 == 2)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  if (ElapsedTicks < TimeoutTicks)
    goto <bb 4>; [INV]
  else
    goto <bb 6>; [INV]

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

  <bb 7> :
  # DEBUG BEGIN_STMT
  master->status = 9;

  <bb 8> :
  # DEBUG BEGIN_STMT
  retStatus = master->status;

  <bb 9> :
  # DEBUG BEGIN_STMT
  D.5405 = retStatus;
  CurrentTicks = {CLOBBER};
  return D.5405;

}


Lpi2c_Ip_MasterReceiveData (uint32 instance, uint8 * rxBuff, uint32 rxSize, boolean sendStop)
{
  Lpi2c_Ip_StatusType retStatus;
  struct Lpi2c_Ip_MasterStateType * master;
  struct LPI2C_Type * baseAddr;
  Lpi2c_Ip_StatusType D.5393;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  retStatus = 2;
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  _1 = master->i2cIdle;
  _2 = ~_1;
  if (_2 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  retStatus = 2;
  goto <bb 7>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  retStatus = 0;
  # DEBUG BEGIN_STMT
  master->bufferSize = rxSize;
  # DEBUG BEGIN_STMT
  master->i2cIdle = 0;
  # DEBUG BEGIN_STMT
  master->sendStop = sendStop;
  # DEBUG BEGIN_STMT
  master->dataBuffer = rxBuff;
  # DEBUG BEGIN_STMT
  master->direction = 1;
  # DEBUG BEGIN_STMT
  master->status = 2;
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterInterruptReceiveInit (instance, rxSize);
  # DEBUG BEGIN_STMT
  _3 = Lpi2c_Ip_MasterCmdQueueEmpty (master);
  _4 = ~_3;
  if (_4 != 0)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterInt (baseAddr, 7171, 1);
  goto <bb 7>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterInt (baseAddr, 7170, 1);

  <bb 7> :
  # DEBUG BEGIN_STMT
  D.5393 = retStatus;
  return D.5393;

}


Lpi2c_Ip_MasterInterruptReceiveInit (uint32 instance, uint32 rxSize)
{
  uint16 rxBytes;
  struct Lpi2c_Ip_MasterStateType * master;
  struct LPI2C_Type * baseAddr;

  <bb 2> :
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterSendAddress (baseAddr, master, 1);
  # DEBUG BEGIN_STMT
  _1 = (unsigned char) rxSize;
  _2 = _1 + 255;
  Lpi2c_Ip_MasterQueueCmd (baseAddr, master, 1, _2);
  # DEBUG BEGIN_STMT
  rxBytes = LPI2C_Get_MasterRxFIFOSize (baseAddr);
  # DEBUG BEGIN_STMT
  _3 = (long unsigned int) rxBytes;
  if (rxSize < _3)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _4 = (unsigned char) rxSize;
  rxBytes = (uint16) _4;

  <bb 4> :
  # DEBUG BEGIN_STMT
  _5 = rxBytes + 65535;
  LPI2C_Set_MasterRxFIFOWatermark (baseAddr, _5);
  return;

}


Lpi2c_Ip_MasterSendDataBlocking (uint32 instance, uint8 * txBuff, uint32 txSize, boolean sendStop, uint32 timeout)
{
  struct Lpi2c_Ip_MasterStateType * master;
  struct LPI2C_Type * baseAddr;
  Lpi2c_Ip_StatusType retStatus;
  uint32 TimeoutTicks;
  uint32 ElapsedTicks;
  uint32 CurrentTicks;
  Lpi2c_Ip_StatusType D.5340;
  long unsigned int D.5336;

  <bb 2> :
  # DEBUG BEGIN_STMT
  CurrentTicks = 0;
  # DEBUG BEGIN_STMT
  ElapsedTicks = 0;
  # DEBUG BEGIN_STMT
  TimeoutTicks = OsIf_MicrosToTicks (timeout, 1);
  # DEBUG BEGIN_STMT
  retStatus = 2;
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  _1 = master->i2cIdle;
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 9>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  master->bufferSize = txSize;
  # DEBUG BEGIN_STMT
  master->dataBuffer = txBuff;
  # DEBUG BEGIN_STMT
  master->direction = 0;
  # DEBUG BEGIN_STMT
  master->sendStop = sendStop;
  # DEBUG BEGIN_STMT
  master->i2cIdle = 0;
  # DEBUG BEGIN_STMT
  master->status = 2;
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterInitSendTransfer (baseAddr, master);
  # DEBUG BEGIN_STMT
  _2 = OsIf_GetCounter (1);
  CurrentTicks = _2;

  <bb 4> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterSend (instance);
  # DEBUG BEGIN_STMT
  D.5336 = OsIf_GetElapsed (&CurrentTicks, 1);
  ElapsedTicks = D.5336 + ElapsedTicks;
  # DEBUG BEGIN_STMT
  _3 = Lpi2c_Ip_MasterGetTransferStatus (instance, 0B);
  if (_3 == 2)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  if (ElapsedTicks < TimeoutTicks)
    goto <bb 4>; [INV]
  else
    goto <bb 6>; [INV]

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

  <bb 7> :
  # DEBUG BEGIN_STMT
  master->status = 9;

  <bb 8> :
  # DEBUG BEGIN_STMT
  retStatus = master->status;

  <bb 9> :
  # DEBUG BEGIN_STMT
  D.5340 = retStatus;
  CurrentTicks = {CLOBBER};
  return D.5340;

}


Lpi2c_Ip_MasterInitSendTransfer (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterSendAddress (baseAddr, master, 0);
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterQueueData (baseAddr, master);
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterTxFIFOWatermark (baseAddr, 0);
  return;

}


Lpi2c_Ip_MasterSendData (uint32 instance, uint8 * txBuff, uint32 txSize, boolean sendStop)
{
  Lpi2c_Ip_StatusType retStatus;
  struct Lpi2c_Ip_MasterStateType * master;
  struct LPI2C_Type * baseAddr;
  Lpi2c_Ip_StatusType D.5305;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  retStatus = 2;
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  _1 = master->i2cIdle;
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  master->bufferSize = txSize;
  # DEBUG BEGIN_STMT
  master->dataBuffer = txBuff;
  # DEBUG BEGIN_STMT
  master->direction = 0;
  # DEBUG BEGIN_STMT
  master->sendStop = sendStop;
  # DEBUG BEGIN_STMT
  master->i2cIdle = 0;
  # DEBUG BEGIN_STMT
  master->status = 2;
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterSendAddress (baseAddr, master, 0);
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterQueueData (baseAddr, master);
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterTxFIFOWatermark (baseAddr, 0);
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterInt (baseAddr, 15361, 1);
  # DEBUG BEGIN_STMT
  retStatus = 0;

  <bb 4> :
  # DEBUG BEGIN_STMT
  D.5305 = retStatus;
  return D.5305;

}


Lpi2c_Ip_MasterSetSlaveAddr (uint32 instance, const uint16 address, const boolean is10bitAddr)
{
  struct Lpi2c_Ip_MasterStateType * master;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  master->slaveAddress = address;
  # DEBUG BEGIN_STMT
  master->is10bitAddr = is10bitAddr;
  return;

}


Lpi2c_Ip_MasterGetBaudRate (uint32 instance, uint32 inputClock, uint32 * baudRate)
{
  uint32 clkHi;
  uint32 clkLo;
  uint32 prescaler;
  const struct Lpi2c_Ip_MasterStateType * master;
  const struct LPI2C_Type * baseAddr;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  _1 = LPI2C_Get_MasterPrescaler (baseAddr);
  prescaler = (uint32) _1;
  # DEBUG BEGIN_STMT
  _2 = LPI2C_Get_MasterClockHighPeriod (baseAddr);
  clkHi = (uint32) _2;
  # DEBUG BEGIN_STMT
  _3 = LPI2C_Get_MasterClockLowPeriod (baseAddr);
  clkLo = (uint32) _3;
  # DEBUG BEGIN_STMT
  _4 = clkLo + clkHi;
  _5 = _4 + 2;
  _6 = _5 << prescaler;
  _7 = inputClock / _6;
  *baudRate = _7;
  # DEBUG BEGIN_STMT
  _8 = master->operatingMode;
  if (_8 == 3)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _9 = LPI2C_Get_MasterClockHighPeriodHS (baseAddr);
  clkHi = (uint32) _9;
  # DEBUG BEGIN_STMT
  _10 = LPI2C_Get_MasterClockLowPeriodHS (baseAddr);
  clkLo = (uint32) _10;
  # DEBUG BEGIN_STMT
  _11 = clkLo + clkHi;
  _12 = _11 + 2;
  _13 = _12 << prescaler;
  _14 = inputClock / _13;
  *baudRate = _14;

  <bb 4> :
  return;

}


Lpi2c_Ip_MasterDeinit (uint32 instance)
{
  const struct Lpi2c_Ip_MasterStateType * master;
  struct LPI2C_Type * baseAddr;
  Lpi2c_Ip_StatusType D.5289;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  g_lpi2cMasterStatePtr[instance] = 0B;
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterEnable (baseAddr, 0);
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  D.5289 = 0;
  return D.5289;

}


Lpi2c_Ip_MasterInit (uint32 instance, const struct Lpi2c_Ip_MasterConfigType * userConfigPtr)
{
  struct Lpi2c_Ip_MasterStateType * master;
  struct LPI2C_Type * baseAddr;
  Lpi2c_Ip_StatusType D.5279;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  _1 = userConfigPtr->masterState;
  g_lpi2cMasterStatePtr[instance] = _1;
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  master->direction = 0;
  # DEBUG BEGIN_STMT
  master->dataBuffer = 0B;
  # DEBUG BEGIN_STMT
  master->bufferSize = 0;
  # DEBUG BEGIN_STMT
  master->status = 0;
  # DEBUG BEGIN_STMT
  master->i2cIdle = 1;
  # DEBUG BEGIN_STMT
  _2 = userConfigPtr->slaveAddress;
  master->slaveAddress = _2;
  # DEBUG BEGIN_STMT
  _3 = userConfigPtr->is10bitAddr;
  master->is10bitAddr = _3;
  # DEBUG BEGIN_STMT
  _4 = userConfigPtr->transferType;
  master->transferType = _4;
  # DEBUG BEGIN_STMT
  _5 = userConfigPtr->dmaTxChannel;
  master->dmaTxChannel = _5;
  # DEBUG BEGIN_STMT
  _6 = userConfigPtr->dmaRxChannel;
  master->dmaRxChannel = _6;
  # DEBUG BEGIN_STMT
  _7 = userConfigPtr->masterCallback;
  master->masterCallback = _7;
  # DEBUG BEGIN_STMT
  _8 = userConfigPtr->callbackParam;
  master->callbackParam = _8;
  # DEBUG BEGIN_STMT
  _9 = userConfigPtr->masterCode;
  master->masterCode = _9;
  # DEBUG BEGIN_STMT
  master->highSpeedInProgress = 0;
  # DEBUG BEGIN_STMT
  _10 = userConfigPtr->baudrateParams;
  master->baudrateParams = _10;
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterInitModule (baseAddr, master);
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterConfigFeatures (baseAddr, userConfigPtr);
  # DEBUG BEGIN_STMT
  _11 = userConfigPtr->operatingMode;
  _12 = master->baudrateParams;
  Lpi2c_Ip_MasterSetBaudRateInit (instance, _11, _12);
  # DEBUG BEGIN_STMT
  _13 = userConfigPtr->slaveAddress;
  _14 = userConfigPtr->is10bitAddr;
  Lpi2c_Ip_MasterSetSlaveAddr (instance, _13, _14);
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterEnable (baseAddr, 1);
  # DEBUG BEGIN_STMT
  D.5279 = 0;
  return D.5279;

}


Lpi2c_Ip_MasterConfigFeatures (struct LPI2C_Type * baseAddr, const struct Lpi2c_Ip_MasterConfigType * userConfigPtr)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = userConfigPtr->u32GlitchFilterSDA;
  LPI2C_Set_MasterGlitchFilterSDA (baseAddr, _1);
  # DEBUG BEGIN_STMT
  _2 = userConfigPtr->u32GlitchFilterSCL;
  LPI2C_Set_MasterGlitchFilterSCL (baseAddr, _2);
  # DEBUG BEGIN_STMT
  _3 = userConfigPtr->u32BusIdleTimeout;
  LPI2C_Set_MasterBusIdleTimeout (baseAddr, _3);
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterPinLowTimeoutConfiguration (baseAddr, 1);
  # DEBUG BEGIN_STMT
  _4 = userConfigPtr->u32PinLowTimeout;
  LPI2C_Set_MasterPinLowTimeout (baseAddr, _4);
  return;

}


Lpi2c_Ip_MasterInitModule (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterResetQueue (master);
  # DEBUG BEGIN_STMT
  LPI2C_Init (baseAddr);
  return;

}


Lpi2c_Ip_MasterSetBaudRateInit (uint32 instance, const Lpi2c_Ip_ModeType operatingMode, const struct Lpi2c_Ip_BaudRateType * baudRate)
{
  Lpi2c_Ip_StatusType retStatus;
  const struct Lpi2c_Ip_MasterStateType * master;
  struct LPI2C_Type * baseAddr;
  Lpi2c_Ip_StatusType D.5287;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  retStatus = 2;
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  _1 = master->i2cIdle;
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterEnable (baseAddr, 0);
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_BaudRateConfig (baseAddr, baudRate);
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_HSBaudRateConfig (baseAddr, baudRate);
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterSetOperatingMode (instance, operatingMode);
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterEnable (baseAddr, 1);
  # DEBUG BEGIN_STMT
  retStatus = 0;

  <bb 4> :
  # DEBUG BEGIN_STMT
  D.5287 = retStatus;
  return D.5287;

}


Lpi2c_Ip_MasterSetBaudRate (uint32 instance, Lpi2c_Ip_ModeType operatingMode, uint32 baudrate, uint32 inputClock)
{
  Lpi2c_Ip_StatusType retStatus;
  uint32 dataVd;
  uint32 setHold;
  uint32 clkHi;
  uint32 clkLo;
  uint32 clkTotal;
  uint32 prescaler;
  uint32 minPrescaler;
  struct Lpi2c_Ip_BaudRateType baudRateParams;
  const struct Lpi2c_Ip_MasterStateType * master;
  struct LPI2C_Type * baseAddr;
  Lpi2c_Ip_StatusType D.5272;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  minPrescaler = 0;
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  retStatus = 2;
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  _1 = master->i2cIdle;
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 24>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterEnable (baseAddr, 0);
  # DEBUG BEGIN_STMT
  if (baudrate != 0)
    goto <bb 4>; [INV]
  else
    goto <bb 9>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _2 = inputClock + 4294967295;
  _3 = baudrate * 128;
  _4 = _2 / _3;
  minPrescaler = _4 + 1;
  # DEBUG BEGIN_STMT
  prescaler = 0;
  goto <bb 7>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  _5 = 1 << prescaler;
  if (minPrescaler <= _5)
    goto <bb 8>; [INV]
  else
    goto <bb 6>; [INV]

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

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

  <bb 8> :
  # DEBUG BEGIN_STMT
  _6 = baudrate << prescaler;
  _7 = _6 >> 1;
  _8 = inputClock + _7;
  _9 = baudrate << prescaler;
  clkTotal = _8 / _9;
  goto <bb 10>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  prescaler = 7;
  # DEBUG BEGIN_STMT
  clkTotal = 128;

  <bb 10> :
  # DEBUG BEGIN_STMT
  if (clkTotal > 128)
    goto <bb 11>; [INV]
  else
    goto <bb 12>; [INV]

  <bb 11> :
  # DEBUG BEGIN_STMT
  clkTotal = 128;

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

  <bb 13> :
  # DEBUG BEGIN_STMT
  clkHi = 0;
  # DEBUG BEGIN_STMT
  clkLo = 0;
  goto <bb 15>; [INV]

  <bb 14> :
  # DEBUG BEGIN_STMT
  _10 = clkTotal + 4294967294;
  clkHi = _10 / 2;
  # DEBUG BEGIN_STMT
  _11 = clkTotal - clkHi;
  clkLo = _11 + 4294967294;

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

  <bb 16> :
  # DEBUG BEGIN_STMT
  clkHi = 1;

  <bb 17> :
  # DEBUG BEGIN_STMT
  if (clkLo <= 2)
    goto <bb 18>; [INV]
  else
    goto <bb 19>; [INV]

  <bb 18> :
  # DEBUG BEGIN_STMT
  clkLo = 3;

  <bb 19> :
  # DEBUG BEGIN_STMT
  setHold = clkHi;
  # DEBUG BEGIN_STMT
  dataVd = clkHi >> 1;
  # DEBUG BEGIN_STMT
  if (setHold <= 1)
    goto <bb 20>; [INV]
  else
    goto <bb 21>; [INV]

  <bb 20> :
  # DEBUG BEGIN_STMT
  setHold = 2;

  <bb 21> :
  # DEBUG BEGIN_STMT
  if (dataVd == 0)
    goto <bb 22>; [INV]
  else
    goto <bb 23>; [INV]

  <bb 22> :
  # DEBUG BEGIN_STMT
  dataVd = 1;

  <bb 23> :
  # DEBUG BEGIN_STMT
  _12 = (<unnamed type>) prescaler;
  baudRateParams.prescaler = _12;
  # DEBUG BEGIN_STMT
  baudRateParams.dataValid = dataVd;
  # DEBUG BEGIN_STMT
  baudRateParams.setHold = setHold;
  # DEBUG BEGIN_STMT
  baudRateParams.clkHI = clkHi;
  # DEBUG BEGIN_STMT
  baudRateParams.clkLO = clkLo;
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_BaudRateConfig (baseAddr, &baudRateParams);
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterSetOperatingMode (instance, operatingMode);
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterEnable (baseAddr, 1);
  # DEBUG BEGIN_STMT
  retStatus = 0;

  <bb 24> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  D.5272 = retStatus;
  baudRateParams = {CLOBBER};
  return D.5272;

}


Lpi2c_Ip_HSBaudRateConfig (struct LPI2C_Type * baseAddr, const struct Lpi2c_Ip_BaudRateType * baudRate)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = baudRate->setHoldHS;
  _2 = (unsigned char) _1;
  LPI2C_Set_MasterDataValidDelayHS (baseAddr, _2);
  # DEBUG BEGIN_STMT
  _3 = baudRate->dataValidHS;
  _4 = (unsigned char) _3;
  LPI2C_Set_MasterSetupHoldDelayHS (baseAddr, _4);
  # DEBUG BEGIN_STMT
  _5 = baudRate->clkHIHS;
  _6 = (unsigned char) _5;
  LPI2C_Set_MasterClockHighPeriodHS (baseAddr, _6);
  # DEBUG BEGIN_STMT
  _7 = baudRate->clkLOHS;
  _8 = (unsigned char) _7;
  LPI2C_Set_MasterClockLowPeriodHS (baseAddr, _8);
  return;

}


Lpi2c_Ip_BaudRateConfig (struct LPI2C_Type * baseAddr, const struct Lpi2c_Ip_BaudRateType * baudRate)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = baudRate->prescaler;
  LPI2C_Set_MasterPrescaler (baseAddr, _1);
  # DEBUG BEGIN_STMT
  _2 = baudRate->setHold;
  _3 = (unsigned char) _2;
  LPI2C_Set_MasterSetupHoldDelay (baseAddr, _3);
  # DEBUG BEGIN_STMT
  _4 = baudRate->dataValid;
  _5 = (unsigned char) _4;
  LPI2C_Set_MasterDataValidDelay (baseAddr, _5);
  # DEBUG BEGIN_STMT
  _6 = baudRate->clkHI;
  _7 = (unsigned char) _6;
  LPI2C_Set_MasterClockHighPeriod (baseAddr, _7);
  # DEBUG BEGIN_STMT
  _8 = baudRate->clkLO;
  _9 = (unsigned char) _8;
  LPI2C_Set_MasterClockLowPeriod (baseAddr, _9);
  return;

}


Lpi2c_Ip_MasterReceive (uint32 instance)
{
  struct Lpi2c_Ip_MasterStateType * master;
  struct LPI2C_Type * baseAddr;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  _1 = LPI2C_Get_MasterReceiveDataReadyEvent (baseAddr);
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 8>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterGetReceivedData (baseAddr, master);
  # DEBUG BEGIN_STMT
  _2 = master->bufferSize;
  if (_2 == 0)
    goto <bb 4>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _3 = master->sendStop;
  Lpi2c_Ip_MasterEndTransfer (baseAddr, master, _3, 0);
  # DEBUG BEGIN_STMT
  master->status = 0;
  # DEBUG BEGIN_STMT
  _4 = master->masterCallback;
  if (_4 != 0B)
    goto <bb 5>; [INV]
  else
    goto <bb 8>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  _5 = master->masterCallback;
  _6 = master->callbackParam;
  _5 (11, _6);
  goto <bb 8>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  _7 = master->bufferSize;
  _8 = LPI2C_Get_MasterRxFIFOWatermark (baseAddr);
  _9 = (long unsigned int) _8;
  if (_7 <= _9)
    goto <bb 7>; [INV]
  else
    goto <bb 8>; [INV]

  <bb 7> :
  # DEBUG BEGIN_STMT
  _10 = master->bufferSize;
  _11 = (short unsigned int) _10;
  _12 = _11 + 65535;
  LPI2C_Set_MasterRxFIFOWatermark (baseAddr, _12);

  <bb 8> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterCheckErrorEvents (baseAddr, master);
  return;

}


Lpi2c_Ip_MasterGetReceivedData (const struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _1 = master->dataBuffer;
  _2 = LPI2C_Get_MasterRxData (baseAddr);
  *_1 = _2;
  # DEBUG BEGIN_STMT
  _3 = master->dataBuffer;
  _4 = _3 + 1;
  master->dataBuffer = _4;
  # DEBUG BEGIN_STMT
  _5 = master->bufferSize;
  _6 = _5 + 4294967295;
  master->bufferSize = _6;

  <bb 4> :
  # DEBUG BEGIN_STMT
  _7 = LPI2C_Get_MasterRxFIFOCount (baseAddr);
  if (_7 != 0)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  _8 = master->bufferSize;
  if (_8 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 6> :
  return;

}


Lpi2c_Ip_MasterSend (uint32 instance)
{
  boolean masterCmdQueueEmpty;
  struct Lpi2c_Ip_MasterStateType * master;
  struct LPI2C_Type * baseAddr;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  masterCmdQueueEmpty = 0;
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  _1 = LPI2C_Get_MasterTransmitDataRequestEvent (baseAddr);
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _2 = Lpi2c_Ip_MasterCmdQueueEmpty (master);
  _3 = ~_2;
  if (_3 != 0)
    goto <bb 4>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterSendQueuedCmd (baseAddr, master);
  goto <bb 6>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  masterCmdQueueEmpty = 1;

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

  <bb 7> :
  # DEBUG BEGIN_STMT
  _4 = master->dataBuffer;
  if (_4 != 0B)
    goto <bb 8>; [INV]
  else
    goto <bb 12>; [INV]

  <bb 8> :
  # DEBUG BEGIN_STMT
  _5 = master->bufferSize;
  if (_5 == 0)
    goto <bb 9>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  _6 = master->sendStop;
  Lpi2c_Ip_MasterEndTransfer (baseAddr, master, _6, 0);
  # DEBUG BEGIN_STMT
  master->status = 0;
  # DEBUG BEGIN_STMT
  _7 = master->masterCallback;
  if (_7 != 0B)
    goto <bb 10>; [INV]
  else
    goto <bb 12>; [INV]

  <bb 10> :
  # DEBUG BEGIN_STMT
  _8 = master->masterCallback;
  _9 = master->callbackParam;
  _8 (11, _9);
  goto <bb 12>; [INV]

  <bb 11> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterQueueData (baseAddr, master);

  <bb 12> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterCheckErrorEvents (baseAddr, master);
  return;

}


Lpi2c_Ip_MasterCheckErrorEvents (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = LPI2C_Get_MasterFIFOErrorEvent (baseAddr);
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  LPI2C_Get_MasterFIFOErrorEventHandler (baseAddr, master);

  <bb 4> :
  # DEBUG BEGIN_STMT
  _2 = LPI2C_Get_MasterArbitrationLostEvent (baseAddr);
  if (_2 != 0)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  LPI2C_Get_MasterArbitrationLostEventHandler (baseAddr, master);

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

  <bb 7> :
  # DEBUG BEGIN_STMT
  LPI2C_Get_MasterNACKDetectEventHandler (baseAddr, master);

  <bb 8> :
  return;

}


LPI2C_Get_MasterArbitrationLostEventHandler (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  LPI2C_Clear_MasterArbitrationLostEvent (baseAddr);
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterEndTransfer (baseAddr, master, 0, 1);
  # DEBUG BEGIN_STMT
  master->status = 6;
  # DEBUG BEGIN_STMT
  _1 = master->masterCallback;
  if (_1 != 0B)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _2 = master->masterCallback;
  _3 = master->callbackParam;
  _2 (11, _3);

  <bb 4> :
  return;

}


LPI2C_Get_MasterNACKDetectEventHandler (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  master->highSpeedInProgress = 0;
  # DEBUG BEGIN_STMT
  master->status = 3;
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterEndTransfer (baseAddr, master, 0, 1);
  # DEBUG BEGIN_STMT
  _1 = master->masterCallback;
  if (_1 != 0B)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _2 = master->masterCallback;
  _3 = master->callbackParam;
  _2 (11, _3);

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

}


LPI2C_Get_MasterFIFOErrorEventHandler (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  LPI2C_Clear_MasterFIFOErrorEvent (baseAddr);
  # DEBUG BEGIN_STMT
  _1 = master->operatingMode;
  if (_1 == 3)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  master->highSpeedInProgress = 0;

  <bb 4> :
  # DEBUG BEGIN_STMT
  master->status = 1;
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterEndTransfer (baseAddr, master, 0, 1);
  # DEBUG BEGIN_STMT
  _2 = master->masterCallback;
  if (_2 != 0B)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  _3 = master->masterCallback;
  _4 = master->callbackParam;
  _3 (11, _4);

  <bb 6> :
  return;

}


Lpi2c_Ip_SlaveHandleReceiveDataEvent (const struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_SlaveStateType * slave)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = slave->bufferSize;
  if (_1 == 0)
    goto <bb 3>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _2 = slave->slaveCallback;
  if (_2 != 0B)
    goto <bb 4>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _3 = slave->slaveCallback;
  _4 = slave->callbackParam;
  _3 (3, _4);

  <bb 5> :
  # DEBUG BEGIN_STMT
  _5 = slave->bufferSize;
  if (_5 == 0)
    goto <bb 6>; [INV]
  else
    goto <bb 7>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  slave->status = 5;
  # DEBUG BEGIN_STMT
  LPI2C_Get_SlaveData (baseAddr);
  goto <bb 8>; [INV]

  <bb 7> :
  # DEBUG BEGIN_STMT
  _6 = slave->dataBuffer;
  _7 = LPI2C_Get_SlaveData (baseAddr);
  *_6 = _7;
  # DEBUG BEGIN_STMT
  _8 = slave->dataBuffer;
  _9 = _8 + 1;
  slave->dataBuffer = _9;
  # DEBUG BEGIN_STMT
  _10 = slave->bufferSize;
  _11 = _10 + 4294967295;
  slave->bufferSize = _11;

  <bb 8> :
  return;

}


Lpi2c_Ip_SlaveHandleTransmitDataEvent (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_SlaveStateType * slave)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = slave->txUnderrunWarning;
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  slave->status = 4;

  <bb 4> :
  # DEBUG BEGIN_STMT
  _2 = slave->bufferSize;
  if (_2 == 0)
    goto <bb 5>; [INV]
  else
    goto <bb 7>; [INV]

  <bb 5> :
  # DEBUG BEGIN_STMT
  _3 = slave->slaveCallback;
  if (_3 != 0B)
    goto <bb 6>; [INV]
  else
    goto <bb 7>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  _4 = slave->slaveCallback;
  _5 = slave->callbackParam;
  _4 (4, _5);

  <bb 7> :
  # DEBUG BEGIN_STMT
  _6 = slave->bufferSize;
  if (_6 == 0)
    goto <bb 8>; [INV]
  else
    goto <bb 9>; [INV]

  <bb 8> :
  # DEBUG BEGIN_STMT
  slave->txUnderrunWarning = 1;
  # DEBUG BEGIN_STMT
  LPI2C_Transmit_SlaveData (baseAddr, 255);
  goto <bb 10>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  _7 = slave->dataBuffer;
  _8 = *_7;
  LPI2C_Transmit_SlaveData (baseAddr, _8);
  # DEBUG BEGIN_STMT
  _9 = slave->dataBuffer;
  _10 = _9 + 1;
  slave->dataBuffer = _10;
  # DEBUG BEGIN_STMT
  _11 = slave->bufferSize;
  _12 = _11 + 4294967295;
  slave->bufferSize = _12;

  <bb 10> :
  return;

}


Lpi2c_Ip_SlaveHandleAddressValidEvent (uint32 instance, const struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_SlaveStateType * slave)
{
  uint16 receivedAddr;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  receivedAddr = LPI2C_Get_SlaveReceivedAddr (baseAddr);
  # DEBUG BEGIN_STMT
  _1 = (unsigned int) receivedAddr;
  _2 = _1 & 1;
  if (_2 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 8>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  slave->direction = 0;
  # DEBUG BEGIN_STMT
  _3 = slave->slaveCallback;
  if (_3 != 0B)
    goto <bb 4>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _4 = slave->slaveCallback;
  _5 = slave->callbackParam;
  _4 (5, _5);

  <bb 5> :
  # DEBUG BEGIN_STMT
  _6 = slave->transferType;
  if (_6 == 1)
    goto <bb 6>; [INV]
  else
    goto <bb 7>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  _7 = g_lpi2cBase[instance];
  LPI2C_Set_SlaveInt (_7, 1, 1);

  <bb 7> :
  # DEBUG BEGIN_STMT
  slave->txUnderrunWarning = 0;
  goto <bb 10>; [INV]

  <bb 8> :
  # DEBUG BEGIN_STMT
  slave->direction = 1;
  # DEBUG BEGIN_STMT
  _8 = slave->slaveCallback;
  if (_8 != 0B)
    goto <bb 9>; [INV]
  else
    goto <bb 10>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  _9 = slave->slaveCallback;
  _10 = slave->callbackParam;
  _9 (6, _10);

  <bb 10> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  slave->status = 2;
  return;

}


Lpi2c_Ip_MasterHandleReceiveDataReadyEvent (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _1 = master->dataBuffer;
  _2 = LPI2C_Get_MasterRxData (baseAddr);
  *_1 = _2;
  # DEBUG BEGIN_STMT
  _3 = master->dataBuffer;
  _4 = _3 + 1;
  master->dataBuffer = _4;
  # DEBUG BEGIN_STMT
  _5 = master->bufferSize;
  _6 = _5 + 4294967295;
  master->bufferSize = _6;

  <bb 4> :
  # DEBUG BEGIN_STMT
  _7 = LPI2C_Get_MasterRxFIFOCount (baseAddr);
  if (_7 != 0)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  _8 = master->bufferSize;
  if (_8 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  _9 = master->bufferSize;
  if (_9 == 0)
    goto <bb 7>; [INV]
  else
    goto <bb 9>; [INV]

  <bb 7> :
  # DEBUG BEGIN_STMT
  _10 = master->sendStop;
  Lpi2c_Ip_MasterEndTransfer (baseAddr, master, _10, 0);
  # DEBUG BEGIN_STMT
  master->status = 0;
  # DEBUG BEGIN_STMT
  _11 = master->masterCallback;
  if (_11 != 0B)
    goto <bb 8>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 8> :
  # DEBUG BEGIN_STMT
  _12 = master->masterCallback;
  _13 = master->callbackParam;
  _12 (11, _13);
  goto <bb 11>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  _14 = master->bufferSize;
  _15 = LPI2C_Get_MasterRxFIFOWatermark (baseAddr);
  _16 = (long unsigned int) _15;
  if (_14 <= _16)
    goto <bb 10>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 10> :
  # DEBUG BEGIN_STMT
  _17 = master->bufferSize;
  _18 = (short unsigned int) _17;
  _19 = _18 + 65535;
  LPI2C_Set_MasterRxFIFOWatermark (baseAddr, _19);

  <bb 11> :
  # DEBUG BEGIN_STMT
  return;

}


Lpi2c_Ip_MasterHandleTransmitDataRequest (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = Lpi2c_Ip_MasterCmdQueueEmpty (master);
  _2 = ~_1;
  if (_2 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterSendQueuedCmd (baseAddr, master);
  goto <bb 11>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _3 = master->dataBuffer;
  if (_3 != 0B)
    goto <bb 5>; [INV]
  else
    goto <bb 10>; [INV]

  <bb 5> :
  _4 = master->direction;
  if (_4 == 0)
    goto <bb 6>; [INV]
  else
    goto <bb 10>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  _5 = master->bufferSize;
  if (_5 == 0)
    goto <bb 7>; [INV]
  else
    goto <bb 9>; [INV]

  <bb 7> :
  # DEBUG BEGIN_STMT
  _6 = master->sendStop;
  Lpi2c_Ip_MasterEndTransfer (baseAddr, master, _6, 0);
  # DEBUG BEGIN_STMT
  master->status = 0;
  # DEBUG BEGIN_STMT
  _7 = master->masterCallback;
  if (_7 != 0B)
    goto <bb 8>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 8> :
  # DEBUG BEGIN_STMT
  _8 = master->masterCallback;
  _9 = master->callbackParam;
  _8 (11, _9);
  goto <bb 11>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterQueueData (baseAddr, master);
  goto <bb 11>; [INV]

  <bb 10> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterInt (baseAddr, 1, 0);

  <bb 11> :
  return;

}


Lpi2c_Ip_SlaveSetOperatingMode (uint32 instance, Lpi2c_Ip_ModeType operatingMode)
{
  boolean bHighSpeedMode;
  struct Lpi2c_Ip_SlaveStateType * slave;
  struct LPI2C_Type * baseAddr;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  bHighSpeedMode = 0;
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  slave = g_lpi2cSlaveStatePtr[instance];
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_SlaveConfigureNormalMode (baseAddr);
  # DEBUG BEGIN_STMT
  if (operatingMode == 3)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

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

  <bb 4> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveHighSpeedModeDetect (baseAddr, bHighSpeedMode);
  # DEBUG BEGIN_STMT
  slave->operatingMode = operatingMode;
  return;

}


Lpi2c_Ip_SlaveConfigureNormalMode (struct LPI2C_Type * baseAddr)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveIgnoreNACK (baseAddr, 0);
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveTransmitNACK (baseAddr, 0);
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveACKStall (baseAddr, 0);
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveTXDStall (baseAddr, 1);
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveRXStall (baseAddr, 1);
  # DEBUG BEGIN_STMT
  LPI2C_Set_SlaveAddrStall (baseAddr, 1);
  return;

}


Lpi2c_Ip_MasterSetOperatingMode (uint32 instance, Lpi2c_Ip_ModeType operatingMode)
{
  struct Lpi2c_Ip_MasterStateType * master;
  struct LPI2C_Type * baseAddr;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  baseAddr = g_lpi2cBase[instance];
  # DEBUG BEGIN_STMT
  master = g_lpi2cMasterStatePtr[instance];
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterPinConfig (baseAddr, 0);
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterNACKConfig (baseAddr, 0);
  # DEBUG BEGIN_STMT
  master->operatingMode = operatingMode;
  return;

}


Lpi2c_Ip_MasterEndTransfer (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master, boolean sendStop, boolean resetFIFO)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  LPI2C_Set_MasterInt (baseAddr, 15363, 0);
  # DEBUG BEGIN_STMT
  if (resetFIFO != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  LPI2C_Reset_MasterTxFIFOCmd (baseAddr);
  # DEBUG BEGIN_STMT
  LPI2C_Reset_MasterRxFIFOCmd (baseAddr);

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

  <bb 5> :
  # DEBUG BEGIN_STMT
  LPI2C_Cmd_MasterTransmit (baseAddr, 2, 0);
  # DEBUG BEGIN_STMT
  master->highSpeedInProgress = 0;

  <bb 6> :
  # DEBUG BEGIN_STMT
  master->dataBuffer = 0B;
  # DEBUG BEGIN_STMT
  master->bufferSize = 0;
  # DEBUG BEGIN_STMT
  master->i2cIdle = 1;
  return;

}


Lpi2c_Ip_MasterQueueData (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master)
{
  uint16 txFifoSize;
  uint16 txFIFOCount;

  <bb 2> :
  # DEBUG BEGIN_STMT
  txFIFOCount = LPI2C_Get_MasterTxFIFOCount (baseAddr);
  # DEBUG BEGIN_STMT
  txFifoSize = LPI2C_Get_MasterTxFIFOSize (baseAddr);
  # DEBUG BEGIN_STMT
  _1 = Lpi2c_Ip_MasterCmdQueueEmpty (master);
  if (_1 != 0)
    goto <bb 4>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _2 = master->dataBuffer;
  _3 = *_2;
  LPI2C_Cmd_MasterTransmit (baseAddr, 0, _3);
  # DEBUG BEGIN_STMT
  _4 = master->dataBuffer;
  _5 = _4 + 1;
  master->dataBuffer = _5;
  # DEBUG BEGIN_STMT
  _6 = master->bufferSize;
  _7 = _6 + 4294967295;
  master->bufferSize = _7;
  # DEBUG BEGIN_STMT
  txFIFOCount = LPI2C_Get_MasterTxFIFOCount (baseAddr);

  <bb 4> :
  # DEBUG BEGIN_STMT
  _8 = master->bufferSize;
  if (_8 != 0)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  if (txFIFOCount < txFifoSize)
    goto <bb 3>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 6> :
  return;

}


Lpi2c_Ip_MasterSendAddress (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master, boolean receive)
{
  Lpi2c_Ip_MasterCommandType startCommand;
  uint8 addrByte;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = master->operatingMode;
  if (_1 == 3)
    goto <bb 3>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 3> :
  _2 = master->highSpeedInProgress;
  _3 = ~_2;
  if (_3 != 0)
    goto <bb 4>; [INV]
  else
    goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _4 = master->masterCode;
  Lpi2c_Ip_MasterQueueCmd (baseAddr, master, 5, _4);
  # DEBUG BEGIN_STMT
  master->highSpeedInProgress = 1;

  <bb 5> :
  # DEBUG BEGIN_STMT
  _5 = master->highSpeedInProgress;
  if (_5 != 0)
    goto <bb 6>; [INV]
  else
    goto <bb 7>; [INV]

  <bb 6> :
  # DEBUG BEGIN_STMT
  startCommand = 6;
  goto <bb 8>; [INV]

  <bb 7> :
  # DEBUG BEGIN_STMT
  startCommand = 4;

  <bb 8> :
  # DEBUG BEGIN_STMT
  _6 = master->is10bitAddr;
  if (_6 != 0)
    goto <bb 9>; [INV]
  else
    goto <bb 11>; [INV]

  <bb 9> :
  # DEBUG BEGIN_STMT
  _7 = master->slaveAddress;
  _8 = _7 >> 7;
  _9 = (unsigned char) _8;
  _10 = _9 & 6;
  addrByte = _10 + 240;
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterQueueCmd (baseAddr, master, startCommand, addrByte);
  # DEBUG BEGIN_STMT
  _11 = master->slaveAddress;
  addrByte = (uint8) _11;
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterQueueCmd (baseAddr, master, 0, addrByte);
  # DEBUG BEGIN_STMT
  if (receive != 0)
    goto <bb 10>; [INV]
  else
    goto <bb 12>; [INV]

  <bb 10> :
  # DEBUG BEGIN_STMT
  _12 = master->slaveAddress;
  _13 = _12 >> 7;
  _14 = (unsigned char) _13;
  _15 = _14 & 6;
  addrByte = _15 + 241;
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterQueueCmd (baseAddr, master, startCommand, addrByte);
  goto <bb 12>; [INV]

  <bb 11> :
  # DEBUG BEGIN_STMT
  _16 = master->slaveAddress;
  _17 = (unsigned char) _16;
  _18 = _17 << 1;
  _19 = (unsigned char) receive;
  addrByte = _18 + _19;
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterQueueCmd (baseAddr, master, startCommand, addrByte);

  <bb 12> :
  return;

}


Lpi2c_Ip_MasterSendQueuedCmd (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master)
{
  uint16 txFifoSize;
  uint16 txFIFOCount;

  <bb 2> :
  # DEBUG BEGIN_STMT
  txFIFOCount = LPI2C_Get_MasterTxFIFOCount (baseAddr);
  # DEBUG BEGIN_STMT
  txFifoSize = LPI2C_Get_MasterTxFIFOSize (baseAddr);
  # DEBUG BEGIN_STMT
  goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  _1 = master->cmdQueue.readIdx;
  _2 = (int) _1;
  _3 = master->cmdQueue.cmd[_2];
  _4 = master->cmdQueue.readIdx;
  _5 = (int) _4;
  _6 = master->cmdQueue.data[_5];
  LPI2C_Cmd_MasterTransmit (baseAddr, _3, _6);
  # DEBUG BEGIN_STMT
  _7 = master->cmdQueue.readIdx;
  _8 = _7;
  _9 = _8 + 1;
  master->cmdQueue.readIdx = _9;
  # DEBUG BEGIN_STMT
  txFIFOCount = LPI2C_Get_MasterTxFIFOCount (baseAddr);

  <bb 4> :
  # DEBUG BEGIN_STMT
  _10 = Lpi2c_Ip_MasterCmdQueueEmpty (master);
  _11 = ~_10;
  if (_11 != 0)
    goto <bb 5>; [INV]
  else
    goto <bb 6>; [INV]

  <bb 5> :
  if (txFIFOCount < txFifoSize)
    goto <bb 3>; [INV]
  else
    goto <bb 6>; [INV]

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

  <bb 7> :
  # DEBUG BEGIN_STMT
  Lpi2c_Ip_MasterResetQueue (master);

  <bb 8> :
  return;

}


Lpi2c_Ip_MasterQueueCmd (struct LPI2C_Type * baseAddr, struct Lpi2c_Ip_MasterStateType * master, Lpi2c_Ip_MasterCommandType cmd, uint8 data)
{
  uint16 txFIFOSize;
  uint16 txFIFOCount;

  <bb 2> :
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  txFIFOCount = LPI2C_Get_MasterTxFIFOCount (baseAddr);
  # DEBUG BEGIN_STMT
  txFIFOSize = LPI2C_Get_MasterTxFIFOSize (baseAddr);
  # DEBUG BEGIN_STMT
  if (txFIFOCount < txFIFOSize)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  LPI2C_Cmd_MasterTransmit (baseAddr, cmd, data);
  goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _1 = master->cmdQueue.writeIdx;
  _2 = (int) _1;
  master->cmdQueue.cmd[_2] = cmd;
  # DEBUG BEGIN_STMT
  _3 = master->cmdQueue.writeIdx;
  _4 = (int) _3;
  master->cmdQueue.data[_4] = data;
  # DEBUG BEGIN_STMT
  _5 = master->cmdQueue.writeIdx;
  _6 = _5;
  _7 = _6 + 1;
  master->cmdQueue.writeIdx = _7;

  <bb 5> :
  return;

}


Lpi2c_Ip_MasterResetQueue (struct Lpi2c_Ip_MasterStateType * master)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  master->cmdQueue.readIdx = 0;
  # DEBUG BEGIN_STMT
  master->cmdQueue.writeIdx = 0;
  return;

}


Lpi2c_Ip_MasterCmdQueueEmpty (const struct Lpi2c_Ip_MasterStateType * master)
{
  boolean D.5329;

  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = master->cmdQueue.writeIdx;
  _2 = master->cmdQueue.readIdx;
  D.5329 = _1 == _2;
  return D.5329;

}


LPI2C_Get_SlaveData (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  uint8 D.5581;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->SRDR;
  # DEBUG BEGIN_STMT
  tmp = tmp & 255;
  # DEBUG BEGIN_STMT
  D.5581 = (uint8) tmp;
  return D.5581;

}


LPI2C_Transmit_SlaveData (struct LPI2C_Type * baseAddr, uint8 data)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) data;
  baseAddr->STDR = _1;
  return;

}


LPI2C_Set_SlaveTransmitNACK (struct LPI2C_Type * baseAddr, Lpi2c_Ip_SlaveNackTransmitType nack)
{
  uint32 regValue;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->STAR;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294967294;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) nack;
  _2 = _1 & 1;
  regValue = regValue | _2;
  # DEBUG BEGIN_STMT
  baseAddr->STAR = regValue;
  return;

}


LPI2C_Get_SlaveReceivedAddr (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  uint16 D.5554;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->SASR;
  # DEBUG BEGIN_STMT
  tmp = tmp & 2047;
  # DEBUG BEGIN_STMT
  D.5554 = (uint16) tmp;
  return D.5554;

}


LPI2C_Set_SlaveAddr0 (struct LPI2C_Type * baseAddr, uint16 addr)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->SAMR;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4294965249;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) addr;
  _2 = _1 << 1;
  _3 = _2 & 2046;
  tmp = tmp | _3;
  # DEBUG BEGIN_STMT
  baseAddr->SAMR = tmp;
  return;

}


LPI2C_Set_SlaveAddrStall (struct LPI2C_Type * baseAddr, boolean enable)
{
  uint32 regValue;
  long unsigned int iftmp.5;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SCFGR1;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294967294;
  # DEBUG BEGIN_STMT
  if (enable != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  iftmp.5 = 1;
  goto <bb 5>; [INV]

  <bb 4> :
  iftmp.5 = 0;

  <bb 5> :
  regValue = iftmp.5 | regValue;
  # DEBUG BEGIN_STMT
  baseAddr->SCFGR1 = regValue;
  return;

}


LPI2C_Set_SlaveRXStall (struct LPI2C_Type * baseAddr, boolean enable)
{
  uint32 regValue;
  long unsigned int iftmp.4;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SCFGR1;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294967293;
  # DEBUG BEGIN_STMT
  if (enable != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  iftmp.4 = 2;
  goto <bb 5>; [INV]

  <bb 4> :
  iftmp.4 = 0;

  <bb 5> :
  regValue = iftmp.4 | regValue;
  # DEBUG BEGIN_STMT
  baseAddr->SCFGR1 = regValue;
  return;

}


LPI2C_Set_SlaveTXDStall (struct LPI2C_Type * baseAddr, boolean enable)
{
  uint32 regValue;
  long unsigned int iftmp.3;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SCFGR1;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294967291;
  # DEBUG BEGIN_STMT
  if (enable != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  iftmp.3 = 4;
  goto <bb 5>; [INV]

  <bb 4> :
  iftmp.3 = 0;

  <bb 5> :
  regValue = iftmp.3 | regValue;
  # DEBUG BEGIN_STMT
  baseAddr->SCFGR1 = regValue;
  return;

}


LPI2C_Set_SlaveACKStall (struct LPI2C_Type * baseAddr, boolean enable)
{
  uint32 regValue;
  long unsigned int iftmp.2;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SCFGR1;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294967287;
  # DEBUG BEGIN_STMT
  if (enable != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  iftmp.2 = 8;
  goto <bb 5>; [INV]

  <bb 4> :
  iftmp.2 = 0;

  <bb 5> :
  regValue = iftmp.2 | regValue;
  # DEBUG BEGIN_STMT
  baseAddr->SCFGR1 = regValue;
  return;

}


LPI2C_Set_SlaveIgnoreNACK (struct LPI2C_Type * baseAddr, Lpi2c_Ip_SlaveNackConfigType nack_config)
{
  uint32 regValue;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SCFGR1;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294963199;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) nack_config;
  _2 = _1 << 12;
  _3 = _2 & 4096;
  regValue = regValue | _3;
  # DEBUG BEGIN_STMT
  baseAddr->SCFGR1 = regValue;
  return;

}


LPI2C_Set_SlaveHighSpeedModeDetect (struct LPI2C_Type * baseAddr, boolean enable)
{
  uint32 regValue;
  long unsigned int iftmp.6;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SCFGR1;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294959103;
  # DEBUG BEGIN_STMT
  if (enable != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  iftmp.6 = 8192;
  goto <bb 5>; [INV]

  <bb 4> :
  iftmp.6 = 0;

  <bb 5> :
  regValue = iftmp.6 | regValue;
  # DEBUG BEGIN_STMT
  baseAddr->SCFGR1 = regValue;
  return;

}


LPI2C_Set_SlaveAddrConfig (struct LPI2C_Type * baseAddr, Lpi2c_Ip_SlaveAddressConfigType configuration)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->SCFGR1;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4294508543;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) configuration;
  _2 = _1 << 16;
  _3 = _2 & 458752;
  tmp = tmp | _3;
  # DEBUG BEGIN_STMT
  baseAddr->SCFGR1 = tmp;
  return;

}


LPI2C_Set_SlaveTxDMA (struct LPI2C_Type * baseAddr, boolean enable)
{
  uint32 regValue;
  long unsigned int iftmp.8;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SDER;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294967294;
  # DEBUG BEGIN_STMT
  if (enable != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  iftmp.8 = 1;
  goto <bb 5>; [INV]

  <bb 4> :
  iftmp.8 = 0;

  <bb 5> :
  regValue = iftmp.8 | regValue;
  # DEBUG BEGIN_STMT
  baseAddr->SDER = regValue;
  return;

}


LPI2C_Set_SlaveRxDMA (struct LPI2C_Type * baseAddr, boolean enable)
{
  uint32 regValue;
  long unsigned int iftmp.7;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SDER;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294967293;
  # DEBUG BEGIN_STMT
  if (enable != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  iftmp.7 = 2;
  goto <bb 5>; [INV]

  <bb 4> :
  iftmp.7 = 0;

  <bb 5> :
  regValue = iftmp.7 | regValue;
  # DEBUG BEGIN_STMT
  baseAddr->SDER = regValue;
  return;

}


LPI2C_Get_SlaveInt (const struct LPI2C_Type * baseAddr, uint32 interrupts)
{
  boolean hasInterrupts;
  uint32 tmp;
  boolean D.5572;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->SIER;
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = tmp & interrupts;
  if (_1 != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  hasInterrupts = 1;
  goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  hasInterrupts = 0;

  <bb 5> :
  # DEBUG BEGIN_STMT
  D.5572 = hasInterrupts;
  return D.5572;

}


LPI2C_Set_SlaveInt (struct LPI2C_Type * baseAddr, uint32 interrupts, boolean enable)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->SIER;
  # DEBUG BEGIN_STMT
  if (enable != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  tmp = tmp | interrupts;
  goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _1 = ~interrupts;
  tmp = tmp & _1;

  <bb 5> :
  # DEBUG BEGIN_STMT
  baseAddr->SIER = tmp;
  return;

}


LPI2C_Clear_SlaveRepeatedStartEvent (struct LPI2C_Type * baseAddr)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  baseAddr->SSR = 256;
  return;

}


LPI2C_Clear_SlaveSTOPDetectEvent (struct LPI2C_Type * baseAddr)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  baseAddr->SSR = 512;
  return;

}


LPI2C_Clear_SlaveBitErrorEvent (struct LPI2C_Type * baseAddr)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  baseAddr->SSR = 1024;
  return;

}


LPI2C_Get_SlaveTransmitDataEvent (const struct LPI2C_Type * baseAddr)
{
  uint32 regValue;
  boolean D.5556;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SSR;
  # DEBUG BEGIN_STMT
  regValue = regValue & 1;
  # DEBUG BEGIN_STMT
  D.5556 = regValue != 0;
  return D.5556;

}


LPI2C_Get_SlaveReceiveDataEvent (const struct LPI2C_Type * baseAddr)
{
  uint32 regValue;
  boolean D.5567;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SSR;
  # DEBUG BEGIN_STMT
  _1 = regValue >> 1;
  regValue = _1 & 1;
  # DEBUG BEGIN_STMT
  D.5567 = regValue != 0;
  return D.5567;

}


LPI2C_Get_SlaveAddressValidEvent (const struct LPI2C_Type * baseAddr)
{
  uint32 regValue;
  boolean D.5543;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SSR;
  # DEBUG BEGIN_STMT
  _1 = regValue >> 2;
  regValue = _1 & 1;
  # DEBUG BEGIN_STMT
  D.5543 = regValue != 0;
  return D.5543;

}


LPI2C_Get_SlaveRepeatedStartEvent (const struct LPI2C_Type * baseAddr)
{
  uint32 regValue;
  boolean D.5585;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SSR;
  # DEBUG BEGIN_STMT
  _1 = regValue >> 8;
  regValue = _1 & 1;
  # DEBUG BEGIN_STMT
  D.5585 = regValue != 0;
  return D.5585;

}


LPI2C_Get_SlaveSTOPDetectEvent (const struct LPI2C_Type * baseAddr)
{
  uint32 regValue;
  boolean D.5583;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SSR;
  # DEBUG BEGIN_STMT
  _1 = regValue >> 9;
  regValue = _1 & 1;
  # DEBUG BEGIN_STMT
  D.5583 = regValue != 0;
  return D.5583;

}


LPI2C_Get_SlaveBitErrorEvent (const struct LPI2C_Type * baseAddr)
{
  uint32 regValue;
  boolean D.5595;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SSR;
  # DEBUG BEGIN_STMT
  _1 = regValue >> 10;
  regValue = _1 & 1;
  # DEBUG BEGIN_STMT
  D.5595 = regValue != 0;
  return D.5595;

}


LPI2C_Set_SlaveEnable (struct LPI2C_Type * baseAddr, boolean enable)
{
  uint32 regValue;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->SCR;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294967294;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) enable;
  regValue = regValue | _1;
  # DEBUG BEGIN_STMT
  baseAddr->SCR = regValue;
  return;

}


LPI2C_Get_MasterRxData (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  uint8 D.5421;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MRDR;
  # DEBUG BEGIN_STMT
  tmp = tmp & 255;
  # DEBUG BEGIN_STMT
  D.5421 = (uint8) tmp;
  return D.5421;

}


LPI2C_Cmd_MasterTransmit (struct LPI2C_Type * baseAddr, Lpi2c_Ip_MasterCommandType cmd, uint8 data)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) cmd;
  _2 = _1 << 8;
  _3 = (long unsigned int) data;
  _4 = _2 + _3;
  baseAddr->MTDR = _4;
  return;

}


LPI2C_Get_MasterTxFIFOCount (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  uint16 D.5322;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MFSR;
  # DEBUG BEGIN_STMT
  tmp = tmp & 7;
  # DEBUG BEGIN_STMT
  D.5322 = (uint16) tmp;
  return D.5322;

}


LPI2C_Get_MasterRxFIFOCount (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  uint16 D.5423;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MFSR;
  # DEBUG BEGIN_STMT
  _1 = tmp >> 16;
  tmp = _1 & 7;
  # DEBUG BEGIN_STMT
  D.5423 = (uint16) tmp;
  return D.5423;

}


LPI2C_Set_MasterTxFIFOWatermark (struct LPI2C_Type * baseAddr, uint16 value)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MFCR;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4294967292;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) value;
  _2 = _1 & 3;
  tmp = tmp | _2;
  # DEBUG BEGIN_STMT
  baseAddr->MFCR = tmp;
  return;

}


LPI2C_Get_MasterRxFIFOWatermark (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  uint16 D.5425;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MFCR;
  # DEBUG BEGIN_STMT
  _1 = tmp >> 16;
  tmp = _1 & 3;
  # DEBUG BEGIN_STMT
  D.5425 = (uint16) tmp;
  return D.5425;

}


LPI2C_Set_MasterRxFIFOWatermark (struct LPI2C_Type * baseAddr, uint16 value)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MFCR;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4294770687;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) value;
  _2 = _1 << 16;
  _3 = _2 & 196608;
  tmp = tmp | _3;
  # DEBUG BEGIN_STMT
  baseAddr->MFCR = tmp;
  return;

}


LPI2C_Get_MasterClockLowPeriodHS (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  uint8 D.5301;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCCR1;
  # DEBUG BEGIN_STMT
  tmp = tmp & 63;
  # DEBUG BEGIN_STMT
  D.5301 = (uint8) tmp;
  return D.5301;

}


LPI2C_Set_MasterClockLowPeriodHS (struct LPI2C_Type * baseAddr, uint8 value)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCCR1;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4294967232;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) value;
  _2 = _1 & 63;
  tmp = tmp | _2;
  # DEBUG BEGIN_STMT
  baseAddr->MCCR1 = tmp;
  return;

}


LPI2C_Get_MasterClockHighPeriodHS (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  uint8 D.5299;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCCR1;
  # DEBUG BEGIN_STMT
  _1 = tmp >> 8;
  tmp = _1 & 63;
  # DEBUG BEGIN_STMT
  D.5299 = (uint8) tmp;
  return D.5299;

}


LPI2C_Set_MasterClockHighPeriodHS (struct LPI2C_Type * baseAddr, uint8 value)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCCR1;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4294951167;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) value;
  _2 = _1 << 8;
  _3 = _2 & 16128;
  tmp = tmp | _3;
  # DEBUG BEGIN_STMT
  baseAddr->MCCR1 = tmp;
  return;

}


LPI2C_Set_MasterSetupHoldDelayHS (struct LPI2C_Type * baseAddr, uint8 value)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCCR1;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4290838527;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) value;
  _2 = _1 << 16;
  _3 = _2 & 4128768;
  tmp = tmp | _3;
  # DEBUG BEGIN_STMT
  baseAddr->MCCR1 = tmp;
  return;

}


LPI2C_Set_MasterDataValidDelayHS (struct LPI2C_Type * baseAddr, uint8 value)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCCR1;
  # DEBUG BEGIN_STMT
  tmp = tmp & 3238002687;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) value;
  _2 = _1 << 24;
  _3 = _2 & 1056964608;
  tmp = tmp | _3;
  # DEBUG BEGIN_STMT
  baseAddr->MCCR1 = tmp;
  return;

}


LPI2C_Get_MasterClockLowPeriod (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  uint8 D.5297;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCCR0;
  # DEBUG BEGIN_STMT
  tmp = tmp & 63;
  # DEBUG BEGIN_STMT
  D.5297 = (uint8) tmp;
  return D.5297;

}


LPI2C_Set_MasterClockLowPeriod (struct LPI2C_Type * baseAddr, uint8 value)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCCR0;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4294967232;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) value;
  _2 = _1 & 63;
  tmp = tmp | _2;
  # DEBUG BEGIN_STMT
  baseAddr->MCCR0 = tmp;
  return;

}


LPI2C_Set_MasterSetupHoldDelay (struct LPI2C_Type * baseAddr, uint8 value)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCCR0;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4290838527;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) value;
  _2 = _1 << 16;
  _3 = _2 & 4128768;
  tmp = tmp | _3;
  # DEBUG BEGIN_STMT
  baseAddr->MCCR0 = tmp;
  return;

}


LPI2C_Set_MasterDataValidDelay (struct LPI2C_Type * baseAddr, uint8 value)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCCR0;
  # DEBUG BEGIN_STMT
  tmp = tmp & 3238002687;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) value;
  _2 = _1 << 24;
  _3 = _2 & 1056964608;
  tmp = tmp | _3;
  # DEBUG BEGIN_STMT
  baseAddr->MCCR0 = tmp;
  return;

}


LPI2C_Set_MasterClockHighPeriod (struct LPI2C_Type * baseAddr, uint8 value)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCCR0;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4294951167;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) value;
  _2 = _1 << 8;
  _3 = _2 & 16128;
  tmp = tmp | _3;
  # DEBUG BEGIN_STMT
  baseAddr->MCCR0 = tmp;
  return;

}


LPI2C_Get_MasterClockHighPeriod (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  uint8 D.5295;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCCR0;
  # DEBUG BEGIN_STMT
  _1 = tmp >> 8;
  tmp = _1 & 63;
  # DEBUG BEGIN_STMT
  D.5295 = (uint8) tmp;
  return D.5295;

}


LPI2C_Get_MasterPrescaler (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  Lpi2c_Ip_MasterPrescalerType D.5293;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCFGR1;
  # DEBUG BEGIN_STMT
  tmp = tmp & 7;
  # DEBUG BEGIN_STMT
  D.5293 = (Lpi2c_Ip_MasterPrescalerType) tmp;
  return D.5293;

}


LPI2C_Set_MasterPrescaler (struct LPI2C_Type * baseAddr, Lpi2c_Ip_MasterPrescalerType prescaler)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCFGR1;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4294967288;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) prescaler;
  _2 = _1 & 7;
  tmp = tmp | _2;
  # DEBUG BEGIN_STMT
  baseAddr->MCFGR1 = tmp;
  return;

}


LPI2C_Set_MasterNACKConfig (struct LPI2C_Type * baseAddr, Lpi2c_Ip_NackConfigType configuration)
{
  uint32 regValue;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->MCFGR1;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294966783;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) configuration;
  _2 = _1 << 9;
  _3 = _2 & 512;
  regValue = regValue | _3;
  # DEBUG BEGIN_STMT
  baseAddr->MCFGR1 = regValue;
  return;

}


LPI2C_Set_MasterBusIdleTimeout (struct LPI2C_Type * baseAddr, uint32 u32Timeout)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCFGR2;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4294963200;
  # DEBUG BEGIN_STMT
  _1 = u32Timeout & 4095;
  tmp = tmp | _1;
  # DEBUG BEGIN_STMT
  baseAddr->MCFGR2 = tmp;
  return;

}


LPI2C_Set_MasterPinLowTimeoutConfiguration (struct LPI2C_Type * baseAddr, boolean configuration)
{
  uint32 tmp;
  long unsigned int iftmp.1;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCFGR1;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4294966271;
  # DEBUG BEGIN_STMT
  if (configuration != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  iftmp.1 = 1024;
  goto <bb 5>; [INV]

  <bb 4> :
  iftmp.1 = 0;

  <bb 5> :
  tmp = iftmp.1 | tmp;
  # DEBUG BEGIN_STMT
  baseAddr->MCFGR1 = tmp;
  return;

}


LPI2C_Set_MasterPinLowTimeout (struct LPI2C_Type * baseAddr, uint32 u32Timeout)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCFGR3;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4293918975;
  # DEBUG BEGIN_STMT
  _1 = u32Timeout << 8;
  _2 = _1 & 1048320;
  tmp = tmp | _2;
  # DEBUG BEGIN_STMT
  baseAddr->MCFGR3 = tmp;
  return;

}


LPI2C_Set_SlaveGlitchFilterSCL (struct LPI2C_Type * baseAddr, uint32 cycles)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->SCFGR2;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4293984255;
  # DEBUG BEGIN_STMT
  _1 = cycles << 16;
  _2 = _1 & 983040;
  tmp = tmp | _2;
  # DEBUG BEGIN_STMT
  baseAddr->SCFGR2 = tmp;
  return;

}


LPI2C_Set_SlaveGlitchFilterSDA (struct LPI2C_Type * baseAddr, uint32 cycles)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->SCFGR2;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4043309055;
  # DEBUG BEGIN_STMT
  _1 = cycles << 24;
  _2 = _1 & 251658240;
  tmp = tmp | _2;
  # DEBUG BEGIN_STMT
  baseAddr->SCFGR2 = tmp;
  return;

}


LPI2C_Set_MasterGlitchFilterSCL (struct LPI2C_Type * baseAddr, uint32 cycles)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCFGR2;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4293984255;
  # DEBUG BEGIN_STMT
  _1 = cycles << 16;
  _2 = _1 & 983040;
  tmp = tmp | _2;
  # DEBUG BEGIN_STMT
  baseAddr->MCFGR2 = tmp;
  return;

}


LPI2C_Set_MasterGlitchFilterSDA (struct LPI2C_Type * baseAddr, uint32 cycles)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCFGR2;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4043309055;
  # DEBUG BEGIN_STMT
  _1 = cycles << 24;
  _2 = _1 & 251658240;
  tmp = tmp | _2;
  # DEBUG BEGIN_STMT
  baseAddr->MCFGR2 = tmp;
  return;

}


LPI2C_Set_MasterPinConfig (struct LPI2C_Type * baseAddr, Lpi2c_Ip_PinConfigType configuration)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MCFGR1;
  # DEBUG BEGIN_STMT
  tmp = tmp & 4177526783;
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) configuration;
  _2 = _1 << 24;
  _3 = _2 & 117440512;
  tmp = tmp | _3;
  # DEBUG BEGIN_STMT
  baseAddr->MCFGR1 = tmp;
  return;

}


LPI2C_Set_MasterInt (struct LPI2C_Type * baseAddr, uint32 interrupts, boolean enable)
{
  uint32 tmp;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->MIER;
  # DEBUG BEGIN_STMT
  if (enable != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  # DEBUG BEGIN_STMT
  tmp = tmp | interrupts;
  goto <bb 5>; [INV]

  <bb 4> :
  # DEBUG BEGIN_STMT
  _1 = ~interrupts;
  tmp = tmp & _1;

  <bb 5> :
  # DEBUG BEGIN_STMT
  baseAddr->MIER = tmp;
  return;

}


LPI2C_Clear_MasterPinLowTimeoutEvent (struct LPI2C_Type * baseAddr)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  baseAddr->MSR = 8192;
  return;

}


LPI2C_Clear_MasterNACKDetectEvent (struct LPI2C_Type * baseAddr)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  baseAddr->MSR = 1024;
  return;

}


LPI2C_Clear_MasterArbitrationLostEvent (struct LPI2C_Type * baseAddr)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  baseAddr->MSR = 2048;
  return;

}


LPI2C_Clear_MasterFIFOErrorEvent (struct LPI2C_Type * baseAddr)
{
  <bb 2> :
  # DEBUG BEGIN_STMT
  baseAddr->MSR = 4096;
  return;

}


LPI2C_Get_MasterPinLowTimeoutEvent (const struct LPI2C_Type * baseAddr)
{
  uint32 regValue;
  boolean D.5462;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->MSR;
  # DEBUG BEGIN_STMT
  _1 = regValue >> 13;
  regValue = _1 & 1;
  # DEBUG BEGIN_STMT
  D.5462 = regValue != 0;
  return D.5462;

}


LPI2C_Get_MasterNACKDetectEvent (const struct LPI2C_Type * baseAddr)
{
  uint32 regValue;
  boolean D.5383;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->MSR;
  # DEBUG BEGIN_STMT
  _1 = regValue >> 10;
  regValue = _1 & 1;
  # DEBUG BEGIN_STMT
  D.5383 = regValue != 0;
  return D.5383;

}


LPI2C_Get_MasterArbitrationLostEvent (const struct LPI2C_Type * baseAddr)
{
  uint32 regValue;
  boolean D.5379;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->MSR;
  # DEBUG BEGIN_STMT
  _1 = regValue >> 11;
  regValue = _1 & 1;
  # DEBUG BEGIN_STMT
  D.5379 = regValue != 0;
  return D.5379;

}


LPI2C_Get_MasterFIFOErrorEvent (const struct LPI2C_Type * baseAddr)
{
  uint32 regValue;
  boolean D.5373;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->MSR;
  # DEBUG BEGIN_STMT
  _1 = regValue >> 12;
  regValue = _1 & 1;
  # DEBUG BEGIN_STMT
  D.5373 = regValue != 0;
  return D.5373;

}


LPI2C_Get_MasterTransmitDataRequestEvent (const struct LPI2C_Type * baseAddr)
{
  uint32 regValue;
  boolean D.5358;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->MSR;
  # DEBUG BEGIN_STMT
  regValue = regValue & 1;
  # DEBUG BEGIN_STMT
  D.5358 = regValue != 0;
  return D.5358;

}


LPI2C_Get_MasterReceiveDataReadyEvent (const struct LPI2C_Type * baseAddr)
{
  uint32 regValue;
  boolean D.5418;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->MSR;
  # DEBUG BEGIN_STMT
  _1 = regValue >> 1;
  regValue = _1 & 1;
  # DEBUG BEGIN_STMT
  D.5418 = regValue != 0;
  return D.5418;

}


LPI2C_Set_MasterEnable (struct LPI2C_Type * baseAddr, boolean enable)
{
  uint32 regValue;
  long unsigned int iftmp.0;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->MCR;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294967294;
  # DEBUG BEGIN_STMT
  if (enable != 0)
    goto <bb 3>; [INV]
  else
    goto <bb 4>; [INV]

  <bb 3> :
  iftmp.0 = 1;
  goto <bb 5>; [INV]

  <bb 4> :
  iftmp.0 = 0;

  <bb 5> :
  regValue = iftmp.0 | regValue;
  # DEBUG BEGIN_STMT
  baseAddr->MCR = regValue;
  return;

}


LPI2C_Reset_MasterTxFIFOCmd (struct LPI2C_Type * baseAddr)
{
  uint32 regValue;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->MCR;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294967039;
  # DEBUG BEGIN_STMT
  regValue = regValue | 256;
  # DEBUG BEGIN_STMT
  baseAddr->MCR = regValue;
  return;

}


LPI2C_Reset_MasterRxFIFOCmd (struct LPI2C_Type * baseAddr)
{
  uint32 regValue;

  <bb 2> :
  # DEBUG BEGIN_STMT
  regValue = baseAddr->MCR;
  # DEBUG BEGIN_STMT
  regValue = regValue & 4294966783;
  # DEBUG BEGIN_STMT
  regValue = regValue | 512;
  # DEBUG BEGIN_STMT
  baseAddr->MCR = regValue;
  return;

}


LPI2C_Get_MasterTxFIFOSize (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  uint16 D.5324;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->PARAM;
  # DEBUG BEGIN_STMT
  tmp = tmp & 15;
  # DEBUG BEGIN_STMT
  tmp = 1 << tmp;
  # DEBUG BEGIN_STMT
  D.5324 = (uint16) tmp;
  return D.5324;

}


LPI2C_Get_MasterRxFIFOSize (const struct LPI2C_Type * baseAddr)
{
  uint32 tmp;
  uint16 D.5397;

  <bb 2> :
  # DEBUG BEGIN_STMT
  tmp = baseAddr->PARAM;
  # DEBUG BEGIN_STMT
  _1 = tmp >> 8;
  tmp = _1 & 15;
  # DEBUG BEGIN_STMT
  tmp = 1 << tmp;
  # DEBUG BEGIN_STMT
  D.5397 = (uint16) tmp;
  return D.5397;

}