
Analyzing function: FlexCAN_ComputePayloadSize.part.0/112
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 6 2 3 4 5
;; 6 succs { 2 }
;; 2 succs { 3 4 }
;; 3 succs { 5 }
;; 4 succs { 5 }
;; 5 succs { 1 }

Analyzing function body size: FlexCAN_ComputePayloadSize.part.0

IPA function summary for FlexCAN_ComputePayloadSize.part.0/112 inlinable
  global time:     5.500000
  self size:       7
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:1.000000, time:0.500000
    size:3.000000, time:2.000000,  executed if:(not inlined)
    size:3.000000, time:3.000000,  nonconst if:(op0 changed)
  array index:(op0 changed)
  calls:


Analyzing function: FlexCAN_SetPNIdFilter1.isra.0/110
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 10 2 3 4 5 6 7 8 9
;; 10 succs { 2 }
;; 2 succs { 4 3 }
;; 3 succs { 4 }
;; 4 succs { 6 5 }
;; 5 succs { 6 }
;; 6 succs { 7 8 }
;; 7 succs { 9 }
;; 8 succs { 9 }
;; 9 succs { 1 }

Analyzing function body size: FlexCAN_SetPNIdFilter1.isra.0

IPA function summary for FlexCAN_SetPNIdFilter1.isra.0/110 inlinable
  global time:     15.500000
  self size:       19
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.500000, time:0.500000
    size:3.500000, time:2.500000,  executed if:(not inlined)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op0[ref offset: 22624] changed) && (not inlined)
    size:1.500000, time:1.500000,  nonconst if:(op0[ref offset: 22624] changed)
    size:4.000000, time:4.000000,  nonconst if:(op1 changed)
    size:1.000000, time:1.000000,  nonconst if:(op1 changed || op0[ref offset: 22624] changed)
    size:2.000000, time:2.000000,  nonconst if:(op2 changed)
    size:1.000000, time:1.000000,  nonconst if:(op1 changed || op0[ref offset: 22624] changed || op2 changed)
    size:3.000000, time:1.500000,  nonconst if:(op3 changed)
    size:2.000000, time:1.000000,  nonconst if:(op1 changed || op3 changed || op0[ref offset: 22624] changed || op2 changed)
  calls:


Analyzing function: FlexCAN_ConfigPN/86
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6 7 8 9 10 11
;; 2 succs { 4 3 }
;; 3 succs { 4 5 }
;; 4 succs { 6 }
;; 5 succs { 6 }
;; 6 succs { 8 7 }
;; 7 succs { 8 11 }
;; 8 succs { 10 9 }
;; 9 succs { 10 11 }
;; 10 succs { 11 }
;; 11 succs { 1 }

Analyzing function body size: FlexCAN_ConfigPN

IPA function summary for FlexCAN_ConfigPN/86 inlinable
  global time:     79.820494
  self size:       58
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:21.500000, time:16.111747
    size:9.500000, time:7.152576,  executed if:(not inlined)
  calls:
    FlexCAN_SetPNPayloadLowFilter2/45 function not considered for inlining
      loop depth: 0 freq:0.26 size: 3 time: 12
    FlexCAN_SetPNPayloadHighFilter2/44 function not considered for inlining
      loop depth: 0 freq:0.26 size: 3 time: 12
    FlexCAN_SetPNPayloadLowFilter1/43 function not considered for inlining
      loop depth: 0 freq:0.47 size: 3 time: 12
    FlexCAN_SetPNPayloadHighFilter1/42 function not considered for inlining
      loop depth: 0 freq:0.47 size: 3 time: 12
    FlexCAN_SetPNDlcFilter/41 function not considered for inlining
      loop depth: 0 freq:0.47 size: 4 time: 13
    FlexCAN_SetPNIdFilter2/40 function not considered for inlining
      loop depth: 0 freq:0.56 size: 3 time: 12
    FlexCAN_SetPNIdFilter1.isra.0/110 function not considered for inlining
      loop depth: 0 freq:1.00 size: 5 time: 14callee size: 9 stack: 0
    FlexCAN_SetPNFilteringSelection/36 function not considered for inlining
      loop depth: 0 freq:1.00 size: 3 time: 12


Analyzing function: FlexCAN_ConfigCtrlOptions/85
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
;; 2 succs { 3 4 }
;; 3 succs { 5 }
;; 4 succs { 5 }
;; 5 succs { 6 7 }
;; 6 succs { 8 }
;; 7 succs { 8 }
;; 8 succs { 9 10 }
;; 9 succs { 11 }
;; 10 succs { 11 }
;; 11 succs { 12 14 }
;; 12 succs { 13 14 }
;; 13 succs { 15 }
;; 14 succs { 15 }
;; 15 succs { 16 17 }
;; 16 succs { 18 }
;; 17 succs { 18 }
;; 18 succs { 19 20 }
;; 19 succs { 21 }
;; 20 succs { 21 }
;; 21 succs { 22 23 }
;; 22 succs { 24 }
;; 23 succs { 24 }
;; 24 succs { 1 }

Analyzing function body size: FlexCAN_ConfigCtrlOptions

IPA function summary for FlexCAN_ConfigCtrlOptions/85 inlinable
  global time:     49.250000
  self size:       77
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:34.500000, time:17.000000
    size:16.500000, time:8.750000,  executed if:(not inlined)
    size:21.000000, time:21.000000,  nonconst if:(op1 changed)
    size:1.000000, time:0.500000,  executed if:(not inlined),  nonconst if:(op0[ref offset: 416] changed) && (not inlined)
    size:4.000000, time:2.000000,  nonconst if:(op0[ref offset: 416] changed)
  calls:


Analyzing function: FlexCAN_IsMbOutOfRange/84
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6
;; 2 succs { 6 3 }
;; 3 succs { 4 6 }
;; 4 succs { 5 6 }
;; 5 succs { 6 }
;; 6 succs { 1 }

Analyzing function body size: FlexCAN_IsMbOutOfRange

IPA function summary for FlexCAN_IsMbOutOfRange/84 inlinable
  global time:     7.250000
  self size:       16
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.000000, time:0.000000
    size:3.000000, time:2.000000,  executed if:(not inlined)
    size:2.000000, time:2.000000,  nonconst if:(op3 changed || op1 changed)
    size:2.000000, time:1.000000,  nonconst if:(op2 changed)
    size:0.500000, time:0.125000,  executed if:(op2 != 0) && (not inlined),  nonconst if:(op0[ref offset: 416] changed) && (op2 != 0) && (not inlined)
    size:6.500000, time:1.625000,  executed if:(op2 != 0),  nonconst if:(op0[ref offset: 416] changed) && (op2 != 0)
    size:2.000000, time:0.500000,  executed if:(op2 != 0),  nonconst if:(op1 changed || op0[ref offset: 416] changed) && (op2 != 0)
  calls:


Analyzing function: FlexCAN_ReadRxFifo/83
;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6 7 8
;;
;; Loop 1
;;  header 7, latch 6
;;  depth 1, outer 0
;;  nodes: 7 6
;; 2 succs { 3 4 }
;; 3 succs { 5 }
;; 4 succs { 5 }
;; 5 succs { 7 }
;; 6 succs { 7 }
;; 7 succs { 6 8 }
;; 8 succs { 1 }

Analyzing function body size: FlexCAN_ReadRxFifo

IPA function summary for FlexCAN_ReadRxFifo/83 inlinable
  global time:     187.227274
  self size:       45
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:34.000000, time:168.727274
    size:6.000000, time:4.500000,  executed if:(not inlined)
    size:1.000000, time:1.000000,  nonconst if:(op0 changed)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op0[ref offset: 608] changed) && (not inlined)
    size:0.500000, time:0.500000,  nonconst if:(op0[ref offset: 608] changed)
  calls:
    FlexCAN_ComputePayloadSize/57 function not considered for inlining
      loop depth: 0 freq:1.00 size: 3 time: 12


Analyzing function: FlexCAN_SetRxFifoFilter/82
;; 4 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
;;
;; Loop 3
;;  header 10, latch 9
;;  depth 1, outer 0
;;  nodes: 10 9 7 8 6 4 5
;;
;; Loop 2
;;  header 23, latch 22
;;  depth 1, outer 0
;;  nodes: 23 22 20 21 19 17 18 16 14 15 12 13
;;
;; Loop 1
;;  header 38, latch 37
;;  depth 1, outer 0
;;  nodes: 38 37 35 36 34 32 33 31 29 30 28 26 27 25
;; 2 succs { 40 3 11 24 39 }
;; 3 succs { 10 }
;; 4 succs { 5 6 }
;; 5 succs { 6 }
;; 6 succs { 7 8 }
;; 7 succs { 9 }
;; 8 succs { 9 }
;; 9 succs { 10 }
;; 10 succs { 4 40 }
;; 11 succs { 23 }
;; 12 succs { 13 14 }
;; 13 succs { 14 }
;; 14 succs { 15 16 }
;; 15 succs { 16 }
;; 16 succs { 17 18 }
;; 17 succs { 19 }
;; 18 succs { 19 }
;; 19 succs { 20 21 }
;; 20 succs { 22 }
;; 21 succs { 22 }
;; 22 succs { 23 }
;; 23 succs { 12 40 }
;; 24 succs { 38 }
;; 25 succs { 26 27 }
;; 26 succs { 28 }
;; 27 succs { 28 }
;; 28 succs { 29 30 }
;; 29 succs { 31 }
;; 30 succs { 31 }
;; 31 succs { 32 33 }
;; 32 succs { 34 }
;; 33 succs { 34 }
;; 34 succs { 35 36 }
;; 35 succs { 37 }
;; 36 succs { 37 }
;; 37 succs { 38 }
;; 38 succs { 25 40 }
;; 39 succs { 40 }
;; 40 succs { 1 }

Analyzing function body size: FlexCAN_SetRxFifoFilter

IPA function summary for FlexCAN_SetRxFifoFilter/82 inlinable
  global time:     228.618184
  self size:       218
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.000000, time:0.000000
    size:3.000000, time:2.000000,  executed if:(not inlined)
    size:1.000000, time:1.000000,  nonconst if:(op0 changed)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op0[ref offset: 416] changed) && (not inlined)
    size:2.500000, time:2.500000,  nonconst if:(op0[ref offset: 416] changed)
    size:10.000000, time:4.000000,  nonconst if:(op1 changed)
    size:1.000000, time:0.200000,  executed if:(op1 == 3) && (not inlined)
    size:2.000000, time:0.400000,  executed if:(op1 == 3)
    size:1.000000, time:0.200000,  executed if:(op1 == 2) && (not inlined)
    size:94.000000, time:96.472729,  executed if:(op1 == 2)
    size:2.000000, time:3.636364,  executed if:(op1 == 2),  nonconst if:(op0[ref offset: 416] changed) && (op1 == 2)
    size:1.000000, time:0.200000,  executed if:(op1 == 1) && (not inlined)
    size:59.000000, time:63.300000,  executed if:(op1 == 1)
    size:2.000000, time:3.636364,  executed if:(op1 == 1),  nonconst if:(op0[ref offset: 416] changed) && (op1 == 1)
    size:1.000000, time:0.200000,  executed if:(op1 == 0) && (not inlined)
    size:28.000000, time:30.736364,  executed if:(op1 == 0)
    size:2.000000, time:3.636364,  executed if:(op1 == 0),  nonconst if:(op0[ref offset: 416] changed) && (op1 == 0)
  loop iterations:(op0[ref offset: 416] changed) && (op1 == 2) && (op1 == 1) && (op1 == 0)
  calls:
    SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13/109 function body not available
      loop depth: 0 freq:0.20 size: 1 time: 10 predicate: (op1 == 3)
    SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13/108 function body not available
      loop depth: 0 freq:0.20 size: 1 time: 10 predicate: (op1 == 3)
    SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13/109 function body not available
      loop depth: 0 freq:0.20 size: 1 time: 10 predicate: (op1 == 2)
    SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13/108 function body not available
      loop depth: 0 freq:0.20 size: 1 time: 10 predicate: (op1 == 2)
    SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13/109 function body not available
      loop depth: 0 freq:0.20 size: 1 time: 10 predicate: (op1 == 1)
    SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13/108 function body not available
      loop depth: 0 freq:0.20 size: 1 time: 10 predicate: (op1 == 1)
    SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13/109 function body not available
      loop depth: 0 freq:0.20 size: 1 time: 10 predicate: (op1 == 0)
    SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13/108 function body not available
      loop depth: 0 freq:0.20 size: 1 time: 10 predicate: (op1 == 0)


Analyzing function: FlexCAN_SetOperationMode/81
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6
;; 2 succs { 6 3 4 5 }
;; 3 succs { 6 }
;; 4 succs { 6 }
;; 5 succs { 6 }
;; 6 succs { 1 }

Analyzing function body size: FlexCAN_SetOperationMode

IPA function summary for FlexCAN_SetOperationMode/81 inlinable
  global time:     10.500000
  self size:       29
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.000000, time:0.000000
    size:3.000000, time:2.000000,  executed if:(not inlined)
    size:8.000000, time:4.000000,  nonconst if:(op1 changed)
    size:0.500000, time:0.125000,  executed if:(op1 == 2) && (not inlined),  nonconst if:(op0[ref offset: 32] changed) && (op1 == 2) && (not inlined)
    size:1.500000, time:0.375000,  executed if:(op1 == 2),  nonconst if:(op0[ref offset: 32] changed) && (op1 == 2)
    size:2.500000, time:0.625000,  executed if:(op1 == 2) && (not inlined)
    size:4.500000, time:1.125000,  executed if:(op1 == 2)
    size:0.500000, time:0.125000,  executed if:(op1 == 1) && (not inlined),  nonconst if:(op0[ref offset: 32] changed) && (op1 == 1) && (not inlined)
    size:1.500000, time:0.375000,  executed if:(op1 == 1),  nonconst if:(op0[ref offset: 32] changed) && (op1 == 1)
    size:0.500000, time:0.125000,  executed if:(op1 == 1) && (not inlined)
    size:0.500000, time:0.125000,  executed if:(op1 == 1)
    size:0.500000, time:0.125000,  executed if:(op1 == 0) && (not inlined),  nonconst if:(op0[ref offset: 32] changed) && (op1 == 0) && (not inlined)
    size:1.500000, time:0.375000,  executed if:(op1 == 0),  nonconst if:(op0[ref offset: 32] changed) && (op1 == 0)
    size:1.500000, time:0.375000,  executed if:(op1 == 0) && (not inlined)
    size:2.500000, time:0.625000,  executed if:(op1 == 0)
  calls:


Analyzing function: FlexCAN_SetMaxMsgBuffNum/80
;; 3 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 11 5 6 7 8 9 10
;;
;; Loop 1
;;  header 9, latch 8
;;  depth 1, outer 0
;;  nodes: 9 8 7 5 6
;;
;; Loop 2
;;  header 7, latch 6
;;  depth 2, outer 1
;;  nodes: 7 6
;; 2 succs { 10 3 }
;; 3 succs { 10 4 }
;; 4 succs { 11 10 }
;; 11 succs { 9 }
;; 5 succs { 7 }
;; 6 succs { 7 }
;; 7 succs { 6 8 }
;; 8 succs { 9 }
;; 9 succs { 5 10 }
;; 10 succs { 1 }

Analyzing function body size: FlexCAN_SetMaxMsgBuffNum

IPA function summary for FlexCAN_SetMaxMsgBuffNum/80 inlinable
  global time:     187.702867
  self size:       51
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:21.500000, time:102.107297
    size:4.500000, time:2.633750,  executed if:(not inlined)
    size:2.000000, time:2.000000,  nonconst if:(op0 changed)
    size:2.000000, time:1.422500,  nonconst if:(op1 changed)
    size:2.000000, time:1.300000,  nonconst if:(op0 changed || op1 changed)
  calls:
    FlexCAN_GetMbPayloadSize/70 function not considered for inlining
      loop depth: 1 freq:1.71 size: 4 time: 13
       op0 change 58.500000% of time
    FlexCAN_GetMsgBuffRegion/58 function not considered for inlining
      loop depth: 1 freq:1.71 size: 4 time: 13
       op0 change 58.500000% of time
    FlexCAN_GetMaxMbNum/59 function not considered for inlining
      loop depth: 0 freq:0.65 size: 3 time: 12
    FlexCAN_GetMsgBuffRegion/58 function not considered for inlining
      loop depth: 0 freq:1.00 size: 4 time: 13
    FlexCAN_GetMbPayloadSize/70 function not considered for inlining
      loop depth: 0 freq:1.00 size: 4 time: 13


Analyzing function: FlexCAN_SetTxMsgBuff/79
;; 4 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 29 5 6 28 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
;;
;; Loop 3
;;  header 11, latch 10
;;  depth 1, outer 0
;;  nodes: 11 10
;;
;; Loop 2
;;  header 8, latch 7
;;  depth 1, outer 0
;;  nodes: 8 7
;;
;; Loop 1
;;  header 6, latch 5
;;  depth 1, outer 0
;;  nodes: 6 5
;; 2 succs { 3 4 }
;; 3 succs { 4 }
;; 4 succs { 29 12 }
;; 29 succs { 6 }
;; 5 succs { 6 }
;; 6 succs { 5 28 }
;; 28 succs { 8 }
;; 7 succs { 8 }
;; 8 succs { 7 9 }
;; 9 succs { 11 }
;; 10 succs { 11 }
;; 11 succs { 10 12 }
;; 12 succs { 13 14 }
;; 13 succs { 14 }
;; 14 succs { 15 16 }
;; 15 succs { 16 }
;; 16 succs { 17 27 }
;; 17 succs { 18 19 }
;; 18 succs { 21 }
;; 19 succs { 20 21 }
;; 20 succs { 21 }
;; 21 succs { 22 23 }
;; 22 succs { 24 }
;; 23 succs { 24 }
;; 24 succs { 25 26 }
;; 25 succs { 26 }
;; 26 succs { 27 }
;; 27 succs { 1 }

Analyzing function body size: FlexCAN_SetTxMsgBuff

IPA function summary for FlexCAN_SetTxMsgBuff/79 inlinable
  global time:     264.177949
  self size:       103
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:42.500000, time:26.994400
    size:11.500000, time:7.500000,  executed if:(not inlined)
    size:1.000000, time:1.000000,  nonconst if:(op0 changed)
    size:2.000000, time:2.000000,  nonconst if:(op3 changed)
    size:1.500000, time:9.195455,  executed if:(op3 != 0B) && (not inlined)
    size:35.500000, time:206.659094,  executed if:(op3 != 0B)
    size:3.000000, time:1.340000,  nonconst if:(op2 changed)
    size:2.000000, time:0.871200,  nonconst if:(op4 changed)
    size:1.000000, time:0.217800,  executed if:(op4 != 0)
  calls:
    FlexCAN_ComputePayloadSize/57 function not considered for inlining
      loop depth: 0 freq:0.70 size: 3 time: 12 predicate: (op3 != 0B)


Analyzing function: FlexCAN_GetMsgBuff/78
;; 3 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6 7 8 9 13 10 11 12
;;
;; Loop 2
;;  header 11, latch 10
;;  depth 1, outer 0
;;  nodes: 11 10
;;
;; Loop 1
;;  header 9, latch 8
;;  depth 1, outer 0
;;  nodes: 9 8
;; 2 succs { 3 4 }
;; 3 succs { 4 }
;; 4 succs { 5 6 }
;; 5 succs { 7 }
;; 6 succs { 7 }
;; 7 succs { 9 }
;; 8 succs { 9 }
;; 9 succs { 8 13 }
;; 13 succs { 11 }
;; 10 succs { 11 }
;; 11 succs { 10 12 }
;; 12 succs { 1 }

Analyzing function body size: FlexCAN_GetMsgBuff

IPA function summary for FlexCAN_GetMsgBuff/78 inlinable
  global time:     291.335454
  self size:       64
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:43.000000, time:241.000000
    size:6.000000, time:8.045455,  executed if:(not inlined)
  calls:
    FlexCAN_GetMbPayloadSize/70 function not considered for inlining
      loop depth: 0 freq:0.33 size: 4 time: 13
    FlexCAN_GetMbPayloadSize/70 function not considered for inlining
      loop depth: 0 freq:1.00 size: 4 time: 13
    FlexCAN_ComputePayloadSize/57 function not considered for inlining
      loop depth: 0 freq:1.00 size: 3 time: 12
    FlexCAN_GetMsgBuffRegion/58 function not considered for inlining
      loop depth: 0 freq:1.00 size: 4 time: 13


Analyzing function: FlexCAN_GetMsgBuffTimestamp/77
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2
;; 2 succs { 1 }

Analyzing function body size: FlexCAN_GetMsgBuffTimestamp

IPA function summary for FlexCAN_GetMsgBuffTimestamp/77 inlinable
  global time:     17.000000
  self size:       9
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:2.000000, time:2.000000
    size:3.000000, time:2.000000,  executed if:(not inlined)
  calls:
    FlexCAN_GetMsgBuffRegion/58 function not considered for inlining
      loop depth: 0 freq:1.00 size: 4 time: 13


Analyzing function: FlexCAN_SetRxMsgBuff/76
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6 7 8
;; 2 succs { 3 4 }
;; 3 succs { 4 }
;; 4 succs { 5 6 }
;; 5 succs { 6 }
;; 6 succs { 7 8 }
;; 7 succs { 8 }
;; 8 succs { 1 }

Analyzing function body size: FlexCAN_SetRxMsgBuff

IPA function summary for FlexCAN_SetRxMsgBuff/76 inlinable
  global time:     40.860000
  self size:       50
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:38.500000, time:23.190000
    size:4.500000, time:3.330000,  executed if:(not inlined)
    size:3.000000, time:1.340000,  nonconst if:(op3 changed)
  calls:
    FlexCAN_GetMsgBuffRegion/58 function not considered for inlining
      loop depth: 0 freq:1.00 size: 4 time: 13


Analyzing function: FlexCAN_EnableInterrupts/75
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2
;; 2 succs { 1 }

Analyzing function body size: FlexCAN_EnableInterrupts

IPA function summary for FlexCAN_EnableInterrupts/75 inlinable
  global time:     4.000000
  self size:       5
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:1.500000, time:1.500000
    size:3.500000, time:2.500000,  executed if:(not inlined)
  array index:(op1 changed)
  calls:


Analyzing function: FlexCAN_DisableInterrupts/74
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2
;; 2 succs { 1 }

Analyzing function body size: FlexCAN_DisableInterrupts

IPA function summary for FlexCAN_DisableInterrupts/74 inlinable
  global time:     3.000000
  self size:       4
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.500000, time:0.500000
    size:3.500000, time:2.500000,  executed if:(not inlined)
  calls:


Analyzing function: FLEXCAN_ClearMsgBuffIntCmd/73
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6
;; 2 succs { 3 6 }
;; 3 succs { 4 5 }
;; 4 succs { 5 }
;; 5 succs { 6 }
;; 6 succs { 1 }

Analyzing function body size: FLEXCAN_ClearMsgBuffIntCmd

IPA function summary for FLEXCAN_ClearMsgBuffIntCmd/73 inlinable
  global time:     14.910000
  self size:       17
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.000000, time:0.000000
    size:3.000000, time:2.000000,  executed if:(not inlined)
    size:4.000000, time:4.000000,  nonconst if:(op2 changed)
    size:0.500000, time:0.165000,  executed if:(op2 <= 31) && (not inlined)
    size:2.500000, time:0.825000,  executed if:(op2 <= 31)
    size:1.000000, time:0.330000,  executed if:(op2 <= 31),  nonconst if:(op2 changed) && (op2 <= 31)
    size:2.000000, time:0.660000,  executed if:(op2 <= 31),  nonconst if:(op3 changed) && (op2 <= 31)
    size:1.500000, time:0.247500,  executed if:(op3 != 0) && (op2 <= 31)
    size:0.500000, time:0.082500,  executed if:(op3 != 0) && (op2 <= 31) && (not inlined)
  array index:(op1 changed)
  calls:
    SchM_Exit_Can_CAN_EXCLUSIVE_AREA_11/106 function body not available
      loop depth: 0 freq:0.33 size: 1 time: 10 predicate: (op2 <= 31)
    SchM_Enter_Can_CAN_EXCLUSIVE_AREA_11/105 function body not available
      loop depth: 0 freq:0.33 size: 1 time: 10 predicate: (op2 <= 31)


Analyzing function: FlexCAN_SetMsgBuffIntCmd/72
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6 7 8
;; 2 succs { 3 8 }
;; 3 succs { 4 7 }
;; 4 succs { 5 6 }
;; 5 succs { 6 }
;; 6 succs { 8 }
;; 7 succs { 8 }
;; 8 succs { 1 }

Analyzing function body size: FlexCAN_SetMsgBuffIntCmd

IPA function summary for FlexCAN_SetMsgBuffIntCmd/72 inlinable
  global time:     20.000000
  self size:       26
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.000000, time:0.000000
    size:3.000000, time:2.000000,  executed if:(not inlined)
    size:4.000000, time:4.000000,  nonconst if:(op2 changed)
    size:2.000000, time:1.000000,  executed if:(op2 <= 31),  nonconst if:(op3 changed) && (op2 <= 31)
    size:4.500000, time:1.125000,  executed if:(op3 == 0) && (op2 <= 31)
    size:1.000000, time:0.250000,  executed if:(op3 == 0) && (op2 <= 31),  nonconst if:(op2 changed) && (op3 == 0) && (op2 <= 31)
    size:0.500000, time:0.125000,  executed if:(op3 == 0) && (op2 <= 31) && (not inlined)
    size:3.000000, time:0.750000,  executed if:(op3 != 0) && (op2 <= 31)
    size:2.000000, time:0.500000,  executed if:(op3 != 0) && (op2 <= 31),  nonconst if:(op4 changed) && (op3 != 0) && (op2 <= 31)
    size:1.500000, time:0.187500,  executed if:(op4 != 0) && (op3 != 0) && (op2 <= 31)
    size:0.500000, time:0.062500,  executed if:(op4 != 0) && (op3 != 0) && (op2 <= 31) && (not inlined)
  array index:(op1 changed)
  calls:
    SchM_Exit_Can_CAN_EXCLUSIVE_AREA_18/104 function body not available
      loop depth: 0 freq:0.25 size: 1 time: 10 predicate: (op3 == 0) && (op2 <= 31)
    SchM_Enter_Can_CAN_EXCLUSIVE_AREA_18/103 function body not available
      loop depth: 0 freq:0.25 size: 1 time: 10 predicate: (op3 == 0) && (op2 <= 31)
    SchM_Exit_Can_CAN_EXCLUSIVE_AREA_18/104 function body not available
      loop depth: 0 freq:0.25 size: 1 time: 10 predicate: (op3 != 0) && (op2 <= 31)
    SchM_Enter_Can_CAN_EXCLUSIVE_AREA_18/103 function body not available
      loop depth: 0 freq:0.25 size: 1 time: 10 predicate: (op3 != 0) && (op2 <= 31)


Analyzing function: FlexCAN_LockRxMsgBuff/71
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2
;; 2 succs { 1 }

Analyzing function body size: FlexCAN_LockRxMsgBuff

IPA function summary for FlexCAN_LockRxMsgBuff/71 inlinable
  global time:     16.000000
  self size:       8
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:1.000000, time:1.000000
    size:3.000000, time:2.000000,  executed if:(not inlined)
  calls:
    FlexCAN_GetMsgBuffRegion/58 function not considered for inlining
      loop depth: 0 freq:1.00 size: 4 time: 13


Analyzing function: FlexCAN_GetMbPayloadSize/70
;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 6 4 5
;;
;; Loop 1
;;  header 4, latch 6
;;  depth 1, outer 0
;;  nodes: 4 6 3
;; 2 succs { 4 }
;; 3 succs { 5 6 }
;; 6 succs { 4 }
;; 4 succs { 3 5 }
;; 5 succs { 1 }

Analyzing function body size: FlexCAN_GetMbPayloadSize

IPA function summary for FlexCAN_GetMbPayloadSize/70 inlinable
  global time:     31.383886
  self size:       14
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:7.000000, time:17.061611
    size:3.000000, time:2.000000,  executed if:(not inlined)
  calls:
    FlexCAN_GetPayloadSize/69 function not considered for inlining
      loop depth: 1 freq:0.95 size: 4 time: 13
       op1 is compile time invariant


Analyzing function: FlexCAN_GetPayloadSize/69
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6
;; 2 succs { 3 6 }
;; 3 succs { 5 4 }
;; 4 succs { 6 }
;; 5 succs { 6 }
;; 6 succs { 1 }

Analyzing function body size: FlexCAN_GetPayloadSize

IPA function summary for FlexCAN_GetPayloadSize/69 inlinable
  global time:     19.000000
  self size:       18
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.000000, time:0.000000
    size:3.000000, time:2.000000,  executed if:(not inlined)
    size:2.000000, time:2.000000,  nonconst if:(op0 changed)
    size:2.000000, time:1.000000,  nonconst if:(op1 changed)
    size:0.500000, time:0.125000,  executed if:(op1 == 0) && (not inlined),  nonconst if:(op0[ref offset: 24576] changed) && (op1 == 0) && (not inlined)
    size:3.500000, time:0.875000,  executed if:(op1 == 0),  nonconst if:(op0[ref offset: 24576] changed) && (op1 == 0)
    size:0.500000, time:0.125000,  executed if:(op1 != 0) && (not inlined),  nonconst if:(op0[ref offset: 24576] changed) && (op1 != 0) && (not inlined)
    size:3.500000, time:0.875000,  executed if:(op1 != 0),  nonconst if:(op0[ref offset: 24576] changed) && (op1 != 0)
  calls:
    FlexCAN_IsFDAvailable/67 function not considered for inlining
      loop depth: 0 freq:1.00 size: 3 time: 12


Analyzing function: FlexCAN_SetPayloadSize/68
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4
;; 2 succs { 3 4 }
;; 3 succs { 4 }
;; 4 succs { 1 }

Analyzing function body size: FlexCAN_SetPayloadSize

IPA function summary for FlexCAN_SetPayloadSize/68 inlinable
  global time:     9.000000
  self size:       13
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.500000, time:0.250000
    size:3.500000, time:2.250000,  executed if:(not inlined)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op0[ref offset: 0] changed) && (not inlined)
    size:3.500000, time:3.500000,  nonconst if:(op0[ref offset: 0] changed)
    size:0.500000, time:0.250000,  executed if:(not inlined),  nonconst if:(op0[ref offset: 24576] changed) && (not inlined)
    size:1.500000, time:0.750000,  nonconst if:(op0[ref offset: 24576] changed)
    size:0.500000, time:0.250000,  executed if:(not inlined),  nonconst if:(op1[ref offset: 0] changed) && (not inlined)
    size:1.500000, time:0.750000,  nonconst if:(op1[ref offset: 0] changed)
    size:1.000000, time:0.500000,  nonconst if:(op0[ref offset: 24576] changed || op1[ref offset: 0] changed)
  calls:


Analyzing function: FlexCAN_IsFDAvailable/67
;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 6 4 5
;;
;; Loop 1
;;  header 4, latch 6
;;  depth 1, outer 0
;;  nodes: 4 6 3
;; 2 succs { 4 }
;; 3 succs { 5 6 }
;; 6 succs { 4 }
;; 4 succs { 3 5 }
;; 5 succs { 1 }

Analyzing function body size: FlexCAN_IsFDAvailable

IPA function summary for FlexCAN_IsFDAvailable/67 inlinable
  global time:     7.687204
  self size:       7
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:2.000000, time:3.791469
    size:3.000000, time:2.000000,  executed if:(not inlined)
    size:2.000000, time:1.895735,  nonconst if:(op0 changed)
  calls:


Analyzing function: FlexCAN_EnableRxFifo/66
;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6
;;
;; Loop 1
;;  header 5, latch 4
;;  depth 1, outer 0
;;  nodes: 5 4
;; 2 succs { 6 3 }
;; 3 succs { 5 }
;; 4 succs { 5 }
;; 5 succs { 4 6 }
;; 6 succs { 1 }

Analyzing function body size: FlexCAN_EnableRxFifo

IPA function summary for FlexCAN_EnableRxFifo/66 inlinable
  global time:     44.727273
  self size:       25
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:7.500000, time:17.159091
    size:5.500000, time:5.022727,  executed if:(not inlined)
    size:1.000000, time:0.750000,  executed if:(not inlined),  nonconst if:(op0[ref offset: 0] changed) && (not inlined)
    size:5.000000, time:4.250000,  nonconst if:(op0[ref offset: 0] changed)
    size:2.000000, time:1.000000,  nonconst if:(op1 changed)
    size:1.000000, time:4.545455,  nonconst if:(op0 changed)
  loop iterations:(op0 changed)
  calls:
    FlexCAN_GetMaxMbNum/59 function not considered for inlining
      loop depth: 0 freq:1.00 size: 3 time: 12


Analyzing function: FlexCAN_Init/65
;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 9 4 5 6 7 8
;;
;; Loop 1
;;  header 4, latch 9
;;  depth 1, outer 0
;;  nodes: 4 9 3
;; 2 succs { 4 }
;; 3 succs { 5 9 }
;; 9 succs { 4 }
;; 4 succs { 3 5 }
;; 5 succs { 6 8 }
;; 6 succs { 7 8 }
;; 7 succs { 8 }
;; 8 succs { 1 }

Analyzing function body size: FlexCAN_Init

IPA function summary for FlexCAN_Init/65 inlinable
  global time:     225.273348
  self size:       49
  global size:     0
  min size:       0
  self stack:      4
  global stack:    4
    size:20.000000, time:67.529443
    size:11.000000, time:9.653989,  executed if:(not inlined)
    size:2.000000, time:0.660000,  nonconst if:(op0 changed)
  calls:
    FlexCAN_IsFDAvailable/67 function not considered for inlining
      loop depth: 0 freq:0.33 size: 3 time: 12callee size: 3 stack: 0
    FlexCAN_ClearRAM/56 function not considered for inlining
      loop depth: 0 freq:0.33 size: 2 time: 11
    OsIf_GetElapsed/93 function body not available
      loop depth: 1 freq:8.83 size: 4 time: 13
       op0 is compile time invariant
       op1 is compile time invariant
    OsIf_GetCounter/92 function body not available
      loop depth: 0 freq:1.00 size: 3 time: 12
       op0 is compile time invariant
    OsIf_MicrosToTicks/89 function body not available
      loop depth: 0 freq:1.00 size: 4 time: 13
       op0 is compile time invariant
       op1 is compile time invariant


Analyzing function: FlexCAN_SetErrIntCmd/64
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6 7 8 9 10 11 12 13
;; 2 succs { 3 9 }
;; 3 succs { 4 5 }
;; 4 succs { 13 }
;; 5 succs { 7 6 }
;; 6 succs { 7 8 }
;; 7 succs { 8 }
;; 8 succs { 13 }
;; 9 succs { 10 11 }
;; 10 succs { 13 }
;; 11 succs { 12 13 }
;; 12 succs { 13 }
;; 13 succs { 1 }

Analyzing function body size: FlexCAN_SetErrIntCmd

IPA function summary for FlexCAN_SetErrIntCmd/64 inlinable
  global time:     32.799356
  self size:       38
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.000000, time:0.000000
    size:3.000000, time:2.000000,  executed if:(not inlined)
    size:2.000000, time:2.000000,  nonconst if:(op2 changed)
    size:2.000000, time:1.000000,  executed if:(op2 == 0),  nonconst if:(op1 changed) && (op2 == 0)
    size:2.500000, time:0.660000,  executed if:(op1 != 16385) && (op2 == 0) && (not inlined)
    size:7.500000, time:2.145000,  executed if:(op1 != 16385) && (op2 == 0)
    size:1.000000, time:0.330000,  executed if:(op1 != 16385) && (op2 == 0),  nonconst if:(op1 changed) && (op1 != 16385) && (op2 == 0)
    size:1.000000, time:0.170000,  executed if:(op1 == 16385) && (op2 == 0) && (not inlined)
    size:2.000000, time:0.340000,  executed if:(op1 == 16385) && (op2 == 0)
    size:2.000000, time:1.000000,  executed if:(op2 != 0),  nonconst if:(op1 changed) && (op2 != 0)
    size:2.000000, time:0.660000,  executed if:(op1 != 16385) && (op2 != 0),  nonconst if:(op1 changed) && (op1 != 16385) && (op2 != 0)
    size:2.000000, time:0.435600,  executed if:(op1 != 1024) && (op1 != 16385) && (op2 != 0),  nonconst if:(op1 changed) && (op1 != 1024) && (op1 != 16385) && (op2 != 0)
    size:1.000000, time:0.186252,  executed if:(op1 == 1024 || op1 == 2048) && (op1 != 16385) && (op2 != 0) && (not inlined)
    size:2.000000, time:0.372504,  executed if:(op1 == 1024 || op1 == 2048) && (op1 != 16385) && (op2 != 0)
    size:1.000000, time:0.330000,  executed if:(op1 != 16385) && (op2 != 0) && (not inlined)
    size:2.000000, time:0.660000,  executed if:(op1 != 16385) && (op2 != 0)
    size:1.000000, time:0.170000,  executed if:(op1 == 16385) && (op2 != 0) && (not inlined)
    size:2.000000, time:0.340000,  executed if:(op1 == 16385) && (op2 != 0)
  calls:
    SchM_Exit_Can_CAN_EXCLUSIVE_AREA_06/101 function body not available
      loop depth: 0 freq:1.00 size: 1 time: 10
    SchM_Enter_Can_CAN_EXCLUSIVE_AREA_06/100 function body not available
      loop depth: 0 freq:1.00 size: 1 time: 10


Analyzing function: FlexCAN_Disable/63
;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 7 5 6
;;
;; Loop 1
;;  header 5, latch 7
;;  depth 1, outer 0
;;  nodes: 5 7 4
;; 2 succs { 3 6 }
;; 3 succs { 5 }
;; 4 succs { 6 7 }
;; 7 succs { 5 }
;; 5 succs { 4 6 }
;; 6 succs { 1 }

Analyzing function body size: FlexCAN_Disable

IPA function summary for FlexCAN_Disable/63 inlinable
  global time:     108.071393
  self size:       31
  global size:     0
  min size:       0
  self stack:      4
  global stack:    4
    size:13.000000, time:29.308625
    size:5.000000, time:4.853571,  executed if:(not inlined)
  calls:
    OsIf_GetElapsed/93 function body not available
      loop depth: 1 freq:3.66 size: 4 time: 13
       op0 is compile time invariant
       op1 is compile time invariant
    OsIf_GetCounter/92 function body not available
      loop depth: 0 freq:0.41 size: 3 time: 12
       op0 is compile time invariant
    SchM_Exit_Can_CAN_EXCLUSIVE_AREA_05/99 function body not available
      loop depth: 0 freq:0.41 size: 1 time: 10
    SchM_Enter_Can_CAN_EXCLUSIVE_AREA_05/98 function body not available
      loop depth: 0 freq:0.41 size: 1 time: 10
    OsIf_MicrosToTicks/89 function body not available
      loop depth: 0 freq:1.00 size: 4 time: 13
       op0 is compile time invariant
       op1 is compile time invariant


Analyzing function: FlexCAN_ExitFreezeMode/62
;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 6 4 5
;;
;; Loop 1
;;  header 4, latch 6
;;  depth 1, outer 0
;;  nodes: 4 6 3
;; 2 succs { 4 }
;; 3 succs { 5 6 }
;; 6 succs { 4 }
;; 4 succs { 3 5 }
;; 5 succs { 1 }

Analyzing function body size: FlexCAN_ExitFreezeMode

IPA function summary for FlexCAN_ExitFreezeMode/62 inlinable
  global time:     233.733349
  self size:       31
  global size:     0
  min size:       0
  self stack:      4
  global stack:    4
    size:12.500000, time:65.219444
    size:5.500000, time:8.673989,  executed if:(not inlined)
  calls:
    OsIf_GetElapsed/93 function body not available
      loop depth: 1 freq:8.83 size: 4 time: 13
       op0 is compile time invariant
       op1 is compile time invariant
    OsIf_GetCounter/92 function body not available
      loop depth: 0 freq:1.00 size: 3 time: 12
       op0 is compile time invariant
    SchM_Exit_Can_CAN_EXCLUSIVE_AREA_04/97 function body not available
      loop depth: 0 freq:1.00 size: 1 time: 10
    SchM_Enter_Can_CAN_EXCLUSIVE_AREA_04/96 function body not available
      loop depth: 0 freq:1.00 size: 1 time: 10
    OsIf_MicrosToTicks/89 function body not available
      loop depth: 0 freq:1.00 size: 4 time: 13
       op0 is compile time invariant
       op1 is compile time invariant


Analyzing function: FlexCAN_Enable/61
;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 6 4 5
;;
;; Loop 1
;;  header 4, latch 6
;;  depth 1, outer 0
;;  nodes: 4 6 3
;; 2 succs { 4 }
;; 3 succs { 5 6 }
;; 6 succs { 4 }
;; 4 succs { 3 5 }
;; 5 succs { 1 }

Analyzing function body size: FlexCAN_Enable

IPA function summary for FlexCAN_Enable/61 inlinable
  global time:     230.733349
  self size:       28
  global size:     0
  min size:       0
  self stack:      4
  global stack:    4
    size:10.500000, time:63.219444
    size:4.500000, time:7.673989,  executed if:(not inlined)
  calls:
    OsIf_GetElapsed/93 function body not available
      loop depth: 1 freq:8.83 size: 4 time: 13
       op0 is compile time invariant
       op1 is compile time invariant
    OsIf_GetCounter/92 function body not available
      loop depth: 0 freq:1.00 size: 3 time: 12
       op0 is compile time invariant
    SchM_Exit_Can_CAN_EXCLUSIVE_AREA_03/95 function body not available
      loop depth: 0 freq:1.00 size: 1 time: 10
    SchM_Enter_Can_CAN_EXCLUSIVE_AREA_03/94 function body not available
      loop depth: 0 freq:1.00 size: 1 time: 10
    OsIf_MicrosToTicks/89 function body not available
      loop depth: 0 freq:1.00 size: 4 time: 13
       op0 is compile time invariant
       op1 is compile time invariant


Analyzing function: FlexCAN_EnterFreezeMode/60
;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 8 6 7
;;
;; Loop 1
;;  header 6, latch 8
;;  depth 1, outer 0
;;  nodes: 6 8 5
;; 2 succs { 3 4 }
;; 3 succs { 4 }
;; 4 succs { 6 }
;; 5 succs { 7 8 }
;; 8 succs { 6 }
;; 6 succs { 5 7 }
;; 7 succs { 1 }

Analyzing function body size: FlexCAN_EnterFreezeMode

IPA function summary for FlexCAN_EnterFreezeMode/60 inlinable
  global time:     237.963349
  self size:       37
  global size:     0
  min size:       0
  self stack:      4
  global stack:    4
    size:17.000000, time:68.539444
    size:7.000000, time:9.583989,  executed if:(not inlined)
  calls:
    OsIf_GetElapsed/93 function body not available
      loop depth: 1 freq:8.83 size: 4 time: 13
       op0 is compile time invariant
       op1 is compile time invariant
    OsIf_GetCounter/92 function body not available
      loop depth: 0 freq:1.00 size: 3 time: 12
       op0 is compile time invariant
    SchM_Exit_Can_CAN_EXCLUSIVE_AREA_02/91 function body not available
      loop depth: 0 freq:1.00 size: 1 time: 10
    SchM_Enter_Can_CAN_EXCLUSIVE_AREA_02/90 function body not available
      loop depth: 0 freq:1.00 size: 1 time: 10
    OsIf_MicrosToTicks/89 function body not available
      loop depth: 0 freq:1.00 size: 4 time: 13
       op0 is compile time invariant
       op1 is compile time invariant


Analyzing function: FlexCAN_GetMaxMbNum/59
;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6 7
;;
;; Loop 1
;;  header 6, latch 5
;;  depth 1, outer 0
;;  nodes: 6 5 3 4
;; 2 succs { 6 }
;; 3 succs { 4 5 }
;; 4 succs { 5 }
;; 5 succs { 6 }
;; 6 succs { 3 7 }
;; 7 succs { 1 }

Analyzing function body size: FlexCAN_GetMaxMbNum

IPA function summary for FlexCAN_GetMaxMbNum/59 inlinable
  global time:     22.900000
  self size:       10
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:7.000000, time:20.900000
    size:3.000000, time:2.000000,  executed if:(not inlined)
  calls:


Analyzing function: FlexCAN_GetMsgBuffRegion/58
;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6
;;
;; Loop 1
;;  header 5, latch 4
;;  depth 1, outer 0
;;  nodes: 5 4 3
;; 2 succs { 5 }
;; 3 succs { 6 4 }
;; 4 succs { 5 }
;; 5 succs { 3 6 }
;; 6 succs { 1 }

Analyzing function body size: FlexCAN_GetMsgBuffRegion

IPA function summary for FlexCAN_GetMsgBuffRegion/58 inlinable
  global time:     49.175355
  self size:       23
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:15.000000, time:33.853081
    size:3.000000, time:2.000000,  executed if:(not inlined)
    size:1.000000, time:1.000000,  nonconst if:(op0 changed)
  calls:
    FlexCAN_GetPayloadSize/69 function not considered for inlining
      loop depth: 1 freq:0.95 size: 4 time: 13callee size: 9 stack: 0
       op1 is compile time invariant


Analyzing function: FlexCAN_ComputePayloadSize/57
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4
;; 2 succs { 4 3 }
;; 3 succs { 4 }
;; 4 succs { 1 }

Analyzing function body size: FlexCAN_ComputePayloadSize

IPA function summary for FlexCAN_ComputePayloadSize/57 inlinable
  global time:     10.000000
  self size:       8
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.000000, time:0.000000
    size:3.000000, time:2.000000,  executed if:(not inlined)
    size:2.000000, time:2.000000,  nonconst if:(op0 changed)
  calls:
    FlexCAN_ComputePayloadSize.part.0/112 function not considered for inlining
      loop depth: 0 freq:0.50 size: 3 time: 12callee size: 3 stack: 0 predicate: (op0 > 8)


Analyzing function: FlexCAN_ClearRAM/56
;; 3 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6 7 8
;;
;; Loop 2
;;  header 7, latch 6
;;  depth 1, outer 0
;;  nodes: 7 6
;;
;; Loop 1
;;  header 4, latch 3
;;  depth 1, outer 0
;;  nodes: 4 3
;; 2 succs { 4 }
;; 3 succs { 4 }
;; 4 succs { 3 5 }
;; 5 succs { 7 }
;; 6 succs { 7 }
;; 7 succs { 6 8 }
;; 8 succs { 1 }

Analyzing function body size: FlexCAN_ClearRAM

IPA function summary for FlexCAN_ClearRAM/56 inlinable
  global time:     117.090910
  self size:       20
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:12.000000, time:101.090909
    size:3.000000, time:2.000000,  executed if:(not inlined)
    size:2.000000, time:2.000000,  nonconst if:(op0 changed)
  loop iterations:(op0 changed)
  calls:
    FlexCAN_GetMaxMbNum/59 function not considered for inlining
      loop depth: 0 freq:1.00 size: 3 time: 12callee size: 5 stack: 0


Analyzing function: FlexCAN_SetPNPayloadLowFilter2/45
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2
;; 2 succs { 1 }

Analyzing function body size: FlexCAN_SetPNPayloadLowFilter2

IPA function summary for FlexCAN_SetPNPayloadLowFilter2/45 inlinable
  global time:     13.000000
  self size:       14
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:7.000000, time:7.000000
    size:5.000000, time:4.000000,  executed if:(not inlined)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op1[ref offset: 0] changed) && (not inlined)
    size:1.500000, time:1.500000,  nonconst if:(op1[ref offset: 0] changed)
  calls:


Analyzing function: FlexCAN_SetPNPayloadHighFilter2/44
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2
;; 2 succs { 1 }

Analyzing function body size: FlexCAN_SetPNPayloadHighFilter2

IPA function summary for FlexCAN_SetPNPayloadHighFilter2/44 inlinable
  global time:     13.000000
  self size:       14
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:8.500000, time:8.500000
    size:5.500000, time:4.500000,  executed if:(not inlined)
  calls:


Analyzing function: FlexCAN_SetPNPayloadLowFilter1/43
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2
;; 2 succs { 1 }

Analyzing function body size: FlexCAN_SetPNPayloadLowFilter1

IPA function summary for FlexCAN_SetPNPayloadLowFilter1/43 inlinable
  global time:     13.000000
  self size:       14
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:7.000000, time:7.000000
    size:5.000000, time:4.000000,  executed if:(not inlined)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op1[ref offset: 0] changed) && (not inlined)
    size:1.500000, time:1.500000,  nonconst if:(op1[ref offset: 0] changed)
  calls:


Analyzing function: FlexCAN_SetPNPayloadHighFilter1/42
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2
;; 2 succs { 1 }

Analyzing function body size: FlexCAN_SetPNPayloadHighFilter1

IPA function summary for FlexCAN_SetPNPayloadHighFilter1/42 inlinable
  global time:     13.000000
  self size:       14
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:8.500000, time:8.500000
    size:5.500000, time:4.500000,  executed if:(not inlined)
  calls:


Analyzing function: FlexCAN_SetPNDlcFilter/41
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2
;; 2 succs { 1 }

Analyzing function body size: FlexCAN_SetPNDlcFilter

IPA function summary for FlexCAN_SetPNDlcFilter/41 inlinable
  global time:     10.000000
  self size:       11
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.500000, time:0.500000
    size:3.500000, time:2.500000,  executed if:(not inlined)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op0[ref offset: 22656] changed) && (not inlined)
    size:1.500000, time:1.500000,  nonconst if:(op0[ref offset: 22656] changed)
    size:1.000000, time:1.000000,  nonconst if:(op2 changed)
    size:1.000000, time:1.000000,  nonconst if:(op0[ref offset: 22656] changed || op2 changed)
    size:2.000000, time:2.000000,  nonconst if:(op1 changed)
    size:1.000000, time:1.000000,  nonconst if:(op0[ref offset: 22656] changed || op2 changed || op1 changed)
  calls:


Analyzing function: FlexCAN_SetPNIdFilter2/40
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6 7 8 9
;; 2 succs { 4 3 }
;; 3 succs { 4 }
;; 4 succs { 6 5 }
;; 5 succs { 6 }
;; 6 succs { 7 8 }
;; 7 succs { 9 }
;; 8 succs { 9 }
;; 9 succs { 1 }

Analyzing function body size: FlexCAN_SetPNIdFilter2

IPA function summary for FlexCAN_SetPNIdFilter2/40 inlinable
  global time:     19.500000
  self size:       24
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.500000, time:0.500000
    size:3.500000, time:2.500000,  executed if:(not inlined)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op0[ref offset: 22752] changed) && (not inlined)
    size:1.500000, time:1.500000,  nonconst if:(op0[ref offset: 22752] changed)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op1[ref offset: 160] changed) && (not inlined)
    size:2.500000, time:2.500000,  nonconst if:(op1[ref offset: 160] changed)
    size:1.000000, time:1.000000,  nonconst if:(op0[ref offset: 22752] changed || op1[ref offset: 160] changed)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op1[ref offset: 168] changed) && (not inlined)
    size:2.500000, time:2.500000,  nonconst if:(op1[ref offset: 168] changed)
    size:1.000000, time:1.000000,  nonconst if:(op0[ref offset: 22752] changed || op1[ref offset: 160] changed || op1[ref offset: 168] changed)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op1[ref offset: 96] changed) && (not inlined)
    size:2.500000, time:2.500000,  nonconst if:(op1[ref offset: 96] changed)
    size:0.500000, time:0.250000,  executed if:(op1[ref offset: 96] == 0) && (not inlined),  nonconst if:(op1[ref offset: 192] changed) && (op1[ref offset: 96] == 0) && (not inlined)
    size:2.500000, time:1.250000,  executed if:(op1[ref offset: 96] == 0),  nonconst if:(op1[ref offset: 192] changed) && (op1[ref offset: 96] == 0)
    size:1.000000, time:0.500000,  executed if:(op1[ref offset: 96] == 0),  nonconst if:(op0[ref offset: 22752] changed || op1[ref offset: 160] changed || op1[ref offset: 168] changed || op1[ref offset: 192] changed) && (op1[ref offset: 96] == 0)
    size:0.500000, time:0.250000,  executed if:(op1[ref offset: 96] != 0) && (not inlined),  nonconst if:(op1[ref offset: 192] changed) && (op1[ref offset: 96] != 0) && (not inlined)
    size:1.500000, time:0.750000,  executed if:(op1[ref offset: 96] != 0),  nonconst if:(op1[ref offset: 192] changed) && (op1[ref offset: 96] != 0)
    size:1.000000, time:0.500000,  executed if:(op1[ref offset: 96] != 0),  nonconst if:(op0[ref offset: 22752] changed || op1[ref offset: 160] changed || op1[ref offset: 168] changed || op1[ref offset: 192] changed) && (op1[ref offset: 96] != 0)
  calls:


Analyzing function: FlexCAN_SetPNFilteringSelection/36
;; 1 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 4 5 6
;; 2 succs { 4 3 }
;; 3 succs { 4 }
;; 4 succs { 6 5 }
;; 5 succs { 6 }
;; 6 succs { 1 }

Analyzing function body size: FlexCAN_SetPNFilteringSelection

IPA function summary for FlexCAN_SetPNFilteringSelection/36 inlinable
  global time:     28.000000
  self size:       29
  global size:     0
  min size:       0
  self stack:      0
  global stack:    0
    size:0.500000, time:0.500000
    size:3.500000, time:2.500000,  executed if:(not inlined)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op0[ref offset: 22528] changed) && (not inlined)
    size:1.500000, time:1.500000,  nonconst if:(op0[ref offset: 22528] changed)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op1[ref offset: 0] changed) && (not inlined)
    size:2.500000, time:2.500000,  nonconst if:(op1[ref offset: 0] changed)
    size:1.000000, time:1.000000,  nonconst if:(op0[ref offset: 22528] changed || op1[ref offset: 0] changed)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op1[ref offset: 8] changed) && (not inlined)
    size:2.500000, time:2.500000,  nonconst if:(op1[ref offset: 8] changed)
    size:1.000000, time:1.000000,  nonconst if:(op0[ref offset: 22528] changed || op1[ref offset: 0] changed || op1[ref offset: 8] changed)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op1[ref offset: 16] changed) && (not inlined)
    size:2.500000, time:2.500000,  nonconst if:(op1[ref offset: 16] changed)
    size:1.000000, time:1.000000,  nonconst if:(op0[ref offset: 22528] changed || op1[ref offset: 0] changed || op1[ref offset: 8] changed || op1[ref offset: 16] changed)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op1[ref offset: 64] changed) && (not inlined)
    size:1.500000, time:1.500000,  nonconst if:(op1[ref offset: 64] changed)
    size:1.000000, time:1.000000,  nonconst if:(op0[ref offset: 22528] changed || op1[ref offset: 0] changed || op1[ref offset: 8] changed || op1[ref offset: 16] changed || op1[ref offset: 64] changed)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op1[ref offset: 224] changed) && (not inlined)
    size:2.500000, time:2.500000,  nonconst if:(op1[ref offset: 224] changed)
    size:1.000000, time:1.000000,  nonconst if:(op0[ref offset: 22528] changed || op1[ref offset: 0] changed || op1[ref offset: 8] changed || op1[ref offset: 16] changed || op1[ref offset: 64] changed || op1[ref offset: 224] changed)
    size:0.500000, time:0.500000,  executed if:(not inlined),  nonconst if:(op1[ref offset: 256] changed) && (not inlined)
    size:2.500000, time:2.500000,  nonconst if:(op1[ref offset: 256] changed)
    size:1.000000, time:1.000000,  nonconst if:(op0[ref offset: 22528] changed || op1[ref offset: 0] changed || op1[ref offset: 8] changed || op1[ref offset: 16] changed || op1[ref offset: 64] changed || op1[ref offset: 224] changed || op1[ref offset: 256] changed)
  calls:

Symbol table:

FlexCAN_GetPayloadSize.constprop.0/120 (FlexCAN_GetPayloadSize.constprop) @0620f460
  Type: function definition analyzed
  Visibility:
  References: 
  Referring: 
  Clone of FlexCAN_GetPayloadSize/69
  Availability: local
  Function flags: count:1073741824 (estimated locally) local optimize_size
  Called by: FlexCAN_GetMsgBuffRegion/58 (536870913 (estimated locally),0.95 per call) FlexCAN_GetMbPayloadSize/70 (536870913 (estimated locally),0.95 per call) 
  Calls: FlexCAN_IsFDAvailable/67 (1073741824 (estimated locally),1.00 per call) 
FlexCAN_ComputePayloadSize.part.0/112 (FlexCAN_ComputePayloadSize.part.0) @061c5b60
  Type: function definition analyzed
  Visibility: prevailing_def_ironly artificial
  References: CSWTCH.51/111 (read)
  Referring: 
  Availability: local
  Function flags: count:1073741824 (estimated locally) first_run:1 body local split_part optimize_size
  Called by: FlexCAN_ComputePayloadSize/57 (536870912 (estimated locally),0.50 per call) 
  Calls: 
CSWTCH.51/111 (CSWTCH.51) @0658d048
  Type: variable definition analyzed
  Visibility: prevailing_def_ironly artificial
  References: 
  Referring: FlexCAN_ComputePayloadSize.part.0/112 (read)
  Availability: available
  Varpool flags: initialized read-only const-value-known
FlexCAN_SetPNIdFilter1.isra.0/110 (FlexCAN_SetPNIdFilter1.isra.0) @061c57e0
  Type: function definition analyzed
  Visibility: prevailing_def_ironly artificial
  References: 
  Referring: 
  Availability: local
  Function flags: count:1073741824 (estimated locally) body local optimize_size
  Called by: FlexCAN_ConfigPN/86 (1073741823 (estimated locally),1.00 per call) 
  Calls: 
SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13/109 (SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13) @06414540
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_SetRxFifoFilter/82 (118111600 (estimated locally),0.20 per call) FlexCAN_SetRxFifoFilter/82 (118111600 (estimated locally),0.20 per call) FlexCAN_SetRxFifoFilter/82 (118111600 (estimated locally),0.20 per call) FlexCAN_SetRxFifoFilter/82 (118111600 (estimated locally),0.20 per call) 
  Calls: 
SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13/108 (SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13) @06414460
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_SetRxFifoFilter/82 (118111600 (estimated locally),0.20 per call) FlexCAN_SetRxFifoFilter/82 (118111600 (estimated locally),0.20 per call) FlexCAN_SetRxFifoFilter/82 (118111600 (estimated locally),0.20 per call) FlexCAN_SetRxFifoFilter/82 (118111600 (estimated locally),0.20 per call) 
  Calls: 
payload_code.7054/107 (payload_code) @06409d80
  Type: variable definition analyzed
  Visibility: prevailing_def_ironly
  References: 
  Referring: FlexCAN_SetTxMsgBuff/79 (read)
  Availability: available
  Varpool flags: initialized read-only const-value-known
SchM_Exit_Can_CAN_EXCLUSIVE_AREA_11/106 (SchM_Exit_Can_CAN_EXCLUSIVE_AREA_11) @063fc620
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FLEXCAN_ClearMsgBuffIntCmd/73 (354334802 (estimated locally),0.33 per call) 
  Calls: 
SchM_Enter_Can_CAN_EXCLUSIVE_AREA_11/105 (SchM_Enter_Can_CAN_EXCLUSIVE_AREA_11) @063fc540
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FLEXCAN_ClearMsgBuffIntCmd/73 (354334802 (estimated locally),0.33 per call) 
  Calls: 
SchM_Exit_Can_CAN_EXCLUSIVE_AREA_18/104 (SchM_Exit_Can_CAN_EXCLUSIVE_AREA_18) @063fc2a0
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_SetMsgBuffIntCmd/72 (268435456 (estimated locally),0.25 per call) FlexCAN_SetMsgBuffIntCmd/72 (268435456 (estimated locally),0.25 per call) 
  Calls: 
SchM_Enter_Can_CAN_EXCLUSIVE_AREA_18/103 (SchM_Enter_Can_CAN_EXCLUSIVE_AREA_18) @063fc1c0
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_SetMsgBuffIntCmd/72 (268435456 (estimated locally),0.25 per call) FlexCAN_SetMsgBuffIntCmd/72 (268435456 (estimated locally),0.25 per call) 
  Calls: 
SchM_Exit_Can_CAN_EXCLUSIVE_AREA_06/101 (SchM_Exit_Can_CAN_EXCLUSIVE_AREA_06) @063e58c0
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_SetErrIntCmd/64 (1073741824 (estimated locally),1.00 per call) 
  Calls: 
SchM_Enter_Can_CAN_EXCLUSIVE_AREA_06/100 (SchM_Enter_Can_CAN_EXCLUSIVE_AREA_06) @063e57e0
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_SetErrIntCmd/64 (1073741824 (estimated locally),1.00 per call) 
  Calls: 
SchM_Exit_Can_CAN_EXCLUSIVE_AREA_05/99 (SchM_Exit_Can_CAN_EXCLUSIVE_AREA_05) @063e5620
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_Disable/63 (114863532 (estimated locally),0.41 per call) 
  Calls: 
SchM_Enter_Can_CAN_EXCLUSIVE_AREA_05/98 (SchM_Enter_Can_CAN_EXCLUSIVE_AREA_05) @063e5540
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_Disable/63 (114863532 (estimated locally),0.41 per call) 
  Calls: 
SchM_Exit_Can_CAN_EXCLUSIVE_AREA_04/97 (SchM_Exit_Can_CAN_EXCLUSIVE_AREA_04) @063e5380
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_ExitFreezeMode/62 (114863532 (estimated locally),1.00 per call) 
  Calls: 
SchM_Enter_Can_CAN_EXCLUSIVE_AREA_04/96 (SchM_Enter_Can_CAN_EXCLUSIVE_AREA_04) @063e52a0
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_ExitFreezeMode/62 (114863532 (estimated locally),1.00 per call) 
  Calls: 
SchM_Exit_Can_CAN_EXCLUSIVE_AREA_03/95 (SchM_Exit_Can_CAN_EXCLUSIVE_AREA_03) @063e50e0
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_Enable/61 (114863532 (estimated locally),1.00 per call) 
  Calls: 
SchM_Enter_Can_CAN_EXCLUSIVE_AREA_03/94 (SchM_Enter_Can_CAN_EXCLUSIVE_AREA_03) @063e5000
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_Enable/61 (114863532 (estimated locally),1.00 per call) 
  Calls: 
OsIf_GetElapsed/93 (OsIf_GetElapsed) @063c50e0
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_Init/65 (1014686025 (estimated locally),8.83 per call) FlexCAN_Disable/63 (1014686024 (estimated locally),3.66 per call) FlexCAN_ExitFreezeMode/62 (1014686025 (estimated locally),8.83 per call) FlexCAN_Enable/61 (1014686025 (estimated locally),8.83 per call) FlexCAN_EnterFreezeMode/60 (1014686025 (estimated locally),8.83 per call) 
  Calls: 
OsIf_GetCounter/92 (OsIf_GetCounter) @063c5ee0
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_Init/65 (114863532 (estimated locally),1.00 per call) FlexCAN_Disable/63 (114863532 (estimated locally),0.41 per call) FlexCAN_ExitFreezeMode/62 (114863532 (estimated locally),1.00 per call) FlexCAN_Enable/61 (114863532 (estimated locally),1.00 per call) FlexCAN_EnterFreezeMode/60 (114863532 (estimated locally),1.00 per call) 
  Calls: 
SchM_Exit_Can_CAN_EXCLUSIVE_AREA_02/91 (SchM_Exit_Can_CAN_EXCLUSIVE_AREA_02) @063c5e00
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_EnterFreezeMode/60 (114863532 (estimated locally),1.00 per call) 
  Calls: 
SchM_Enter_Can_CAN_EXCLUSIVE_AREA_02/90 (SchM_Enter_Can_CAN_EXCLUSIVE_AREA_02) @063c5d20
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_EnterFreezeMode/60 (114863532 (estimated locally),1.00 per call) 
  Calls: 
OsIf_MicrosToTicks/89 (OsIf_MicrosToTicks) @063c5c40
  Type: function
  Visibility: external public
  References: 
  Referring: 
  Availability: not_available
  Function flags: optimize_size
  Called by: FlexCAN_Init/65 (114863532 (estimated locally),1.00 per call) FlexCAN_Disable/63 (276913048 (estimated locally),1.00 per call) FlexCAN_ExitFreezeMode/62 (114863532 (estimated locally),1.00 per call) FlexCAN_Enable/61 (114863532 (estimated locally),1.00 per call) FlexCAN_EnterFreezeMode/60 (114863532 (estimated locally),1.00 per call) 
  Calls: 
maxMbNum.7105/88 (maxMbNum) @063c6bd0
  Type: variable definition analyzed
  Visibility: prevailing_def_ironly
  References: 
  Referring: FlexCAN_GetMaxMbNum/59 (read)
  Availability: available
  Varpool flags: initialized read-only const-value-known
flexcanBase.7104/87 (flexcanBase) @063c6b88
  Type: variable definition analyzed
  Visibility: prevailing_def_ironly
  References: 
  Referring: FlexCAN_GetMaxMbNum/59 (read)
  Availability: available
  Varpool flags: initialized read-only const-value-known
FlexCAN_ConfigPN/86 (FlexCAN_ConfigPN) @063c5540
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:1073741823 (estimated locally) body optimize_size
  Called by: 
  Calls: FlexCAN_SetPNPayloadLowFilter2/45 (283645176 (estimated locally),0.26 per call) FlexCAN_SetPNPayloadHighFilter2/44 (283645176 (estimated locally),0.26 per call) FlexCAN_SetPNPayloadLowFilter1/43 (508506948 (estimated locally),0.47 per call) FlexCAN_SetPNPayloadHighFilter1/42 (508506948 (estimated locally),0.47 per call) FlexCAN_SetPNDlcFilter/41 (508506948 (estimated locally),0.47 per call) FlexCAN_SetPNIdFilter2/40 (598933190 (estimated locally),0.56 per call) FlexCAN_SetPNIdFilter1.isra.0/110 (1073741823 (estimated locally),1.00 per call) FlexCAN_SetPNFilteringSelection/36 (1073741823 (estimated locally),1.00 per call) 
FlexCAN_ConfigCtrlOptions/85 (FlexCAN_ConfigCtrlOptions) @063c52a0
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: 
FlexCAN_IsMbOutOfRange/84 (FlexCAN_IsMbOutOfRange) @063c5000
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: 
FlexCAN_ReadRxFifo/83 (FlexCAN_ReadRxFifo) @0638ec40
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:118111600 (estimated locally) body optimize_size
  Called by: 
  Calls: FlexCAN_ComputePayloadSize/57 (118111600 (estimated locally),1.00 per call) 
FlexCAN_SetRxFifoFilter/82 (FlexCAN_SetRxFifoFilter) @0638ee00
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:590558001 (estimated locally) body optimize_size
  Called by: 
  Calls: SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13/109 (118111600 (estimated locally),0.20 per call) SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13/108 (118111600 (estimated locally),0.20 per call) SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13/109 (118111600 (estimated locally),0.20 per call) SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13/108 (118111600 (estimated locally),0.20 per call) SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13/109 (118111600 (estimated locally),0.20 per call) SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13/108 (118111600 (estimated locally),0.20 per call) SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13/109 (118111600 (estimated locally),0.20 per call) SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13/108 (118111600 (estimated locally),0.20 per call) 
FlexCAN_SetOperationMode/81 (FlexCAN_SetOperationMode) @0638eb60
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: 
FlexCAN_SetMaxMsgBuffNum/80 (FlexCAN_SetMaxMsgBuffNum) @0638e460
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:69103254 (estimated locally) body optimize_size
  Called by: 
  Calls: FlexCAN_GetMbPayloadSize/70 (118111600 (estimated locally),1.71 per call) FlexCAN_GetMsgBuffRegion/58 (118111600 (estimated locally),1.71 per call) FlexCAN_GetMaxMbNum/59 (44917115 (estimated locally),0.65 per call) FlexCAN_GetMsgBuffRegion/58 (69103254 (estimated locally),1.00 per call) FlexCAN_GetMbPayloadSize/70 (69103254 (estimated locally),1.00 per call) 
FlexCAN_SetTxMsgBuff/79 (FlexCAN_SetTxMsgBuff) @0638e1c0
  Type: function definition analyzed
  Visibility: externally_visible public
  References: payload_code.7054/107 (read)
  Referring: 
  Availability: available
  Function flags: count:168730856 (estimated locally) body optimize_size
  Called by: 
  Calls: FlexCAN_ComputePayloadSize/57 (118111600 (estimated locally),0.70 per call) 
FlexCAN_GetMsgBuff/78 (FlexCAN_GetMsgBuff) @062557e0
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:118111600 (estimated locally) body optimize_size
  Called by: 
  Calls: FlexCAN_GetMbPayloadSize/70 (38976828 (estimated locally),0.33 per call) FlexCAN_GetMbPayloadSize/70 (118111600 (estimated locally),1.00 per call) FlexCAN_ComputePayloadSize/57 (118111600 (estimated locally),1.00 per call) FlexCAN_GetMsgBuffRegion/58 (118111600 (estimated locally),1.00 per call) 
FlexCAN_GetMsgBuffTimestamp/77 (FlexCAN_GetMsgBuffTimestamp) @06255ee0
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: FlexCAN_GetMsgBuffRegion/58 (1073741824 (estimated locally),1.00 per call) 
FlexCAN_SetRxMsgBuff/76 (FlexCAN_SetRxMsgBuff) @06255c40
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: FlexCAN_GetMsgBuffRegion/58 (1073741824 (estimated locally),1.00 per call) 
FlexCAN_EnableInterrupts/75 (FlexCAN_EnableInterrupts) @062559a0
  Type: function definition analyzed
  Visibility: externally_visible public
  References: FlexCAN_Ip_au32ImaskBuff/54 (read)
  Referring: 
  Availability: available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: 
FlexCAN_DisableInterrupts/74 (FlexCAN_DisableInterrupts) @06255700
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: 
FLEXCAN_ClearMsgBuffIntCmd/73 (FLEXCAN_ClearMsgBuffIntCmd) @06255460
  Type: function definition analyzed
  Visibility: externally_visible public
  References: FlexCAN_Ip_au32ImaskBuff/54 (write)FlexCAN_Ip_au32ImaskBuff/54 (read)
  Referring: 
  Availability: available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: SchM_Exit_Can_CAN_EXCLUSIVE_AREA_11/106 (354334802 (estimated locally),0.33 per call) SchM_Enter_Can_CAN_EXCLUSIVE_AREA_11/105 (354334802 (estimated locally),0.33 per call) 
FlexCAN_SetMsgBuffIntCmd/72 (FlexCAN_SetMsgBuffIntCmd) @062551c0
  Type: function definition analyzed
  Visibility: externally_visible public
  References: FlexCAN_Ip_au32ImaskBuff/54 (read)FlexCAN_Ip_au32ImaskBuff/54 (write)FlexCAN_Ip_au32ImaskBuff/54 (read)FlexCAN_Ip_au32ImaskBuff/54 (read)FlexCAN_Ip_au32ImaskBuff/54 (write)FlexCAN_Ip_au32ImaskBuff/54 (read)
  Referring: 
  Availability: available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: SchM_Exit_Can_CAN_EXCLUSIVE_AREA_18/104 (268435456 (estimated locally),0.25 per call) SchM_Enter_Can_CAN_EXCLUSIVE_AREA_18/103 (268435456 (estimated locally),0.25 per call) SchM_Exit_Can_CAN_EXCLUSIVE_AREA_18/104 (268435456 (estimated locally),0.25 per call) SchM_Enter_Can_CAN_EXCLUSIVE_AREA_18/103 (268435456 (estimated locally),0.25 per call) 
FlexCAN_LockRxMsgBuff/71 (FlexCAN_LockRxMsgBuff) @0624be00
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: FlexCAN_GetMsgBuffRegion/58 (1073741824 (estimated locally),1.00 per call) 
FlexCAN_GetMbPayloadSize/70 (FlexCAN_GetMbPayloadSize) @0624b8c0
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:566398813 (estimated locally) body optimize_size
  Called by: FlexCAN_SetMaxMsgBuffNum/80 (118111600 (estimated locally),1.71 per call) FlexCAN_SetMaxMsgBuffNum/80 (69103254 (estimated locally),1.00 per call) FlexCAN_GetMsgBuff/78 (38976828 (estimated locally),0.33 per call) FlexCAN_GetMsgBuff/78 (118111600 (estimated locally),1.00 per call) 
  Calls: FlexCAN_GetPayloadSize.constprop/120 (536870913 (estimated locally),0.95 per call) 
FlexCAN_GetPayloadSize/69 (FlexCAN_GetPayloadSize) @0624b0e0
  Type: function
  Body removed by symtab_remove_unreachable_nodes
  Visibility: prevailing_def_ironly
  References: 
  Referring: 
  Availability: not_available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: 
FlexCAN_SetPayloadSize/68 (FlexCAN_SetPayloadSize) @0624bd20
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: 
FlexCAN_IsFDAvailable/67 (FlexCAN_IsFDAvailable) @0624ba80
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:566398813 (estimated locally) body optimize_size
  Called by: FlexCAN_GetPayloadSize.constprop/120 (1073741824 (estimated locally),1.00 per call) FlexCAN_Init/65 (37904965 (estimated locally),0.33 per call) 
  Calls: 
FlexCAN_EnableRxFifo/66 (FlexCAN_EnableRxFifo) @0624b7e0
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:236223200 (estimated locally) body optimize_size
  Called by: 
  Calls: FlexCAN_GetMaxMbNum/59 (236223200 (estimated locally),1.00 per call) 
FlexCAN_Init/65 (FlexCAN_Init) @0624b460
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:114863532 (estimated locally) body optimize_size
  Called by: 
  Calls: FlexCAN_IsFDAvailable/67 (37904965 (estimated locally),0.33 per call) FlexCAN_ClearRAM/56 (37904965 (estimated locally),0.33 per call) OsIf_GetElapsed/93 (1014686025 (estimated locally),8.83 per call) OsIf_GetCounter/92 (114863532 (estimated locally),1.00 per call) OsIf_MicrosToTicks/89 (114863532 (estimated locally),1.00 per call) 
FlexCAN_SetErrIntCmd/64 (FlexCAN_SetErrIntCmd) @0624b000
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:1073741824 (estimated locally) body optimize_size
  Called by: 
  Calls: SchM_Exit_Can_CAN_EXCLUSIVE_AREA_06/101 (1073741824 (estimated locally),1.00 per call) SchM_Enter_Can_CAN_EXCLUSIVE_AREA_06/100 (1073741824 (estimated locally),1.00 per call) 
FlexCAN_Disable/63 (FlexCAN_Disable) @0623fe00
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:276913048 (estimated locally) body optimize_size
  Called by: 
  Calls: OsIf_GetElapsed/93 (1014686024 (estimated locally),3.66 per call) OsIf_GetCounter/92 (114863532 (estimated locally),0.41 per call) SchM_Exit_Can_CAN_EXCLUSIVE_AREA_05/99 (114863532 (estimated locally),0.41 per call) SchM_Enter_Can_CAN_EXCLUSIVE_AREA_05/98 (114863532 (estimated locally),0.41 per call) OsIf_MicrosToTicks/89 (276913048 (estimated locally),1.00 per call) 
FlexCAN_ExitFreezeMode/62 (FlexCAN_ExitFreezeMode) @0623fa80
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:114863532 (estimated locally) body optimize_size
  Called by: 
  Calls: OsIf_GetElapsed/93 (1014686025 (estimated locally),8.83 per call) OsIf_GetCounter/92 (114863532 (estimated locally),1.00 per call) SchM_Exit_Can_CAN_EXCLUSIVE_AREA_04/97 (114863532 (estimated locally),1.00 per call) SchM_Enter_Can_CAN_EXCLUSIVE_AREA_04/96 (114863532 (estimated locally),1.00 per call) OsIf_MicrosToTicks/89 (114863532 (estimated locally),1.00 per call) 
FlexCAN_Enable/61 (FlexCAN_Enable) @0623f620
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:114863532 (estimated locally) body optimize_size
  Called by: 
  Calls: OsIf_GetElapsed/93 (1014686025 (estimated locally),8.83 per call) OsIf_GetCounter/92 (114863532 (estimated locally),1.00 per call) SchM_Exit_Can_CAN_EXCLUSIVE_AREA_03/95 (114863532 (estimated locally),1.00 per call) SchM_Enter_Can_CAN_EXCLUSIVE_AREA_03/94 (114863532 (estimated locally),1.00 per call) OsIf_MicrosToTicks/89 (114863532 (estimated locally),1.00 per call) 
FlexCAN_EnterFreezeMode/60 (FlexCAN_EnterFreezeMode) @0623f380
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:114863532 (estimated locally) body optimize_size
  Called by: 
  Calls: OsIf_GetElapsed/93 (1014686025 (estimated locally),8.83 per call) OsIf_GetCounter/92 (114863532 (estimated locally),1.00 per call) SchM_Exit_Can_CAN_EXCLUSIVE_AREA_02/91 (114863532 (estimated locally),1.00 per call) SchM_Enter_Can_CAN_EXCLUSIVE_AREA_02/90 (114863532 (estimated locally),1.00 per call) OsIf_MicrosToTicks/89 (114863532 (estimated locally),1.00 per call) 
FlexCAN_GetMaxMbNum/59 (FlexCAN_GetMaxMbNum) @05d0ad20
  Type: function definition analyzed
  Visibility: externally_visible public
  References: flexcanBase.7104/87 (read)maxMbNum.7105/88 (read)
  Referring: 
  Availability: available
  Function flags: count:268435456 (estimated locally) body optimize_size
  Called by: FlexCAN_SetMaxMsgBuffNum/80 (44917115 (estimated locally),0.65 per call) FlexCAN_EnableRxFifo/66 (236223200 (estimated locally),1.00 per call) FlexCAN_ClearRAM/56 (118111600 (estimated locally),1.00 per call) 
  Calls: 
FlexCAN_GetMsgBuffRegion/58 (FlexCAN_GetMsgBuffRegion) @05d0a8c0
  Type: function definition analyzed
  Visibility: externally_visible public
  References: 
  Referring: 
  Availability: available
  Function flags: count:566398813 (estimated locally) body optimize_size
  Called by: FlexCAN_SetMaxMsgBuffNum/80 (118111600 (estimated locally),1.71 per call) FlexCAN_SetMaxMsgBuffNum/80 (69103254 (estimated locally),1.00 per call) FlexCAN_GetMsgBuff/78 (118111600 (estimated locally),1.00 per call) FlexCAN_GetMsgBuffTimestamp/77 (1073741824 (estimated locally),1.00 per call) FlexCAN_SetRxMsgBuff/76 (1073741824 (estimated locally),1.00 per call) FlexCAN_LockRxMsgBuff/71 (1073741824 (estimated locally),1.00 per call) 
  Calls: FlexCAN_GetPayloadSize.constprop/120 (536870913 (estimated locally),0.95 per call) 
FlexCAN_ComputePayloadSize/57 (FlexCAN_ComputePayloadSize) @05d0aee0
  Type: function definition analyzed
  Visibility: prevailing_def_ironly
  References: 
  Referring: 
  Availability: local
  Function flags: count:1073741824 (estimated locally) body local optimize_size
  Called by: FlexCAN_ReadRxFifo/83 (118111600 (estimated locally),1.00 per call) FlexCAN_SetTxMsgBuff/79 (118111600 (estimated locally),0.70 per call) FlexCAN_GetMsgBuff/78 (118111600 (estimated locally),1.00 per call) 
  Calls: FlexCAN_ComputePayloadSize.part.0/112 (536870912 (estimated locally),0.50 per call) 
FlexCAN_ClearRAM/56 (FlexCAN_ClearRAM) @05d0ac40
  Type: function definition analyzed
  Visibility: prevailing_def_ironly
  References: 
  Referring: 
  Availability: local
  Function flags: count:118111600 (estimated locally) body local optimize_size
  Called by: FlexCAN_Init/65 (37904965 (estimated locally),0.33 per call) 
  Calls: FlexCAN_GetMaxMbNum/59 (118111600 (estimated locally),1.00 per call) 
FlexCAN_Ip_au32ImaskBuff/54 (FlexCAN_Ip_au32ImaskBuff) @05d093f0
  Type: variable definition analyzed
  Visibility: force_output prevailing_def_ironly
  References: 
  Referring: FlexCAN_SetMsgBuffIntCmd/72 (write)FLEXCAN_ClearMsgBuffIntCmd/73 (read)FlexCAN_SetMsgBuffIntCmd/72 (read)FlexCAN_SetMsgBuffIntCmd/72 (read)FlexCAN_SetMsgBuffIntCmd/72 (write)FlexCAN_SetMsgBuffIntCmd/72 (read)FlexCAN_SetMsgBuffIntCmd/72 (read)FLEXCAN_ClearMsgBuffIntCmd/73 (write)FlexCAN_EnableInterrupts/75 (read)
  Availability: available
  Varpool flags:
FlexCAN_SetPNPayloadLowFilter2/45 (FlexCAN_SetPNPayloadLowFilter2) @062187e0
  Type: function definition analyzed
  Visibility: prevailing_def_ironly
  References: 
  Referring: 
  Availability: local
  Function flags: count:1073741824 (estimated locally) body local optimize_size
  Called by: FlexCAN_ConfigPN/86 (283645176 (estimated locally),0.26 per call) 
  Calls: 
FlexCAN_SetPNPayloadHighFilter2/44 (FlexCAN_SetPNPayloadHighFilter2) @062181c0
  Type: function definition analyzed
  Visibility: prevailing_def_ironly
  References: 
  Referring: 
  Availability: local
  Function flags: count:1073741824 (estimated locally) body local optimize_size
  Called by: FlexCAN_ConfigPN/86 (283645176 (estimated locally),0.26 per call) 
  Calls: 
FlexCAN_SetPNPayloadLowFilter1/43 (FlexCAN_SetPNPayloadLowFilter1) @06216b60
  Type: function definition analyzed
  Visibility: prevailing_def_ironly
  References: 
  Referring: 
  Availability: local
  Function flags: count:1073741824 (estimated locally) body local optimize_size
  Called by: FlexCAN_ConfigPN/86 (508506948 (estimated locally),0.47 per call) 
  Calls: 
FlexCAN_SetPNPayloadHighFilter1/42 (FlexCAN_SetPNPayloadHighFilter1) @06216540
  Type: function definition analyzed
  Visibility: prevailing_def_ironly
  References: 
  Referring: 
  Availability: local
  Function flags: count:1073741824 (estimated locally) body local optimize_size
  Called by: FlexCAN_ConfigPN/86 (508506948 (estimated locally),0.47 per call) 
  Calls: 
FlexCAN_SetPNDlcFilter/41 (FlexCAN_SetPNDlcFilter) @0620fee0
  Type: function definition analyzed
  Visibility: prevailing_def_ironly
  References: 
  Referring: 
  Availability: local
  Function flags: count:1073741824 (estimated locally) body local optimize_size
  Called by: FlexCAN_ConfigPN/86 (508506948 (estimated locally),0.47 per call) 
  Calls: 
FlexCAN_SetPNIdFilter2/40 (FlexCAN_SetPNIdFilter2) @0620fa80
  Type: function definition analyzed
  Visibility: prevailing_def_ironly
  References: 
  Referring: 
  Availability: local
  Function flags: count:1073741824 (estimated locally) body local optimize_size
  Called by: FlexCAN_ConfigPN/86 (598933190 (estimated locally),0.56 per call) 
  Calls: 
FlexCAN_SetPNFilteringSelection/36 (FlexCAN_SetPNFilteringSelection) @06209d20
  Type: function definition analyzed
  Visibility: prevailing_def_ironly
  References: 
  Referring: 
  Availability: local
  Function flags: count:1073741824 (estimated locally) body local optimize_size
  Called by: FlexCAN_ConfigPN/86 (1073741823 (estimated locally),1.00 per call) 
  Calls: 
FlexCAN_ComputePayloadSize.part.0 (uint8 dlcValue)
{
  uint8 ret;
  unsigned char _2;
  unsigned char _4;

  <bb 6> [local count: 1073741824]:

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  _2 = dlcValue_1(D) + 247;
  if (_2 <= 6)
    goto <bb 4>; [50.00%]
  else
    goto <bb 3>; [50.00%]

  <bb 3> [local count: 536870913]:
<L0>:
  ret_3 = 8;
  goto <bb 5>; [100.00%]

  <bb 4> [local count: 536870913]:
<L1>:
  _4 = CSWTCH.51[_2];
  ret_5 = _4;

  <bb 5> [local count: 1073741824]:
  # ret_6 = PHI <ret_3(3), ret_5(4)>
<L2>:
<L3>:
  # DEBUG ret => ret_6
  # DEBUG BEGIN_STMT
  return ret_6;

}


FlexCAN_SetPNIdFilter1.isra.0 (struct FLEXCAN_Type * pBase, unsigned char ISRA.39, boolean ISRA.40, uint32 ISRA.41)
{
  uint32 u32Tmp;
  unsigned char idFilter;
  long unsigned int idFilter$u32Id;
  _Bool _6;
  long unsigned int iftmp.21_7;
  _Bool _9;
  long unsigned int iftmp.22_10;
  long unsigned int _12;
  long unsigned int _14;
  long unsigned int _15;

  <bb 10> [local count: 1073741824]:

  <bb 2> [local count: 1073741824]:
  idFilter_1 = ISRA.39_20(D);
  # DEBUG idFilter => idFilter_1
  idFilter$u32Id_2 = ISRA.41_21(D);
  # DEBUG idFilter$u32Id => idFilter$u32Id_2
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  u32Tmp_4 ={v} pBase_3(D)->FLT_ID1;
  # DEBUG u32Tmp => u32Tmp_4
  # DEBUG BEGIN_STMT
  u32Tmp_5 = u32Tmp_4 & 2147483648;
  # DEBUG u32Tmp => u32Tmp_5
  # DEBUG BEGIN_STMT
  _6 = VIEW_CONVERT_EXPR<_Bool>(idFilter_1);
  if (_6 != 0)
    goto <bb 4>; [50.00%]
  else
    goto <bb 3>; [50.00%]

  <bb 3> [local count: 536870913]:

  <bb 4> [local count: 1073741824]:
  # iftmp.21_7 = PHI <1073741824(2), 0(3)>
  u32Tmp_8 = u32Tmp_5 | iftmp.21_7;
  # DEBUG u32Tmp => u32Tmp_8
  # DEBUG BEGIN_STMT
  _9 = ISRA.40_22(D);
  if (_9 != 0)
    goto <bb 6>; [50.00%]
  else
    goto <bb 5>; [50.00%]

  <bb 5> [local count: 536870913]:

  <bb 6> [local count: 1073741824]:
  # iftmp.22_10 = PHI <536870912(4), 0(5)>
  u32Tmp_11 = u32Tmp_8 | iftmp.22_10;
  # DEBUG u32Tmp => u32Tmp_11
  # DEBUG BEGIN_STMT
  if (_6 != 0)
    goto <bb 7>; [50.00%]
  else
    goto <bb 8>; [50.00%]

  <bb 7> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  _12 = idFilter$u32Id_2 & 536870911;
  u32Tmp_13 = u32Tmp_11 | _12;
  # DEBUG u32Tmp => u32Tmp_13
  goto <bb 9>; [100.00%]

  <bb 8> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  _14 = idFilter$u32Id_2 << 18;
  _15 = _14 & 536870911;
  u32Tmp_16 = u32Tmp_11 | _15;
  # DEBUG u32Tmp => u32Tmp_16

  <bb 9> [local count: 1073741824]:
  # u32Tmp_17 = PHI <u32Tmp_13(7), u32Tmp_16(8)>
  # DEBUG u32Tmp => u32Tmp_17
  # DEBUG BEGIN_STMT
  pBase_3(D)->FLT_ID1 ={v} u32Tmp_17;
  return;

}


FlexCAN_ConfigPN (struct FLEXCAN_Type * pBase, const struct Flexcan_Ip_PnConfigType * pPnConfig)
{
  short unsigned int _1;
  <unnamed type> _2;
  <unnamed type> _3;
  unsigned char _4;
  unsigned char _5;
  const uint8[8] * _6;
  <unnamed type> _7;
  const uint8[8] * _8;
  unsigned char _22;
  _Bool _23;
  long unsigned int _24;
  long unsigned int _25;
  long unsigned int _26;
  long unsigned int _27;
  long unsigned int _28;
  long unsigned int _29;
  long unsigned int _30;

  <bb 2> [local count: 1073741823]:
  # DEBUG BEGIN_STMT
  FlexCAN_SetPNFilteringSelection (pBase_12(D), pPnConfig_13(D));
  # DEBUG BEGIN_STMT
  _1 = pPnConfig_13(D)->u16MatchTimeout;
  # DEBUG pBase => pBase_12(D)
  # DEBUG u16TimeoutValue => _1
  # DEBUG INLINE_ENTRY FlexCAN_SetPNTimeoutValue
  # DEBUG BEGIN_STMT
  _25 ={v} pBase_12(D)->CTRL2_PN;
  _26 = _25 & 4294901760;
  _27 = (long unsigned int) _1;
  _28 = _26 | _27;
  pBase_12(D)->CTRL2_PN ={v} _28;
  # DEBUG pBase => NULL
  # DEBUG u16TimeoutValue => NULL
  # DEBUG BEGIN_STMT
  _22 = MEM[(const struct Flexcan_Ip_PnConfigType *)pPnConfig_13(D) + 12B];
  # DEBUG D#1 => pPnConfig_13(D)->idFilter1
  _23 = MEM[(const struct Flexcan_Ip_PnConfigType *)pPnConfig_13(D) + 13B];
  # DEBUG D#1 => pPnConfig_13(D)->idFilter1
  _24 = MEM[(const struct Flexcan_Ip_PnConfigType *)pPnConfig_13(D) + 16B];
  # DEBUG D#1 => pPnConfig_13(D)->idFilter1
  FlexCAN_SetPNIdFilter1.isra.0 (pBase_12(D), _22, _23, _24);
  # DEBUG BEGIN_STMT
  _2 = pPnConfig_13(D)->eIdFilterType;
  if (_2 == 0)
    goto <bb 4>; [33.00%]
  else
    goto <bb 3>; [67.00%]

  <bb 3> [local count: 719407022]:
  if (_2 == 3)
    goto <bb 4>; [34.00%]
  else
    goto <bb 5>; [66.00%]

  <bb 4> [local count: 598933190]:
  # DEBUG BEGIN_STMT
  FlexCAN_SetPNIdFilter2 (pBase_12(D), pPnConfig_13(D));
  goto <bb 6>; [100.00%]

  <bb 5> [local count: 474808634]:
  # DEBUG BEGIN_STMT
  # DEBUG pBase => pBase_12(D)
  # DEBUG INLINE_ENTRY FlexCAN_SetPNIdFilter2Check
  # DEBUG BEGIN_STMT
  _29 ={v} pBase_12(D)->FLT_ID2_IDMASK;
  _30 = _29 | 1610612736;
  pBase_12(D)->FLT_ID2_IDMASK ={v} _30;

  <bb 6> [local count: 1073741824]:
  # DEBUG pBase => NULL
  # DEBUG BEGIN_STMT
  _3 = pPnConfig_13(D)->eFilterComb;
  if (_3 == 1)
    goto <bb 8>; [20.24%]
  else
    goto <bb 7>; [79.76%]

  <bb 7> [local count: 856416479]:
  if (_3 == 3)
    goto <bb 8>; [34.00%]
  else
    goto <bb 11>; [66.00%]

  <bb 8> [local count: 508506948]:
  # DEBUG BEGIN_STMT
  _4 = pPnConfig_13(D)->payloadFilter.u8DlcLow;
  _5 = pPnConfig_13(D)->payloadFilter.u8DlcHigh;
  FlexCAN_SetPNDlcFilter (pBase_12(D), _4, _5);
  # DEBUG BEGIN_STMT
  _6 = &pPnConfig_13(D)->payloadFilter.aPayload1;
  FlexCAN_SetPNPayloadHighFilter1 (pBase_12(D), _6);
  # DEBUG BEGIN_STMT
  FlexCAN_SetPNPayloadLowFilter1 (pBase_12(D), _6);
  # DEBUG BEGIN_STMT
  _7 = pPnConfig_13(D)->ePayloadFilterType;
  if (_7 == 0)
    goto <bb 10>; [33.00%]
  else
    goto <bb 9>; [67.00%]

  <bb 9> [local count: 340699655]:
  if (_7 == 3)
    goto <bb 10>; [34.00%]
  else
    goto <bb 11>; [66.00%]

  <bb 10> [local count: 283645176]:
  # DEBUG BEGIN_STMT
  _8 = &pPnConfig_13(D)->payloadFilter.aPayload2;
  FlexCAN_SetPNPayloadHighFilter2 (pBase_12(D), _8);
  # DEBUG BEGIN_STMT
  FlexCAN_SetPNPayloadLowFilter2 (pBase_12(D), _8);

  <bb 11> [local count: 1073741824]:
  return;

}


FlexCAN_ConfigCtrlOptions (struct FLEXCAN_Type * pBase, uint32 u32Options)
{
  long unsigned int _1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  long unsigned int _8;
  long unsigned int _9;
  long unsigned int _20;
  long unsigned int _21;
  long unsigned int _22;
  long unsigned int _23;
  long unsigned int _24;
  long unsigned int _25;
  long unsigned int _26;
  long unsigned int _27;
  long unsigned int _28;
  long unsigned int _29;
  long unsigned int _30;
  long unsigned int _31;
  long unsigned int _32;
  long unsigned int _33;
  long unsigned int _34;
  long unsigned int _35;
  long unsigned int _36;
  long unsigned int _37;
  long unsigned int _38;
  long unsigned int _39;
  long unsigned int _40;
  long unsigned int _41;
  long unsigned int _42;
  long unsigned int _43;
  long unsigned int _44;
  long unsigned int _45;
  long unsigned int _46;
  long unsigned int _47;
  long unsigned int _48;
  long unsigned int _49;
  long unsigned int _50;
  long unsigned int _51;
  long unsigned int _52;
  long unsigned int _53;
  long unsigned int _54;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  _1 = u32Options_17(D) & 32;
  if (_1 != 0)
    goto <bb 3>; [50.00%]
  else
    goto <bb 4>; [50.00%]

  <bb 3> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 1
  # DEBUG INLINE_ENTRY FlexCAN_SetIsoCan
  # DEBUG BEGIN_STMT
  _20 ={v} pBase_19(D)->CTRL2;
  _21 = _20 & 4294963199;
  _22 = _21 | 4096;
  pBase_19(D)->CTRL2 ={v} _22;
  goto <bb 5>; [100.00%]

  <bb 4> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 0
  # DEBUG INLINE_ENTRY FlexCAN_SetIsoCan
  # DEBUG BEGIN_STMT
  _23 ={v} pBase_19(D)->CTRL2;
  _24 = _23 & 4294963199;
  pBase_19(D)->CTRL2 ={v} _24;

  <bb 5> [local count: 1073741824]:
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG BEGIN_STMT
  _2 = u32Options_17(D) & 64;
  if (_2 != 0)
    goto <bb 6>; [50.00%]
  else
    goto <bb 7>; [50.00%]

  <bb 6> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 1
  # DEBUG INLINE_ENTRY FlexCAN_SetEntireFrameArbitrationFieldComparison
  # DEBUG BEGIN_STMT
  _25 ={v} pBase_19(D)->CTRL2;
  _26 = _25 & 4294901759;
  _27 = _26 | 65536;
  pBase_19(D)->CTRL2 ={v} _27;
  goto <bb 8>; [100.00%]

  <bb 7> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 0
  # DEBUG INLINE_ENTRY FlexCAN_SetEntireFrameArbitrationFieldComparison
  # DEBUG BEGIN_STMT
  _28 ={v} pBase_19(D)->CTRL2;
  _29 = _28 & 4294901759;
  pBase_19(D)->CTRL2 ={v} _29;

  <bb 8> [local count: 1073741824]:
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG BEGIN_STMT
  _3 = u32Options_17(D) & 8;
  if (_3 != 0)
    goto <bb 9>; [50.00%]
  else
    goto <bb 10>; [50.00%]

  <bb 9> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 1
  # DEBUG INLINE_ENTRY FlexCAN_SetProtocolException
  # DEBUG BEGIN_STMT
  _30 ={v} pBase_19(D)->CTRL2;
  _31 = _30 & 4294950911;
  _32 = _31 | 16384;
  pBase_19(D)->CTRL2 ={v} _32;
  goto <bb 11>; [100.00%]

  <bb 10> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 0
  # DEBUG INLINE_ENTRY FlexCAN_SetProtocolException
  # DEBUG BEGIN_STMT
  _33 ={v} pBase_19(D)->CTRL2;
  _34 = _33 & 4294950911;
  pBase_19(D)->CTRL2 ={v} _34;

  <bb 11> [local count: 1073741824]:
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG BEGIN_STMT
  _4 = u32Options_17(D) & 2;
  if (_4 != 0)
    goto <bb 12>; [50.00%]
  else
    goto <bb 14>; [50.00%]

  <bb 12> [local count: 536870913]:
  _5 ={v} pBase_19(D)->MCR;
  _6 = _5 & 2048;
  if (_6 == 0)
    goto <bb 13>; [50.00%]
  else
    goto <bb 14>; [50.00%]

  <bb 13> [local count: 268435456]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 1
  # DEBUG INLINE_ENTRY FlexCAN_CanBitSampling
  # DEBUG BEGIN_STMT
  _35 ={v} pBase_19(D)->CTRL1;
  _36 = _35 & 4294967167;
  _37 = _36 | 128;
  pBase_19(D)->CTRL1 ={v} _37;
  goto <bb 15>; [100.00%]

  <bb 14> [local count: 805306369]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 0
  # DEBUG INLINE_ENTRY FlexCAN_CanBitSampling
  # DEBUG BEGIN_STMT
  _38 ={v} pBase_19(D)->CTRL1;
  _39 = _38 & 4294967167;
  pBase_19(D)->CTRL1 ={v} _39;

  <bb 15> [local count: 1073741824]:
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG BEGIN_STMT
  _7 = u32Options_17(D) & 4;
  if (_7 != 0)
    goto <bb 16>; [50.00%]
  else
    goto <bb 17>; [50.00%]

  <bb 16> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 1
  # DEBUG INLINE_ENTRY FlexCAN_SetBusOffAutorecovery
  # DEBUG BEGIN_STMT
  _40 ={v} pBase_19(D)->CTRL1;
  _41 = _40 & 4294967231;
  pBase_19(D)->CTRL1 ={v} _41;
  goto <bb 18>; [100.00%]

  <bb 17> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 0
  # DEBUG INLINE_ENTRY FlexCAN_SetBusOffAutorecovery
  # DEBUG BEGIN_STMT
  _42 ={v} pBase_19(D)->CTRL1;
  _43 = _42 & 4294967231;
  _44 = _43 | 64;
  pBase_19(D)->CTRL1 ={v} _44;

  <bb 18> [local count: 1073741824]:
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG BEGIN_STMT
  _8 = u32Options_17(D) & 1;
  if (_8 != 0)
    goto <bb 19>; [50.00%]
  else
    goto <bb 20>; [50.00%]

  <bb 19> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 1
  # DEBUG INLINE_ENTRY FlexCAN_SetRemoteReqStore
  # DEBUG BEGIN_STMT
  _45 ={v} pBase_19(D)->CTRL2;
  _46 = _45 & 4294836223;
  _47 = _46 | 131072;
  pBase_19(D)->CTRL2 ={v} _47;
  goto <bb 21>; [100.00%]

  <bb 20> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 0
  # DEBUG INLINE_ENTRY FlexCAN_SetRemoteReqStore
  # DEBUG BEGIN_STMT
  _48 ={v} pBase_19(D)->CTRL2;
  _49 = _48 & 4294836223;
  pBase_19(D)->CTRL2 ={v} _49;

  <bb 21> [local count: 1073741824]:
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG BEGIN_STMT
  _9 = u32Options_17(D) & 16;
  if (_9 != 0)
    goto <bb 22>; [50.00%]
  else
    goto <bb 23>; [50.00%]

  <bb 22> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 1
  # DEBUG INLINE_ENTRY FlexCAN_SetEdgeFilter
  # DEBUG BEGIN_STMT
  _50 ={v} pBase_19(D)->CTRL2;
  _51 = _50 & 4294965247;
  pBase_19(D)->CTRL2 ={v} _51;
  goto <bb 24>; [100.00%]

  <bb 23> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  # DEBUG base => pBase_19(D)
  # DEBUG enable => 0
  # DEBUG INLINE_ENTRY FlexCAN_SetEdgeFilter
  # DEBUG BEGIN_STMT
  _52 ={v} pBase_19(D)->CTRL2;
  _53 = _52 & 4294965247;
  _54 = _53 | 2048;
  pBase_19(D)->CTRL2 ={v} _54;

  <bb 24> [local count: 1073741824]:
  # DEBUG base => NULL
  # DEBUG enable => NULL
  # DEBUG base => NULL
  # DEBUG enable => NULL
  return;

}


FlexCAN_IsMbOutOfRange (const struct FLEXCAN_Type * pBase, uint8 u8MbIndex, boolean bIsLegacyFifoEn, uint32 u32MaxMbNum)
{
  uint32 u32NumOfMbOccupiedByFiFo;
  uint32 u32NumOfFiFoElement;
  boolean ReturnValue;
  unsigned char _1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  # DEBUG ReturnValue => 0
  # DEBUG BEGIN_STMT
  # DEBUG u32NumOfFiFoElement => 0
  # DEBUG BEGIN_STMT
  # DEBUG u32NumOfMbOccupiedByFiFo => 0
  # DEBUG BEGIN_STMT
  _1 = (unsigned char) u32MaxMbNum_9(D);
  if (_1 <= u8MbIndex_10(D))
    goto <bb 6>; [50.00%]
  else
    goto <bb 3>; [50.00%]

  <bb 3> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  if (bIsLegacyFifoEn_11(D) != 0)
    goto <bb 4>; [50.00%]
  else
    goto <bb 6>; [50.00%]

  <bb 4> [local count: 268435456]:
  # DEBUG BEGIN_STMT
  _2 ={v} pBase_13(D)->CTRL2;
  _3 = _2 >> 24;
  u32NumOfFiFoElement_14 = _3 & 15;
  # DEBUG u32NumOfFiFoElement => u32NumOfFiFoElement_14
  # DEBUG BEGIN_STMT
  _4 = u32NumOfFiFoElement_14 + 1;
  _5 = _4 * 8;
  _6 = _5 >> 2;
  u32NumOfMbOccupiedByFiFo_15 = _6 + 5;
  # DEBUG u32NumOfMbOccupiedByFiFo => u32NumOfMbOccupiedByFiFo_15
  # DEBUG BEGIN_STMT
  _7 = (long unsigned int) u8MbIndex_10(D);
  if (_7 <= u32NumOfMbOccupiedByFiFo_15)
    goto <bb 5>; [50.00%]
  else
    goto <bb 6>; [50.00%]

  <bb 5> [local count: 134217728]:
  # DEBUG BEGIN_STMT
  # DEBUG ReturnValue => 1

  <bb 6> [local count: 1073741824]:
  # ReturnValue_8 = PHI <1(2), 1(5), 0(3), 0(4)>
  # DEBUG ReturnValue => ReturnValue_8
  # DEBUG BEGIN_STMT
  return ReturnValue_8;

}


FlexCAN_ReadRxFifo (const struct FLEXCAN_Type * base, struct Flexcan_Ip_MsgBuffType * rxFifo)
{
  uint8 can_real_payload;
  uint8 flexcan_mb_dlc_value;
  uint32 * msgData_32;
  const uint32 * flexcan_mb;
  uint32 MbWord;
  uint32 DataByte;
  long unsigned int base.11_1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  unsigned char _5;
  long unsigned int _6;
  long unsigned int _7;
  long unsigned int _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _11;
  unsigned char _12;
  long unsigned int _13;
  long unsigned int _14;
  long unsigned int _15;
  const uint32 * _16;
  long unsigned int _17;
  long unsigned int _18;
  long unsigned int _19;
  long unsigned int _20;
  long unsigned int _21;
  long unsigned int _22;
  long unsigned int _23;
  long unsigned int _24;
  uint32 * _25;
  long unsigned int _26;
  long unsigned int _27;
  sizetype _39;

  <bb 2> [local count: 118111600]:
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  base.11_1 = (long unsigned int) base_31(D);
  _2 = base.11_1 + 128;
  flexcan_mb_32 = (const uint32 *) _2;
  # DEBUG flexcan_mb => flexcan_mb_32
  # DEBUG BEGIN_STMT
  # DEBUG flexcan_mb_id => flexcan_mb_32 + 4
  # DEBUG BEGIN_STMT
  # DEBUG flexcan_mb_data_32 => flexcan_mb_32 + 8
  # DEBUG BEGIN_STMT
  msgData_32_35 = &rxFifo_34(D)->data;
  # DEBUG msgData_32 => msgData_32_35
  # DEBUG BEGIN_STMT
  _3 ={v} *flexcan_mb_32;
  _4 = _3 >> 16;
  _5 = (unsigned char) _4;
  flexcan_mb_dlc_value_37 = _5 & 15;
  # DEBUG flexcan_mb_dlc_value => flexcan_mb_dlc_value_37
  # DEBUG BEGIN_STMT
  can_real_payload_38 = FlexCAN_ComputePayloadSize (flexcan_mb_dlc_value_37);
  # DEBUG can_real_payload => can_real_payload_38
  # DEBUG BEGIN_STMT
  can_real_payload_33 = MIN_EXPR <8, can_real_payload_38>;
  # DEBUG can_real_payload => can_real_payload_33
  # DEBUG BEGIN_STMT
  rxFifo_34(D)->dataLen = can_real_payload_33;
  # DEBUG BEGIN_STMT
  _6 ={v} *flexcan_mb_32;
  rxFifo_34(D)->cs = _6;
  # DEBUG BEGIN_STMT
  _7 = _6 & 2097152;
  if (_7 != 0)
    goto <bb 3>; [50.00%]
  else
    goto <bb 4>; [50.00%]

  <bb 3> [local count: 59055800]:
  # DEBUG BEGIN_STMT
  _8 ={v} MEM[(const uint32 *)flexcan_mb_32 + 4B];
  rxFifo_34(D)->msgId = _8;
  goto <bb 5>; [100.00%]

  <bb 4> [local count: 59055800]:
  # DEBUG BEGIN_STMT
  _9 ={v} MEM[(const uint32 *)flexcan_mb_32 + 4B];
  _10 = _9 >> 18;
  rxFifo_34(D)->msgId = _10;

  <bb 5> [local count: 118111600]:
  # DEBUG BEGIN_STMT
  _11 ={v} base_31(D)->RXFIR;
  _12 = (unsigned char) _11;
  rxFifo_34(D)->id_hit = _12;
  # DEBUG BEGIN_STMT
  _13 = _6 & 65535;
  rxFifo_34(D)->time_stamp = _13;
  # DEBUG BEGIN_STMT
  # DEBUG DataByte => 0
  goto <bb 7>; [100.00%]

  <bb 6> [local count: 955630223]:
  # DEBUG BEGIN_STMT
  _14 = DataByte_28 >> 2;
  _15 = _14 * 4;
  _39 = _15 + 8;
  _16 = flexcan_mb_32 + _39;
  MbWord_46 ={v} *_16;
  # DEBUG MbWord => MbWord_46
  # DEBUG BEGIN_STMT
  _17 = MbWord_46 >> 24;
  _18 = MbWord_46 >> 8;
  _19 = _18 & 65280;
  _20 = _17 | _19;
  _21 = MbWord_46 << 8;
  _22 = _21 & 16711680;
  _23 = _20 | _22;
  _24 = MbWord_46 << 24;
  _25 = msgData_32_35 + _15;
  _26 = _23 | _24;
  *_25 = _26;
  # DEBUG BEGIN_STMT
  DataByte_48 = DataByte_28 + 4;
  # DEBUG DataByte => DataByte_48

  <bb 7> [local count: 1073741824]:
  # DataByte_28 = PHI <0(5), DataByte_48(6)>
  # DEBUG DataByte => DataByte_28
  # DEBUG BEGIN_STMT
  _27 = (long unsigned int) can_real_payload_33;
  if (_27 > DataByte_28)
    goto <bb 6>; [89.00%]
  else
    goto <bb 8>; [11.00%]

  <bb 8> [local count: 118111601]:
  return;

}


FlexCAN_SetRxFifoFilter (struct FLEXCAN_Type * base, Flexcan_Ip_RxFifoIdElementFormatType idFormat, const struct Flexcan_Ip_IdTableType * idFilterTable)
{
  volatile uint32 * FilterTable;
  uint32 Val;
  uint32 Val2;
  uint32 Val1;
  uint32 NumOfFilters;
  uint32 j;
  uint32 i;
  long unsigned int base.10_1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  const struct Flexcan_Ip_IdTableType * _8;
  _Bool _9;
  _Bool _10;
  long unsigned int _11;
  long unsigned int _12;
  long unsigned int _13;
  long unsigned int _14;
  volatile uint32 * _15;
  long unsigned int _16;
  long unsigned int _17;
  long unsigned int _18;
  long unsigned int _19;
  long unsigned int _20;
  volatile uint32 * _21;
  long unsigned int _22;
  long unsigned int _23;
  long unsigned int _24;
  long unsigned int _25;
  long unsigned int _26;
  long unsigned int _27;
  long unsigned int _28;
  const struct Flexcan_Ip_IdTableType * _29;
  _Bool _30;
  sizetype _31;
  sizetype _32;
  const struct Flexcan_Ip_IdTableType * _33;
  _Bool _34;
  _Bool _35;
  long unsigned int _36;
  long unsigned int _37;
  long unsigned int _38;
  long unsigned int _39;
  long unsigned int _40;
  volatile uint32 * _41;
  long unsigned int _42;
  long unsigned int _43;
  long unsigned int _44;
  long unsigned int _45;
  long unsigned int _46;
  volatile uint32 * _47;
  long unsigned int _48;
  _Bool _49;
  long unsigned int _50;
  volatile uint32 * _51;
  long unsigned int _52;
  long unsigned int _53;
  long unsigned int _54;
  long unsigned int _55;
  long unsigned int _56;
  long unsigned int _57;
  long unsigned int _58;
  volatile uint32 * _59;
  long unsigned int _60;
  long unsigned int _61;
  long unsigned int _62;
  long unsigned int _63;
  long unsigned int _64;
  long unsigned int _65;
  long unsigned int _66;
  long unsigned int _67;
  long unsigned int _68;
  long unsigned int _69;
  long unsigned int _70;
  long unsigned int _71;
  const struct Flexcan_Ip_IdTableType * _72;
  _Bool _73;
  long unsigned int _74;
  long unsigned int _75;
  long unsigned int _76;
  long unsigned int _77;
  volatile uint32 * _78;
  long unsigned int _79;
  long unsigned int _80;
  long unsigned int _81;
  long unsigned int _82;
  volatile uint32 * _83;
  sizetype _84;
  sizetype _85;
  const struct Flexcan_Ip_IdTableType * _86;
  _Bool _87;
  long unsigned int _88;
  volatile uint32 * _89;
  long unsigned int _90;
  long unsigned int _91;
  long unsigned int _92;
  long unsigned int _93;
  long unsigned int _94;
  long unsigned int _95;
  long unsigned int _96;
  volatile uint32 * _97;
  long unsigned int _98;
  long unsigned int _99;
  long unsigned int _100;
  long unsigned int _101;
  long unsigned int _102;
  long unsigned int _103;
  sizetype _104;
  sizetype _105;
  const struct Flexcan_Ip_IdTableType * _106;
  _Bool _107;
  long unsigned int _108;
  volatile uint32 * _109;
  long unsigned int _110;
  long unsigned int _111;
  long unsigned int _112;
  long unsigned int _113;
  long unsigned int _114;
  long unsigned int _115;
  long unsigned int _116;
  volatile uint32 * _117;
  long unsigned int _118;
  long unsigned int _119;
  long unsigned int _120;
  long unsigned int _121;
  long unsigned int _122;
  long unsigned int _123;
  sizetype _124;
  sizetype _125;
  const struct Flexcan_Ip_IdTableType * _126;
  _Bool _127;
  long unsigned int _128;
  volatile uint32 * _129;
  long unsigned int _130;
  long unsigned int _131;
  long unsigned int _132;
  long unsigned int _133;
  long unsigned int _134;
  long unsigned int _135;
  volatile uint32 * _136;
  long unsigned int _137;
  long unsigned int _138;
  long unsigned int _139;
  long unsigned int _140;
  long unsigned int _141;
  long unsigned int _142;
  long unsigned int _143;
  long unsigned int _144;
  long unsigned int _145;

  <bb 2> [local count: 590558001]:
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG Val1 => 0
  # DEBUG Val2 => 0
  # DEBUG Val => 0
  # DEBUG BEGIN_STMT
  base.10_1 = (long unsigned int) base_165(D);
  _2 = base.10_1 + 224;
  FilterTable_166 = (volatile uint32 *) _2;
  # DEBUG FilterTable => FilterTable_166
  # DEBUG BEGIN_STMT
  _3 ={v} base_165(D)->CTRL2;
  _4 = _3 >> 24;
  NumOfFilters_168 = _4 & 15;
  # DEBUG NumOfFilters => NumOfFilters_168
  # DEBUG BEGIN_STMT
  switch (idFormat_169(D)) <default: <L42> [20.00%], case 0: <L0> [20.00%], case 1: <L9> [20.00%], case 2: <L23> [20.00%], case 3: <L39> [20.00%]>

  <bb 3> [local count: 118111600]:
<L0>:
  # DEBUG BEGIN_STMT
  SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13 ();
  # DEBUG BEGIN_STMT
  _5 ={v} base_165(D)->MCR;
  _6 = _5 & 4294966527;
  base_165(D)->MCR ={v} _6;
  # DEBUG BEGIN_STMT
  SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13 ();
  # DEBUG BEGIN_STMT
  # DEBUG i => 0
  goto <bb 10>; [100.00%]

  <bb 4> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  # DEBUG Val => 0
  # DEBUG BEGIN_STMT
  _7 = i_146 * 8;
  _8 = idFilterTable_176(D) + _7;
  _9 = _8->isRemoteFrame;
  if (_9 != 0)
    goto <bb 5>; [50.00%]
  else
    goto <bb 6>; [50.00%]

  <bb 5> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  # DEBUG Val => 2147483648

  <bb 6> [local count: 955630224]:
  # Val_153 = PHI <0(4), 2147483648(5)>
  # DEBUG Val => Val_153
  # DEBUG BEGIN_STMT
  _10 = _8->isExtendedFrame;
  if (_10 != 0)
    goto <bb 7>; [50.00%]
  else
    goto <bb 8>; [50.00%]

  <bb 7> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  Val_202 = Val_153 | 1073741824;
  # DEBUG Val => Val_202
  # DEBUG BEGIN_STMT
  _11 = _8->id;
  _12 = _11 << 1;
  _13 = _12 & 1073741823;
  _14 = i_146 * 4;
  _15 = FilterTable_166 + _14;
  _16 = _13 + Val_202;
  *_15 ={v} _16;
  goto <bb 9>; [100.00%]

  <bb 8> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  _17 = _8->id;
  _18 = _17 << 19;
  _19 = _18 & 1073217536;
  _20 = i_146 * 4;
  _21 = FilterTable_166 + _20;
  _22 = _19 + Val_153;
  *_21 ={v} _22;

  <bb 9> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  i_204 = i_146 + 1;
  # DEBUG i => i_204

  <bb 10> [local count: 1073741824]:
  # i_146 = PHI <0(3), i_204(9)>
  # DEBUG i => i_146
  # DEBUG BEGIN_STMT
  _23 = NumOfFilters_168 + 1;
  _24 = _23 * 8;
  if (_24 > i_146)
    goto <bb 4>; [89.00%]
  else
    goto <bb 40>; [11.00%]

  <bb 11> [local count: 118111600]:
<L9>:
  # DEBUG BEGIN_STMT
  SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13 ();
  # DEBUG BEGIN_STMT
  _25 ={v} base_165(D)->MCR;
  _26 = _25 & 4294966527;
  _27 = _26 | 256;
  base_165(D)->MCR ={v} _27;
  # DEBUG BEGIN_STMT
  SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13 ();
  # DEBUG BEGIN_STMT
  # DEBUG j => 0
  # DEBUG BEGIN_STMT
  # DEBUG i => 0
  goto <bb 23>; [100.00%]

  <bb 12> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  # DEBUG Val1 => 0
  # DEBUG BEGIN_STMT
  # DEBUG Val2 => 0
  # DEBUG BEGIN_STMT
  _28 = j_149 * 8;
  _29 = idFilterTable_176(D) + _28;
  _30 = _29->isRemoteFrame;
  if (_30 != 0)
    goto <bb 13>; [50.00%]
  else
    goto <bb 14>; [50.00%]

  <bb 13> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  # DEBUG Val1 => 2147483648

  <bb 14> [local count: 955630224]:
  # Val1_151 = PHI <0(12), 2147483648(13)>
  # DEBUG Val1 => Val1_151
  # DEBUG BEGIN_STMT
  _31 = j_149 + 1;
  _32 = _31 * 8;
  _33 = idFilterTable_176(D) + _32;
  _34 = _33->isRemoteFrame;
  if (_34 != 0)
    goto <bb 15>; [50.00%]
  else
    goto <bb 16>; [50.00%]

  <bb 15> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  # DEBUG Val2 => 32768

  <bb 16> [local count: 955630224]:
  # Val2_152 = PHI <0(14), 32768(15)>
  # DEBUG Val2 => Val2_152
  # DEBUG BEGIN_STMT
  _35 = _29->isExtendedFrame;
  if (_35 != 0)
    goto <bb 17>; [50.00%]
  else
    goto <bb 18>; [50.00%]

  <bb 17> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  Val1_191 = Val1_151 | 1073741824;
  # DEBUG Val1 => Val1_191
  # DEBUG BEGIN_STMT
  _36 = _29->id;
  _37 = _36 >> 15;
  _38 = _37 << 16;
  _39 = _38 & 1073676288;
  _40 = i_147 * 4;
  _41 = FilterTable_166 + _40;
  _42 = _39 + Val1_191;
  *_41 ={v} _42;
  goto <bb 19>; [100.00%]

  <bb 18> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  _43 = _29->id;
  _44 = _43 << 19;
  _45 = _44 & 1073217536;
  _46 = i_147 * 4;
  _47 = FilterTable_166 + _46;
  _48 = _45 + Val1_151;
  *_47 ={v} _48;

  <bb 19> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  _49 = _33->isExtendedFrame;
  if (_49 != 0)
    goto <bb 20>; [50.00%]
  else
    goto <bb 21>; [50.00%]

  <bb 20> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  Val2_194 = Val2_152 | 16384;
  # DEBUG Val2 => Val2_194
  # DEBUG BEGIN_STMT
  _50 = i_147 * 4;
  _51 = FilterTable_166 + _50;
  _52 ={v} *_51;
  _53 = _33->id;
  _54 = _53 >> 15;
  _55 = _54 & 16383;
  _56 = _55 + Val2_194;
  _57 = _52 | _56;
  *_51 ={v} _57;
  goto <bb 22>; [100.00%]

  <bb 21> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  _58 = i_147 * 4;
  _59 = FilterTable_166 + _58;
  _60 ={v} *_59;
  _61 = _33->id;
  _62 = _61 << 3;
  _63 = _62 & 16376;
  _64 = _63 + Val2_152;
  _65 = _60 | _64;
  *_59 ={v} _65;

  <bb 22> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  j_196 = j_149 + 2;
  # DEBUG j => j_196
  # DEBUG BEGIN_STMT
  i_197 = i_147 + 1;
  # DEBUG i => i_197

  <bb 23> [local count: 1073741824]:
  # i_147 = PHI <0(11), i_197(22)>
  # j_149 = PHI <0(11), j_196(22)>
  # DEBUG j => j_149
  # DEBUG i => i_147
  # DEBUG BEGIN_STMT
  _66 = NumOfFilters_168 + 1;
  _67 = _66 * 8;
  if (_67 > i_147)
    goto <bb 12>; [89.00%]
  else
    goto <bb 40>; [11.00%]

  <bb 24> [local count: 118111600]:
<L23>:
  # DEBUG BEGIN_STMT
  SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13 ();
  # DEBUG BEGIN_STMT
  _68 ={v} base_165(D)->MCR;
  _69 = _68 & 4294966527;
  _70 = _69 | 512;
  base_165(D)->MCR ={v} _70;
  # DEBUG BEGIN_STMT
  SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13 ();
  # DEBUG BEGIN_STMT
  # DEBUG j => 0
  # DEBUG BEGIN_STMT
  # DEBUG i => 0
  goto <bb 38>; [100.00%]

  <bb 25> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  _71 = j_150 * 8;
  _72 = idFilterTable_176(D) + _71;
  _73 = _72->isExtendedFrame;
  if (_73 != 0)
    goto <bb 26>; [50.00%]
  else
    goto <bb 27>; [50.00%]

  <bb 26> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  _74 = _72->id;
  _75 = _74 >> 21;
  _76 = _75 << 24;
  _77 = i_148 * 4;
  _78 = FilterTable_166 + _77;
  *_78 ={v} _76;
  goto <bb 28>; [100.00%]

  <bb 27> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  _79 = _72->id;
  _80 = _79 >> 3;
  _81 = _80 << 24;
  _82 = i_148 * 4;
  _83 = FilterTable_166 + _82;
  *_83 ={v} _81;

  <bb 28> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  _84 = j_150 + 1;
  _85 = _84 * 8;
  _86 = idFilterTable_176(D) + _85;
  _87 = _86->isExtendedFrame;
  if (_87 != 0)
    goto <bb 29>; [50.00%]
  else
    goto <bb 30>; [50.00%]

  <bb 29> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  _88 = i_148 * 4;
  _89 = FilterTable_166 + _88;
  _90 ={v} *_89;
  _91 = _86->id;
  _92 = _91 >> 21;
  _93 = _92 << 16;
  _94 = _93 & 16711680;
  _95 = _90 | _94;
  *_89 ={v} _95;
  goto <bb 31>; [100.00%]

  <bb 30> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  _96 = i_148 * 4;
  _97 = FilterTable_166 + _96;
  _98 ={v} *_97;
  _99 = _86->id;
  _100 = _99 >> 3;
  _101 = _100 << 16;
  _102 = _101 & 16711680;
  _103 = _98 | _102;
  *_97 ={v} _103;

  <bb 31> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  _104 = j_150 + 2;
  _105 = _104 * 8;
  _106 = idFilterTable_176(D) + _105;
  _107 = _106->isExtendedFrame;
  if (_107 != 0)
    goto <bb 32>; [50.00%]
  else
    goto <bb 33>; [50.00%]

  <bb 32> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  _108 = i_148 * 4;
  _109 = FilterTable_166 + _108;
  _110 ={v} *_109;
  _111 = _106->id;
  _112 = _111 >> 21;
  _113 = _112 << 8;
  _114 = _113 & 65535;
  _115 = _110 | _114;
  *_109 ={v} _115;
  goto <bb 34>; [100.00%]

  <bb 33> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  _116 = i_148 * 4;
  _117 = FilterTable_166 + _116;
  _118 ={v} *_117;
  _119 = _106->id;
  _120 = _119 >> 3;
  _121 = _120 << 8;
  _122 = _121 & 65535;
  _123 = _118 | _122;
  *_117 ={v} _123;

  <bb 34> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  _124 = j_150 + 3;
  _125 = _124 * 8;
  _126 = idFilterTable_176(D) + _125;
  _127 = _126->isExtendedFrame;
  if (_127 != 0)
    goto <bb 35>; [50.00%]
  else
    goto <bb 36>; [50.00%]

  <bb 35> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  _128 = i_148 * 4;
  _129 = FilterTable_166 + _128;
  _130 ={v} *_129;
  _131 = _126->id;
  _132 = _131 >> 21;
  _133 = _132 & 255;
  _134 = _130 | _133;
  *_129 ={v} _134;
  goto <bb 37>; [100.00%]

  <bb 36> [local count: 477815112]:
  # DEBUG BEGIN_STMT
  _135 = i_148 * 4;
  _136 = FilterTable_166 + _135;
  _137 ={v} *_136;
  _138 = _126->id;
  _139 = _138 >> 3;
  _140 = _139 & 255;
  _141 = _137 | _140;
  *_136 ={v} _141;

  <bb 37> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  j_185 = j_150 + 4;
  # DEBUG j => j_185
  # DEBUG BEGIN_STMT
  i_186 = i_148 + 1;
  # DEBUG i => i_186

  <bb 38> [local count: 1073741824]:
  # i_148 = PHI <0(24), i_186(37)>
  # j_150 = PHI <0(24), j_185(37)>
  # DEBUG j => j_150
  # DEBUG i => i_148
  # DEBUG BEGIN_STMT
  _142 = NumOfFilters_168 + 1;
  _143 = _142 * 8;
  if (_143 > i_148)
    goto <bb 25>; [89.00%]
  else
    goto <bb 40>; [11.00%]

  <bb 39> [local count: 118111600]:
<L39>:
  # DEBUG BEGIN_STMT
  SchM_Enter_Can_CAN_EXCLUSIVE_AREA_13 ();
  # DEBUG BEGIN_STMT
  _144 ={v} base_165(D)->MCR;
  _145 = _144 | 768;
  base_165(D)->MCR ={v} _145;
  # DEBUG BEGIN_STMT
  SchM_Exit_Can_CAN_EXCLUSIVE_AREA_13 ();
  # DEBUG BEGIN_STMT

  <bb 40> [local count: 590558003]:
<L42>:
  return;

}


FlexCAN_SetOperationMode (struct FLEXCAN_Type * base, Flexcan_Ip_ModesType mode)
{
  long unsigned int _1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  long unsigned int _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _20;
  long unsigned int _21;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  switch (mode_12(D)) <default: <L5> [25.00%], case 0: <L0> [25.00%], case 1: <L1> [25.00%], case 2: <L2> [25.00%]>

  <bb 3> [local count: 268435456]:
<L0>:
  # DEBUG BEGIN_STMT
  _1 ={v} base_14(D)->CTRL1;
  _2 = _1 & 4294967287;
  base_14(D)->CTRL1 ={v} _2;
  # DEBUG BEGIN_STMT
  _3 ={v} base_14(D)->CTRL1;
  _4 = _3 & 4294963199;
  base_14(D)->CTRL1 ={v} _4;
  # DEBUG BEGIN_STMT
  goto <bb 6>; [100.00%]

  <bb 4> [local count: 268435456]:
<L1>:
  # DEBUG BEGIN_STMT
  _5 ={v} base_14(D)->CTRL1;
  _6 = _5 | 8;
  base_14(D)->CTRL1 ={v} _6;
  # DEBUG BEGIN_STMT
  goto <bb 6>; [100.00%]

  <bb 5> [local count: 268435456]:
<L2>:
  # DEBUG BEGIN_STMT
  _7 ={v} base_14(D)->CTRL1;
  _8 = _7 | 4096;
  base_14(D)->CTRL1 ={v} _8;
  # DEBUG BEGIN_STMT
  _9 ={v} base_14(D)->CTRL1;
  _10 = _9 & 4294967287;
  base_14(D)->CTRL1 ={v} _10;
  # DEBUG BEGIN_STMT
  # DEBUG base => base_14(D)
  # DEBUG enable => 1
  # DEBUG INLINE_ENTRY FlexCAN_SetSelfReception
  # DEBUG BEGIN_STMT
  _20 ={v} base_14(D)->MCR;
  _21 = _20 & 4294836223;
  base_14(D)->MCR ={v} _21;

  <bb 6> [local count: 1073741824]:
<L5>:
  # DEBUG base => NULL
  # DEBUG enable => NULL
  return;

}


FlexCAN_SetMaxMsgBuffNum (struct FLEXCAN_Type * base, uint32 maxMsgBuffNum)
{
  Flexcan_Ip_StatusType Status;
  uint32 ValEndRam;
  uint32 ValEndMb;
  uint8 Can_Real_Payload;
  volatile uint32 * Flexcan_Mb;
  const uint32 * ValEndMbPointer;
  const uint32 * RAM;
  uint32 DataByte;
  uint8 MsgBuffIdx;
  long unsigned int base.6_1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int ValEndMbPointer.7_5;
  long unsigned int _6;
  const uint32 * _7;
  long unsigned int _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _11;
  long unsigned int _12;
  long unsigned int _13;
  long unsigned int _14;
  volatile uint8 * _15;
  long unsigned int _16;
  long unsigned int _17;
  sizetype _25;

  <bb 2> [local count: 69103254]:
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  base.6_1 = (long unsigned int) base_23(D);
  _2 = base.6_1 + 128;
  RAM_24 = (const uint32 *) _2;
  # DEBUG RAM => RAM_24
  # DEBUG BEGIN_STMT
  # DEBUG ValEndMbPointer => 0B
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb => 0B
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Id => 0B
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Data => 0B
  # DEBUG BEGIN_STMT
  # DEBUG Arbitration_Field_Size => 8
  # DEBUG BEGIN_STMT
  _3 = maxMsgBuffNum_27(D) + 4294967295;
  Can_Real_Payload_30 = FlexCAN_GetMbPayloadSize (base_23(D), _3);
  # DEBUG Can_Real_Payload => Can_Real_Payload_30
  # DEBUG BEGIN_STMT
  # DEBUG ValEndMb => 0
  # DEBUG BEGIN_STMT
  # DEBUG ValEndRam => 0
  # DEBUG BEGIN_STMT
  # DEBUG Status => 0
  # DEBUG BEGIN_STMT
  ValEndMbPointer_32 = FlexCAN_GetMsgBuffRegion (base_23(D), _3);
  # DEBUG ValEndMbPointer => ValEndMbPointer_32
  # DEBUG BEGIN_STMT
  _4 = (long unsigned int) Can_Real_Payload_30;
  ValEndMbPointer.7_5 = (long unsigned int) ValEndMbPointer_32;
  _6 = _4 + ValEndMbPointer.7_5;
  ValEndMb_33 = _6 + 8;
  # DEBUG ValEndMb => ValEndMb_33
  # DEBUG BEGIN_STMT
  _7 = RAM_24 + 512;
  ValEndRam_34 = (uint32) _7;
  # DEBUG ValEndRam => ValEndRam_34
  # DEBUG BEGIN_STMT
  if (ValEndMb_33 > ValEndRam_34)
    goto <bb 10>; [35.00%]
  else
    goto <bb 3>; [65.00%]

  <bb 3> [local count: 44917115]:
  _8 = FlexCAN_GetMaxMbNum (base_23(D));
  if (_8 < maxMsgBuffNum_27(D))
    goto <bb 10>; [35.00%]
  else
    goto <bb 4>; [65.00%]

  <bb 4> [local count: 29196125]:
  # DEBUG Status => 0
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _9 ={v} base_23(D)->MCR;
  _10 = _9 & 4294967168;
  _11 = _3 & 127;
  _12 = _10 | _11;
  base_23(D)->MCR ={v} _12;
  # DEBUG BEGIN_STMT
  _13 ={v} base_23(D)->MCR;
  _14 = _13 & 536870912;
  if (_14 == 0)
    goto <bb 11>; [50.00%]
  else
    goto <bb 10>; [50.00%]

  <bb 11> [local count: 14598062]:
  goto <bb 9>; [100.00%]

  <bb 5> [local count: 118111600]:
  # DEBUG BEGIN_STMT
  Flexcan_Mb_37 = FlexCAN_GetMsgBuffRegion (base_23(D), _17);
  # DEBUG Flexcan_Mb => Flexcan_Mb_37
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Id => Flexcan_Mb_37 + 4
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Data => Flexcan_Mb_37 + 8
  # DEBUG BEGIN_STMT
  *Flexcan_Mb_37 ={v} 0;
  # DEBUG BEGIN_STMT
  MEM[(volatile uint32 *)Flexcan_Mb_37 + 4B] ={v} 0;
  # DEBUG BEGIN_STMT
  Can_Real_Payload_41 = FlexCAN_GetMbPayloadSize (base_23(D), _17);
  # DEBUG Can_Real_Payload => Can_Real_Payload_41
  # DEBUG BEGIN_STMT
  # DEBUG DataByte => 0
  goto <bb 7>; [100.00%]

  <bb 6> [local count: 955630223]:
  # DEBUG BEGIN_STMT
  _25 = DataByte_19 + 8;
  _15 = Flexcan_Mb_37 + _25;
  *_15 ={v} 0;
  # DEBUG BEGIN_STMT
  DataByte_44 = DataByte_19 + 1;
  # DEBUG DataByte => DataByte_44

  <bb 7> [local count: 1073741824]:
  # DataByte_19 = PHI <0(5), DataByte_44(6)>
  # DEBUG DataByte => DataByte_19
  # DEBUG BEGIN_STMT
  _16 = (long unsigned int) Can_Real_Payload_41;
  if (_16 > DataByte_19)
    goto <bb 6>; [89.00%]
  else
    goto <bb 8>; [11.00%]

  <bb 8> [local count: 118111601]:
  # DEBUG BEGIN_STMT
  MsgBuffIdx_42 = MsgBuffIdx_18 + 1;
  # DEBUG MsgBuffIdx => MsgBuffIdx_42

  <bb 9> [local count: 132709663]:
  # MsgBuffIdx_18 = PHI <MsgBuffIdx_42(8), 0(11)>
  # DEBUG MsgBuffIdx => MsgBuffIdx_18
  # DEBUG BEGIN_STMT
  _17 = (long unsigned int) MsgBuffIdx_18;
  if (_17 < maxMsgBuffNum_27(D))
    goto <bb 5>; [89.00%]
  else
    goto <bb 10>; [11.00%]

  <bb 10> [local count: 69103254]:
  # Status_26 = PHI <4(3), 0(4), 0(9), 4(2)>
  # DEBUG Status => NULL
  # DEBUG BEGIN_STMT
  return Status_26;

}


FlexCAN_SetTxMsgBuff (volatile uint32 * const pMbAddr, const struct Flexcan_Ip_MsbuffCodeStatusType * cs, uint32 msgId, const uint8 * msgData, const boolean isRemote)
{
  uint32 ret;
  static const uint8 payload_code[65] = "\x00\x01\x02\x03\x04\x05\x06\x07\b\t\t\t\t\n\n\n\n\v\v\v\v\f\f\f\f\r\r\r\r\r\r\r\r\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f";
  volatile uint8 * Flexcan_Mb_Data;
  uint8 Payload_Size;
  uint32 DataByte;
  uint32 Flexcan_Mb_Config;
  long unsigned int _1;
  unsigned char _2;
  long unsigned int _3;
  long unsigned int _4;
  const uint32 * _5;
  long unsigned int _6;
  long unsigned int _7;
  long unsigned int _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _11;
  long unsigned int _12;
  long unsigned int _13;
  long unsigned int _14;
  volatile uint32 * _15;
  long unsigned int _16;
  long unsigned int _17;
  long unsigned int _18;
  const uint8 * _19;
  long unsigned int _20;
  volatile uint8 * _21;
  unsigned char _22;
  long unsigned int _23;
  long unsigned int _24;
  volatile uint8 * _25;
  unsigned char _26;
  long unsigned int _27;
  <unnamed type> _28;
  long unsigned int _29;
  long unsigned int _30;
  long unsigned int _31;
  long unsigned int _32;
  long unsigned int _33;
  long unsigned int _34;
  long unsigned int _35;
  long unsigned int _36;
  long unsigned int _37;
  long unsigned int _38;
  long unsigned int _39;
  long unsigned int _40;
  long unsigned int _41;
  long unsigned int _42;
  _Bool _43;
  long unsigned int _44;
  long unsigned int _45;
  long unsigned int _46;
  long unsigned int _47;
  long unsigned int _48;
  _Bool _49;
  long unsigned int _50;
  long unsigned int _51;
  long unsigned int _67;
  long unsigned int _69;
  long unsigned int _71;
  sizetype _73;
  unsigned char _78;
  int _79;
  unsigned char _102;

  <bb 2> [local count: 168730856]:
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Config => 0
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb => pMbAddr_68(D)
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Id => pMbAddr_68(D) + 4
  # DEBUG BEGIN_STMT
  Flexcan_Mb_Data_70 = pMbAddr_68(D) + 8;
  # DEBUG Flexcan_Mb_Data => Flexcan_Mb_Data_70
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Data_32 => Flexcan_Mb_Data_70
  # DEBUG BEGIN_STMT
  # DEBUG MsgData_32 => msgData_72(D)
  # DEBUG BEGIN_STMT
  *pMbAddr_68(D) ={v} 134217728;
  # DEBUG BEGIN_STMT
  MEM[(volatile uint32 *)pMbAddr_68(D) + 4B] ={v} 0;
  # DEBUG BEGIN_STMT
  _1 = cs_77(D)->dataLen;
  _2 = (unsigned char) _1;
  # DEBUG payloadSize => _2
  # DEBUG INLINE_ENTRY FlexCAN_ComputeDLCValue
  # DEBUG BEGIN_STMT
  # DEBUG ret => 255
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  if (_2 <= 64)
    goto <bb 3>; [50.00%]
  else
    goto <bb 4>; [50.00%]

  <bb 3> [local count: 84365428]:
  # DEBUG BEGIN_STMT
  _67 = _1 & 255;
  _79 = (int) _67;
  _78 = payload_code[_79];
  ret_100 = (uint32) _78;
  # DEBUG ret => ret_100

  <bb 4> [local count: 168730856]:
  # ret_101 = PHI <255(2), ret_100(3)>
  # DEBUG ret => ret_101
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _102 = (unsigned char) ret_101;
  # DEBUG payloadSize => NULL
  # DEBUG ret => NULL
  # DEBUG Dlc_Value => _102
  # DEBUG BEGIN_STMT
  if (msgData_72(D) != 0B)
    goto <bb 29>; [70.00%]
  else
    goto <bb 12>; [30.00%]

  <bb 29> [local count: 118111599]:
  goto <bb 6>; [100.00%]

  <bb 5> [local count: 955630215]:
  # DEBUG BEGIN_STMT
  _3 = DataByte_57 >> 2;
  _4 = _3 * 4;
  _5 = msgData_72(D) + _4;
  _6 = *_5;
  _7 = _6 >> 24;
  _8 = _6 >> 8;
  _9 = _8 & 65280;
  _10 = _7 | _9;
  _11 = _6 << 8;
  _12 = _11 & 16711680;
  _13 = _10 | _12;
  _14 = _6 << 24;
  _73 = _4 + 8;
  _15 = pMbAddr_68(D) + _73;
  _16 = _13 | _14;
  *_15 ={v} _16;
  # DEBUG BEGIN_STMT
  DataByte_86 = DataByte_57 + 4;
  # DEBUG DataByte => DataByte_86

  <bb 6> [local count: 1073741814]:
  # DataByte_57 = PHI <DataByte_86(5), 0(29)>
  # DEBUG DataByte => DataByte_57
  # DEBUG BEGIN_STMT
  _17 = cs_77(D)->dataLen;
  _18 = _17 & 4294967292;
  if (_18 > DataByte_57)
    goto <bb 5>; [89.00%]
  else
    goto <bb 28>; [11.00%]

  <bb 28> [local count: 118111600]:
  goto <bb 8>; [100.00%]

  <bb 7> [local count: 955630220]:
  # DEBUG BEGIN_STMT
  _19 = msgData_72(D) + DataByte_58;
  _20 = DataByte_58 ^ 3;
  _21 = Flexcan_Mb_Data_70 + _20;
  _22 = *_19;
  *_21 ={v} _22;
  # DEBUG BEGIN_STMT
  DataByte_84 = DataByte_58 + 1;
  # DEBUG DataByte => DataByte_84

  <bb 8> [local count: 1073741821]:
  # DataByte_58 = PHI <DataByte_84(7), DataByte_57(28)>
  # DEBUG DataByte => DataByte_58
  # DEBUG BEGIN_STMT
  _23 = cs_77(D)->dataLen;
  if (_23 > DataByte_58)
    goto <bb 7>; [89.00%]
  else
    goto <bb 9>; [11.00%]

  <bb 9> [local count: 118111600]:
  # _71 = PHI <_23(8)>
  # DEBUG BEGIN_STMT
  Payload_Size_80 = FlexCAN_ComputePayloadSize (_102);
  # DEBUG Payload_Size => Payload_Size_80
  # DEBUG BEGIN_STMT
  # DEBUG DataByte => _71
  goto <bb 11>; [100.00%]

  <bb 10> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  _24 = DataByte_59 ^ 3;
  _25 = Flexcan_Mb_Data_70 + _24;
  _26 = cs_77(D)->fd_padding;
  *_25 ={v} _26;
  # DEBUG BEGIN_STMT
  DataByte_82 = DataByte_59 + 1;
  # DEBUG DataByte => DataByte_82

  <bb 11> [local count: 1073741824]:
  # DataByte_59 = PHI <_71(9), DataByte_82(10)>
  # DEBUG DataByte => DataByte_59
  # DEBUG BEGIN_STMT
  _27 = (long unsigned int) Payload_Size_80;
  if (_27 > DataByte_59)
    goto <bb 10>; [89.00%]
  else
    goto <bb 12>; [11.00%]

  <bb 12> [local count: 168730858]:
  # DEBUG BEGIN_STMT
  _28 = cs_77(D)->msgIdType;
  if (_28 == 1)
    goto <bb 13>; [34.00%]
  else
    goto <bb 14>; [66.00%]

  <bb 13> [local count: 57368492]:
  # DEBUG BEGIN_STMT
  _29 ={v} MEM[(volatile uint32 *)pMbAddr_68(D) + 4B];
  _30 = _29 & 3758096384;
  MEM[(volatile uint32 *)pMbAddr_68(D) + 4B] ={v} _30;
  # DEBUG BEGIN_STMT
  _31 ={v} MEM[(volatile uint32 *)pMbAddr_68(D) + 4B];
  _32 = msgId_88(D) & 536870911;
  _33 = _31 | _32;
  MEM[(volatile uint32 *)pMbAddr_68(D) + 4B] ={v} _33;
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Config => 6291456

  <bb 14> [local count: 168730858]:
  # Flexcan_Mb_Config_52 = PHI <0(12), 6291456(13)>
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_52
  # DEBUG BEGIN_STMT
  if (_28 == 0)
    goto <bb 15>; [50.00%]
  else
    goto <bb 16>; [50.00%]

  <bb 15> [local count: 84365429]:
  # DEBUG BEGIN_STMT
  _34 ={v} MEM[(volatile uint32 *)pMbAddr_68(D) + 4B];
  _35 = _34 & 3758358527;
  MEM[(volatile uint32 *)pMbAddr_68(D) + 4B] ={v} _35;
  # DEBUG BEGIN_STMT
  _36 ={v} MEM[(volatile uint32 *)pMbAddr_68(D) + 4B];
  _37 = msgId_88(D) << 18;
  _38 = _37 & 536608768;
  _39 = _36 | _38;
  MEM[(volatile uint32 *)pMbAddr_68(D) + 4B] ={v} _39;
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Config => 0

  <bb 16> [local count: 168730858]:
  # Flexcan_Mb_Config_53 = PHI <Flexcan_Mb_Config_52(14), 0(15)>
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_53
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_53
  # DEBUG BEGIN_STMT
  _40 = ret_101 << 16;
  _41 = _40 & 983040;
  Flexcan_Mb_Config_92 = _41 | Flexcan_Mb_Config_53;
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_92
  # DEBUG BEGIN_STMT
  _42 = cs_77(D)->code;
  if (_42 != 15)
    goto <bb 17>; [66.00%]
  else
    goto <bb 27>; [34.00%]

  <bb 17> [local count: 111362366]:
  # DEBUG BEGIN_STMT
  if (_42 == 28)
    goto <bb 18>; [34.00%]
  else
    goto <bb 19>; [66.00%]

  <bb 18> [local count: 37863204]:
  # DEBUG BEGIN_STMT
  Flexcan_Mb_Config_95 = Flexcan_Mb_Config_92 | 1048576;
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_95
  goto <bb 21>; [100.00%]

  <bb 19> [local count: 73499162]:
  # DEBUG BEGIN_STMT
  if (isRemote_93(D) != 0)
    goto <bb 20>; [50.00%]
  else
    goto <bb 21>; [50.00%]

  <bb 20> [local count: 36749581]:
  # DEBUG BEGIN_STMT
  Flexcan_Mb_Config_94 = Flexcan_Mb_Config_92 | 1048576;
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_94

  <bb 21> [local count: 111362366]:
  # Flexcan_Mb_Config_54 = PHI <Flexcan_Mb_Config_95(18), Flexcan_Mb_Config_92(19), Flexcan_Mb_Config_94(20)>
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_54
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_54
  # DEBUG BEGIN_STMT
  _43 = cs_77(D)->fd_enable;
  if (_43 != 0)
    goto <bb 22>; [50.00%]
  else
    goto <bb 23>; [50.00%]

  <bb 22> [local count: 55681183]:
  # DEBUG BEGIN_STMT
  _44 = _42 << 24;
  _45 = _44 & 251658240;
  _46 = _45 | Flexcan_Mb_Config_54;
  # DEBUG Flexcan_Mb_Config => _46 | 2147483648
  # DEBUG BEGIN_STMT
  _69 = _46 & 4293918719;
  Flexcan_Mb_Config_97 = _69 | 2147483648;
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_97
  goto <bb 24>; [100.00%]

  <bb 23> [local count: 55681183]:
  # DEBUG BEGIN_STMT
  _47 = _42 << 24;
  _48 = _47 & 251658240;
  Flexcan_Mb_Config_96 = _48 | Flexcan_Mb_Config_54;
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_96

  <bb 24> [local count: 111362366]:
  # Flexcan_Mb_Config_55 = PHI <Flexcan_Mb_Config_97(22), Flexcan_Mb_Config_96(23)>
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_55
  # DEBUG BEGIN_STMT
  _49 = cs_77(D)->enable_brs;
  if (_49 != 0)
    goto <bb 25>; [50.00%]
  else
    goto <bb 26>; [50.00%]

  <bb 25> [local count: 55681183]:
  # DEBUG BEGIN_STMT
  Flexcan_Mb_Config_98 = Flexcan_Mb_Config_55 | 1073741824;
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_98

  <bb 26> [local count: 111362366]:
  # Flexcan_Mb_Config_56 = PHI <Flexcan_Mb_Config_55(24), Flexcan_Mb_Config_98(25)>
  # DEBUG Flexcan_Mb_Config => Flexcan_Mb_Config_56
  # DEBUG BEGIN_STMT
  _50 ={v} *pMbAddr_68(D);
  _51 = _50 | Flexcan_Mb_Config_56;
  *pMbAddr_68(D) ={v} _51;

  <bb 27> [local count: 168730858]:
  return;

}


FlexCAN_GetMsgBuff (const struct FLEXCAN_Type * base, uint32 msgBuffIdx, struct Flexcan_Ip_MsgBuffType * msgBuff)
{
  uint8 Payload_Size;
  uint8 Flexcan_Mb_Dlc_Value;
  uint32 MbWord;
  uint32 * MsgBuff_Data_32;
  const uint32 * Flexcan_Mb;
  uint8 i;
  long unsigned int _1;
  long unsigned int _2;
  unsigned char _3;
  unsigned char _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  long unsigned int _8;
  long unsigned int _9;
  long unsigned int _10;
  unsigned char _11;
  unsigned int _12;
  unsigned int _13;
  const uint32 * _14;
  long unsigned int _15;
  long unsigned int _16;
  long unsigned int _17;
  long unsigned int _18;
  long unsigned int _19;
  long unsigned int _20;
  long unsigned int _21;
  long unsigned int _22;
  uint32 * _23;
  long unsigned int _24;
  unsigned int _25;
  unsigned int _26;
  unsigned int _27;
  unsigned char _28;
  sizetype _29;
  const uint8 * _30;
  int _31;
  unsigned char _32;
  sizetype _48;
  sizetype _58;

  <bb 2> [local count: 118111600]:
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  Flexcan_Mb_44 = FlexCAN_GetMsgBuffRegion (base_41(D), msgBuffIdx_42(D));
  # DEBUG Flexcan_Mb => Flexcan_Mb_44
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Id => Flexcan_Mb_44 + 4
  # DEBUG BEGIN_STMT
  # DEBUG D#2 => Flexcan_Mb_44 + 8
  # DEBUG Flexcan_Mb_Data => D#2
  # DEBUG BEGIN_STMT
  # DEBUG Flexcan_Mb_Data_32 => D#2
  # DEBUG BEGIN_STMT
  MsgBuff_Data_32_46 = &msgBuff_45(D)->data;
  # DEBUG MsgBuff_Data_32 => MsgBuff_Data_32_46
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 ={v} *Flexcan_Mb_44;
  _2 = _1 >> 16;
  _3 = (unsigned char) _2;
  Flexcan_Mb_Dlc_Value_47 = _3 & 15;
  # DEBUG Flexcan_Mb_Dlc_Value => Flexcan_Mb_Dlc_Value_47
  # DEBUG BEGIN_STMT
  Payload_Size_49 = FlexCAN_ComputePayloadSize (Flexcan_Mb_Dlc_Value_47);
  # DEBUG Payload_Size => Payload_Size_49
  # DEBUG BEGIN_STMT
  _4 = FlexCAN_GetMbPayloadSize (base_41(D), msgBuffIdx_42(D));
  if (_4 < Payload_Size_49)
    goto <bb 3>; [33.00%]
  else
    goto <bb 4>; [67.00%]

  <bb 3> [local count: 38976828]:
  # DEBUG BEGIN_STMT
  Payload_Size_52 = FlexCAN_GetMbPayloadSize (base_41(D), msgBuffIdx_42(D));
  # DEBUG Payload_Size => Payload_Size_52

  <bb 4> [local count: 118111600]:
  # Payload_Size_35 = PHI <Payload_Size_49(2), Payload_Size_52(3)>
  # DEBUG Payload_Size => Payload_Size_35
  # DEBUG BEGIN_STMT
  msgBuff_45(D)->dataLen = Payload_Size_35;
  # DEBUG BEGIN_STMT
  _5 ={v} *Flexcan_Mb_44;
  msgBuff_45(D)->cs = _5;
  # DEBUG BEGIN_STMT
  _6 = _5 & 2097152;
  if (_6 != 0)
    goto <bb 5>; [50.00%]
  else
    goto <bb 6>; [50.00%]

  <bb 5> [local count: 59055800]:
  # DEBUG BEGIN_STMT
  _7 ={v} MEM[(const uint32 *)Flexcan_Mb_44 + 4B];
  msgBuff_45(D)->msgId = _7;
  goto <bb 7>; [100.00%]

  <bb 6> [local count: 59055800]:
  # DEBUG BEGIN_STMT
  _8 ={v} MEM[(const uint32 *)Flexcan_Mb_44 + 4B];
  _9 = _8 >> 18;
  msgBuff_45(D)->msgId = _9;

  <bb 7> [local count: 118111600]:
  # DEBUG BEGIN_STMT
  _10 = _5 & 65535;
  msgBuff_45(D)->time_stamp = _10;
  # DEBUG BEGIN_STMT
  # DEBUG i => 0
  goto <bb 9>; [100.00%]

  <bb 8> [local count: 955630220]:
  # DEBUG BEGIN_STMT
  _11 = i_33 >> 2;
  _12 = (unsigned int) _11;
  _13 = _12 * 4;
  _48 = _13 + 8;
  _14 = Flexcan_Mb_44 + _48;
  MbWord_61 ={v} *_14;
  # DEBUG MbWord => MbWord_61
  # DEBUG BEGIN_STMT
  _15 = MbWord_61 >> 24;
  _16 = MbWord_61 >> 8;
  _17 = _16 & 65280;
  _18 = _15 | _17;
  _19 = MbWord_61 << 8;
  _20 = _19 & 16711680;
  _21 = _18 | _20;
  _22 = MbWord_61 << 24;
  _23 = MsgBuff_Data_32_46 + _13;
  _24 = _21 | _22;
  *_23 = _24;
  # DEBUG BEGIN_STMT
  i_63 = i_33 + 4;
  # DEBUG i => i_63

  <bb 9> [local count: 1073741821]:
  # i_33 = PHI <0(7), i_63(8)>
  # DEBUG i => i_33
  # DEBUG BEGIN_STMT
  _25 = (unsigned int) i_33;
  _26 = (unsigned int) Payload_Size_35;
  _27 = _26 & 4294967292;
  if (_25 < _27)
    goto <bb 8>; [89.00%]
  else
    goto <bb 13>; [11.00%]

  <bb 13> [local count: 118111600]:
  goto <bb 11>; [100.00%]

  <bb 10> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  _28 = i_34 ^ 3;
  _29 = (sizetype) _28;
  _58 = _29 + 8;
  _30 = Flexcan_Mb_44 + _58;
  _31 = (int) i_34;
  _32 ={v} *_30;
  msgBuff_45(D)->data[_31] = _32;
  # DEBUG BEGIN_STMT
  i_60 = i_34 + 1;
  # DEBUG i => i_60

  <bb 11> [local count: 1073741824]:
  # i_34 = PHI <i_60(10), i_33(13)>
  # DEBUG i => i_34
  # DEBUG BEGIN_STMT
  if (i_34 < Payload_Size_35)
    goto <bb 10>; [89.00%]
  else
    goto <bb 12>; [11.00%]

  <bb 12> [local count: 118111601]:
  return;

}


FlexCAN_GetMsgBuffTimestamp (const struct FLEXCAN_Type * base, uint32 msgBuffIdx)
{
  const uint32 * Flexcan_Mb;
  uint32 TimeStamp;
  long unsigned int _1;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  # DEBUG TimeStamp => 0
  # DEBUG BEGIN_STMT
  Flexcan_Mb_6 = FlexCAN_GetMsgBuffRegion (base_3(D), msgBuffIdx_4(D));
  # DEBUG Flexcan_Mb => Flexcan_Mb_6
  # DEBUG BEGIN_STMT
  _1 ={v} *Flexcan_Mb_6;
  TimeStamp_7 = _1 & 65535;
  # DEBUG TimeStamp => TimeStamp_7
  # DEBUG BEGIN_STMT
  return TimeStamp_7;

}


FlexCAN_SetRxMsgBuff (const struct FLEXCAN_Type * base, uint32 msgBuffIdx, const struct Flexcan_Ip_MsbuffCodeStatusType * cs, uint32 msgId)
{
  volatile uint32 * flexcan_mb;
  <unnamed type> _1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  long unsigned int _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _11;
  long unsigned int _12;
  long unsigned int _13;
  long unsigned int _14;
  long unsigned int _15;
  long unsigned int _16;
  long unsigned int _17;
  long unsigned int _18;
  long unsigned int _19;
  long unsigned int _20;
  long unsigned int _21;
  long unsigned int _22;
  long unsigned int _23;
  long unsigned int _24;
  long unsigned int _25;
  long unsigned int _26;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  flexcan_mb_34 = FlexCAN_GetMsgBuffRegion (base_31(D), msgBuffIdx_32(D));
  # DEBUG flexcan_mb => flexcan_mb_34
  # DEBUG BEGIN_STMT
  # DEBUG flexcan_mb_id => flexcan_mb_34 + 4
  # DEBUG BEGIN_STMT
  *flexcan_mb_34 ={v} 0;
  # DEBUG BEGIN_STMT
  MEM[(volatile uint32 *)flexcan_mb_34 + 4B] ={v} 0;
  # DEBUG BEGIN_STMT
  _1 = cs_37(D)->msgIdType;
  if (_1 == 1)
    goto <bb 3>; [34.00%]
  else
    goto <bb 4>; [66.00%]

  <bb 3> [local count: 365072220]:
  # DEBUG BEGIN_STMT
  _2 ={v} *flexcan_mb_34;
  _3 = _2 | 2097152;
  *flexcan_mb_34 ={v} _3;
  # DEBUG BEGIN_STMT
  _4 ={v} *flexcan_mb_34;
  _5 = _4 & 4290772991;
  *flexcan_mb_34 ={v} _5;
  # DEBUG BEGIN_STMT
  _6 ={v} MEM[(volatile uint32 *)flexcan_mb_34 + 4B];
  _7 = _6 & 3758096384;
  MEM[(volatile uint32 *)flexcan_mb_34 + 4B] ={v} _7;
  # DEBUG BEGIN_STMT
  _8 ={v} MEM[(volatile uint32 *)flexcan_mb_34 + 4B];
  _9 = msgId_41(D) & 536870911;
  _10 = _8 | _9;
  MEM[(volatile uint32 *)flexcan_mb_34 + 4B] ={v} _10;

  <bb 4> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  if (_1 == 0)
    goto <bb 5>; [50.00%]
  else
    goto <bb 6>; [50.00%]

  <bb 5> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  _11 ={v} *flexcan_mb_34;
  _12 = _11 & 4288675839;
  *flexcan_mb_34 ={v} _12;
  # DEBUG BEGIN_STMT
  _13 ={v} MEM[(volatile uint32 *)flexcan_mb_34 + 4B];
  _14 = _13 & 3758358527;
  MEM[(volatile uint32 *)flexcan_mb_34 + 4B] ={v} _14;
  # DEBUG BEGIN_STMT
  _15 ={v} MEM[(volatile uint32 *)flexcan_mb_34 + 4B];
  _16 = msgId_41(D) << 18;
  _17 = _16 & 536608768;
  _18 = _15 | _17;
  MEM[(volatile uint32 *)flexcan_mb_34 + 4B] ={v} _18;

  <bb 6> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  _19 = cs_37(D)->code;
  if (_19 != 15)
    goto <bb 7>; [66.00%]
  else
    goto <bb 8>; [34.00%]

  <bb 7> [local count: 708669605]:
  # DEBUG BEGIN_STMT
  _20 ={v} *flexcan_mb_34;
  _21 = _20 & 4043309055;
  *flexcan_mb_34 ={v} _21;
  # DEBUG BEGIN_STMT
  _22 ={v} *flexcan_mb_34;
  _23 = cs_37(D)->code;
  _24 = _23 << 24;
  _25 = _24 & 251658240;
  _26 = _22 | _25;
  *flexcan_mb_34 ={v} _26;

  <bb 8> [local count: 1073741824]:
  return;

}


FlexCAN_EnableInterrupts (struct FLEXCAN_Type * pBase, uint8 u8Instance)
{
  int _1;
  long unsigned int _2;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  _1 = (int) u8Instance_3(D);
  _2 ={v} FlexCAN_Ip_au32ImaskBuff[_1][0];
  pBase_5(D)->IMASK1 ={v} _2;
  return;

}


FlexCAN_DisableInterrupts (struct FLEXCAN_Type * pBase)
{
  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  pBase_2(D)->IMASK1 ={v} 0;
  return;

}


FLEXCAN_ClearMsgBuffIntCmd (struct FLEXCAN_Type * pBase, uint8 u8Instance, uint32 mb_idx, boolean bIsIntActive)
{
  uint32 temp;
  long unsigned int _1;
  long unsigned int _2;
  long unsigned int _3;
  int _4;
  long unsigned int _5;
  long unsigned int _6;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  _1 = mb_idx_9(D) & 31;
  temp_10 = 1 << _1;
  # DEBUG temp => temp_10
  # DEBUG BEGIN_STMT
  if (mb_idx_9(D) <= 31)
    goto <bb 3>; [33.00%]
  else
    goto <bb 6>; [67.00%]

  <bb 3> [local count: 354334802]:
  # DEBUG BEGIN_STMT
  SchM_Enter_Can_CAN_EXCLUSIVE_AREA_11 ();
  # DEBUG BEGIN_STMT
  _2 ={v} pBase_13(D)->IMASK1;
  _3 = ~temp_10;
  _4 = (int) u8Instance_14(D);
  _5 = _2 & _3;
  FlexCAN_Ip_au32ImaskBuff[_4][0] ={v} _5;
  # DEBUG BEGIN_STMT
  if (bIsIntActive_16(D) != 0)
    goto <bb 4>; [50.00%]
  else
    goto <bb 5>; [50.00%]

  <bb 4> [local count: 177167401]:
  # DEBUG BEGIN_STMT
  _6 ={v} FlexCAN_Ip_au32ImaskBuff[_4][0];
  pBase_13(D)->IMASK1 ={v} _6;

  <bb 5> [local count: 354334802]:
  # DEBUG BEGIN_STMT
  SchM_Exit_Can_CAN_EXCLUSIVE_AREA_11 ();

  <bb 6> [local count: 1073741824]:
  return;

}


FlexCAN_SetMsgBuffIntCmd (struct FLEXCAN_Type * base, uint8 u8Instance, uint32 msgBuffIdx, boolean enable, boolean bIsIntActive)
{
  uint32 temp;
  long unsigned int _1;
  int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  int _6;
  long unsigned int _7;
  long unsigned int _8;
  long unsigned int _9;
  long unsigned int _10;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG stat => 0
  # DEBUG BEGIN_STMT
  _1 = msgBuffIdx_13(D) & 31;
  temp_14 = 1 << _1;
  # DEBUG temp => temp_14
  # DEBUG BEGIN_STMT
  if (msgBuffIdx_13(D) <= 31)
    goto <bb 3>; [50.00%]
  else
    goto <bb 8>; [50.00%]

  <bb 3> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  if (enable_16(D) != 0)
    goto <bb 4>; [50.00%]
  else
    goto <bb 7>; [50.00%]

  <bb 4> [local count: 268435456]:
  # DEBUG BEGIN_STMT
  SchM_Enter_Can_CAN_EXCLUSIVE_AREA_18 ();
  # DEBUG BEGIN_STMT
  _2 = (int) u8Instance_18(D);
  _3 ={v} FlexCAN_Ip_au32ImaskBuff[_2][0];
  _4 = _3 | temp_14;
  FlexCAN_Ip_au32ImaskBuff[_2][0] ={v} _4;
  # DEBUG BEGIN_STMT
  if (bIsIntActive_25(D) != 0)
    goto <bb 5>; [50.00%]
  else
    goto <bb 6>; [50.00%]

  <bb 5> [local count: 134217728]:
  # DEBUG BEGIN_STMT
  _5 ={v} FlexCAN_Ip_au32ImaskBuff[_2][0];
  base_20(D)->IMASK1 ={v} _5;

  <bb 6> [local count: 268435456]:
  # DEBUG BEGIN_STMT
  SchM_Exit_Can_CAN_EXCLUSIVE_AREA_18 ();
  goto <bb 8>; [100.00%]

  <bb 7> [local count: 268435456]:
  # DEBUG BEGIN_STMT
  SchM_Enter_Can_CAN_EXCLUSIVE_AREA_18 ();
  # DEBUG BEGIN_STMT
  _6 = (int) u8Instance_18(D);
  _7 ={v} FlexCAN_Ip_au32ImaskBuff[_6][0];
  _8 = ~temp_14;
  _9 = _7 & _8;
  FlexCAN_Ip_au32ImaskBuff[_6][0] ={v} _9;
  # DEBUG BEGIN_STMT
  _10 ={v} FlexCAN_Ip_au32ImaskBuff[_6][0];
  base_20(D)->IMASK1 ={v} _10;
  # DEBUG BEGIN_STMT
  SchM_Exit_Can_CAN_EXCLUSIVE_AREA_18 ();

  <bb 8> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  return 0;

}


FlexCAN_LockRxMsgBuff (const struct FLEXCAN_Type * base, uint32 msgBuffIdx)
{
  const uint32 * flexcan_mb;
  long unsigned int vol.4_6;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  flexcan_mb_5 = FlexCAN_GetMsgBuffRegion (base_2(D), msgBuffIdx_3(D));
  # DEBUG flexcan_mb => flexcan_mb_5
  # DEBUG BEGIN_STMT
  vol.4_6 ={v} *flexcan_mb_5;
  return;

}


FlexCAN_GetMbPayloadSize (const struct FLEXCAN_Type * base, uint32 maxMsgBuffNum)
{
  uint8 mb_size;
  uint8 i;
  uint8 maxMbBlockNum;
  uint8 can_real_payload;
  long unsigned int _1;
  long unsigned int _2;
  unsigned char _3;
  long unsigned int _4;

  <bb 2> [local count: 566398813]:
  # DEBUG BEGIN_STMT
  # DEBUG arbitration_field_size => 8
  # DEBUG BEGIN_STMT
  # DEBUG ramBlockSize => 512
  # DEBUG BEGIN_STMT
  # DEBUG can_real_payload => 8
  # DEBUG BEGIN_STMT
  # DEBUG maxMbBlockNum => 0
  # DEBUG BEGIN_STMT
  # DEBUG i => 0
  # DEBUG BEGIN_STMT
  # DEBUG mb_size => 0
  # DEBUG BEGIN_STMT
  # DEBUG i => 0
  goto <bb 4>; [100.00%]

  <bb 3> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  can_real_payload_14 = FlexCAN_GetPayloadSize (base_12(D), 0);
  # DEBUG can_real_payload => can_real_payload_14
  # DEBUG BEGIN_STMT
  mb_size_15 = can_real_payload_14 + 8;
  # DEBUG mb_size => mb_size_15
  # DEBUG BEGIN_STMT
  _1 = (long unsigned int) mb_size_15;
  _2 = 512 / _1;
  _3 = (unsigned char) _2;
  maxMbBlockNum_16 = _3 + maxMbBlockNum_7;
  # DEBUG maxMbBlockNum => maxMbBlockNum_16
  # DEBUG BEGIN_STMT
  _4 = (long unsigned int) maxMbBlockNum_16;
  if (_4 > maxMsgBuffNum_17(D))
    goto <bb 5>; [5.50%]
  else
    goto <bb 6>; [94.50%]

  <bb 6> [local count: 507343012]:

  <bb 4> [local count: 1073741824]:
  # can_real_payload_5 = PHI <8(2), can_real_payload_14(6)>
  # maxMbBlockNum_7 = PHI <0(2), maxMbBlockNum_16(6)>
  # i_8 = PHI <0(2), 1(6)>
  # DEBUG i => i_8
  # DEBUG maxMbBlockNum => maxMbBlockNum_7
  # DEBUG can_real_payload => can_real_payload_5
  # DEBUG BEGIN_STMT
  if (i_8 == 0)
    goto <bb 3>; [50.00%]
  else
    goto <bb 5>; [50.00%]

  <bb 5> [local count: 566398813]:
  # can_real_payload_6 = PHI <can_real_payload_14(3), can_real_payload_5(4)>
  # DEBUG can_real_payload => can_real_payload_6
  # DEBUG BEGIN_STMT
  return can_real_payload_6;

}


FlexCAN_SetPayloadSize (struct FLEXCAN_Type * base, const struct Flexcan_Ip_PayloadSizeType * payloadSize)
{
  uint32 tmp;
  <unnamed type> _1;
  long unsigned int _2;
  long unsigned int _11;
  long unsigned int _12;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG base => base_5(D)
  # DEBUG INLINE_ENTRY FlexCAN_IsFDEnabled
  # DEBUG BEGIN_STMT
  _11 ={v} MEM[(const struct FLEXCAN_Type *)base_5(D)].MCR;
  _12 = _11 & 2048;
  # DEBUG base => NULL
  if (_12 != 0)
    goto <bb 3>; [50.00%]
  else
    goto <bb 4>; [50.00%]

  <bb 3> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  tmp_6 ={v} base_5(D)->FDCTRL;
  # DEBUG tmp => tmp_6
  # DEBUG BEGIN_STMT
  tmp_7 = tmp_6 & 4294770687;
  # DEBUG tmp => tmp_7
  # DEBUG BEGIN_STMT
  _1 = payloadSize_8(D)->payloadBlock0;
  _2 = _1 << 16;
  tmp_9 = _2 | tmp_7;
  # DEBUG tmp => tmp_9
  # DEBUG BEGIN_STMT
  base_5(D)->FDCTRL ={v} tmp_9;

  <bb 4> [local count: 1073741824]:
  return;

}


FlexCAN_IsFDAvailable (const struct FLEXCAN_Type * base)
{
  boolean returnValue;
  uint32 i;

  <bb 2> [local count: 566398813]:
  # DEBUG BEGIN_STMT
  # DEBUG i => 0
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG returnValue => 0
  # DEBUG BEGIN_STMT
  # DEBUG i => 0
  goto <bb 4>; [100.00%]

  <bb 3> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  if (base_4(D) == 1073889280B)
    goto <bb 5>; [5.50%]
  else
    goto <bb 6>; [94.50%]

  <bb 6> [local count: 507343012]:

  <bb 4> [local count: 1073741824]:
  # i_1 = PHI <0(2), 1(6)>
  # DEBUG i => i_1
  # DEBUG BEGIN_STMT
  if (i_1 == 0)
    goto <bb 3>; [50.00%]
  else
    goto <bb 5>; [50.00%]

  <bb 5> [local count: 566398813]:
  # returnValue_2 = PHI <1(3), 0(4)>
  # DEBUG returnValue => returnValue_2
  # DEBUG BEGIN_STMT
  return returnValue_2;

}


FlexCAN_EnableRxFifo (struct FLEXCAN_Type * base, uint32 numOfFilters)
{
  Flexcan_Ip_StatusType stat;
  uint32 i;
  long unsigned int _1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  long unsigned int _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _17;

  <bb 2> [local count: 236223200]:
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = FlexCAN_GetMaxMbNum (base_15(D));
  # DEBUG noOfMbx => (uint16) _1
  # DEBUG BEGIN_STMT
  # DEBUG stat => 0
  # DEBUG BEGIN_STMT
  _2 ={v} base_15(D)->MCR;
  _3 = _2 & 2048;
  if (_3 != 0)
    goto <bb 6>; [50.00%]
  else
    goto <bb 3>; [50.00%]

  <bb 3> [local count: 118111600]:
  # DEBUG stat => 0
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _4 ={v} base_15(D)->MCR;
  _5 = _4 | 536870912;
  base_15(D)->MCR ={v} _5;
  # DEBUG BEGIN_STMT
  _6 ={v} base_15(D)->CTRL2;
  _7 = _6 & 4043309055;
  _8 = numOfFilters_19(D) << 24;
  _9 = _8 & 251658240;
  _10 = _7 | _9;
  base_15(D)->CTRL2 ={v} _10;
  # DEBUG BEGIN_STMT
  base_15(D)->RXFGMASK ={v} 4294967295;
  # DEBUG BEGIN_STMT
  # DEBUG i => 0
  goto <bb 5>; [100.00%]

  <bb 4> [local count: 955630223]:
  # DEBUG BEGIN_STMT
  base_15(D)->RXIMR[i_11] ={v} 536870911;
  # DEBUG BEGIN_STMT
  i_23 = i_11 + 1;
  # DEBUG i => i_23

  <bb 5> [local count: 1073741824]:
  # i_11 = PHI <0(3), i_23(4)>
  # DEBUG i => i_11
  # DEBUG BEGIN_STMT
  _17 = _1 & 65535;
  if (i_11 < _17)
    goto <bb 4>; [89.00%]
  else
    goto <bb 6>; [11.00%]

  <bb 6> [local count: 236223201]:
  # stat_16 = PHI <1(2), 0(5)>
  # DEBUG stat => NULL
  # DEBUG BEGIN_STMT
  return stat_16;

}


FlexCAN_Init (struct FLEXCAN_Type * base)
{
  Flexcan_Ip_StatusType returnResult;
  uint32 uS2Ticks;
  uint32 timeElapsed;
  uint32 timeStart;
  long unsigned int _1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  _Bool _8;
  long unsigned int _23;

  <bb 2> [local count: 114863532]:
  # DEBUG BEGIN_STMT
  timeStart = 0;
  # DEBUG BEGIN_STMT
  # DEBUG timeElapsed => 0
  # DEBUG BEGIN_STMT
  uS2Ticks_17 = OsIf_MicrosToTicks (1000000, 0);
  # DEBUG uS2Ticks => uS2Ticks_17
  # DEBUG BEGIN_STMT
  # DEBUG returnResult => 0
  # DEBUG BEGIN_STMT
  _1 ={v} base_18(D)->MCR;
  _2 = _1 | 33554432;
  base_18(D)->MCR ={v} _2;
  # DEBUG BEGIN_STMT
  _3 = OsIf_GetCounter (0);
  timeStart = _3;
  # DEBUG BEGIN_STMT
  goto <bb 4>; [100.00%]

  <bb 3> [local count: 1014686025]:
  # DEBUG BEGIN_STMT
  _23 = OsIf_GetElapsed (&timeStart, 0);
  timeElapsed_24 = timeElapsed_9 + _23;
  # DEBUG timeElapsed => timeElapsed_24
  # DEBUG BEGIN_STMT
  if (uS2Ticks_17 <= timeElapsed_24)
    goto <bb 5>; [5.50%]
  else
    goto <bb 9>; [94.50%]

  <bb 9> [local count: 958878293]:

  <bb 4> [local count: 1073741824]:
  # timeElapsed_9 = PHI <0(2), timeElapsed_24(9)>
  # DEBUG timeElapsed => timeElapsed_9
  # DEBUG BEGIN_STMT
  _4 ={v} base_18(D)->MCR;
  _5 = _4 & 33554432;
  if (_5 != 0)
    goto <bb 3>; [94.50%]
  else
    goto <bb 5>; [5.50%]

  <bb 5> [local count: 114863532]:
  # returnResult_10 = PHI <3(3), 0(4)>
  # DEBUG returnResult => returnResult_10
  # DEBUG BEGIN_STMT
  if (returnResult_10 == 0)
    goto <bb 6>; [33.00%]
  else
    goto <bb 8>; [67.00%]

  <bb 6> [local count: 37904965]:
  # DEBUG BEGIN_STMT
  _6 ={v} base_18(D)->MCR;
  _7 = _6 | 4096;
  base_18(D)->MCR ={v} _7;
  # DEBUG BEGIN_STMT
  FlexCAN_ClearRAM (base_18(D));
  # DEBUG BEGIN_STMT
  base_18(D)->RXMGMASK ={v} 4294967295;
  # DEBUG BEGIN_STMT
  base_18(D)->RX14MASK ={v} 4294967295;
  # DEBUG BEGIN_STMT
  base_18(D)->RX15MASK ={v} 4294967295;
  # DEBUG BEGIN_STMT
  base_18(D)->IMASK1 ={v} 0;
  # DEBUG BEGIN_STMT
  base_18(D)->IFLAG1 ={v} 4294967295;
  # DEBUG BEGIN_STMT
  base_18(D)->ESR1 ={v} 3866630;
  # DEBUG BEGIN_STMT
  base_18(D)->CTRL1 ={v} 0;
  # DEBUG BEGIN_STMT
  base_18(D)->CTRL2 ={v} 1048576;
  # DEBUG BEGIN_STMT
  base_18(D)->CBT ={v} 0;
  # DEBUG BEGIN_STMT
  _8 = FlexCAN_IsFDAvailable (base_18(D));
  if (_8 != 0)
    goto <bb 7>; [50.00%]
  else
    goto <bb 8>; [50.00%]

  <bb 7> [local count: 18952483]:
  # DEBUG BEGIN_STMT
  base_18(D)->FDCBT ={v} 0;
  # DEBUG BEGIN_STMT
  base_18(D)->FDCTRL ={v} 2147500288;

  <bb 8> [local count: 114863532]:
  # DEBUG BEGIN_STMT
  timeStart ={v} {CLOBBER};
  return returnResult_10;

}


FlexCAN_SetErrIntCmd (struct FLEXCAN_Type * base, flexcan_int_type_t errType, boolean enable)
{
  uint32 temp;
  long unsigned int _1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  long unsigned int _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _11;
  unsigned int _12;
  long unsigned int _13;
  long unsigned int _14;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  # DEBUG temp => errType_17(D)
  # DEBUG BEGIN_STMT
  SchM_Enter_Can_CAN_EXCLUSIVE_AREA_06 ();
  # DEBUG BEGIN_STMT
  if (enable_20(D) != 0)
    goto <bb 3>; [50.00%]
  else
    goto <bb 9>; [50.00%]

  <bb 3> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  if (errType_17(D) == 16385)
    goto <bb 4>; [34.00%]
  else
    goto <bb 5>; [66.00%]

  <bb 4> [local count: 182536110]:
  # DEBUG BEGIN_STMT
  _1 ={v} base_21(D)->CTRL2;
  _2 = _1 | 2147483648;
  base_21(D)->CTRL2 ={v} _2;
  # DEBUG BEGIN_STMT
  goto <bb 13>; [100.00%]

  <bb 5> [local count: 354334802]:
  # DEBUG BEGIN_STMT
  if (errType_17(D) == 1024)
    goto <bb 7>; [34.00%]
  else
    goto <bb 6>; [66.00%]

  <bb 6> [local count: 233860969]:
  if (errType_17(D) == 2048)
    goto <bb 7>; [34.00%]
  else
    goto <bb 8>; [66.00%]

  <bb 7> [local count: 199986562]:
  # DEBUG BEGIN_STMT
  _3 ={v} base_21(D)->MCR;
  _4 = _3 | 2097152;
  base_21(D)->MCR ={v} _4;

  <bb 8> [local count: 354334802]:
  # DEBUG BEGIN_STMT
  _5 ={v} base_21(D)->CTRL1;
  _6 = _5 | errType_17(D);
  base_21(D)->CTRL1 ={v} _6;
  goto <bb 13>; [100.00%]

  <bb 9> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  if (errType_17(D) == 16385)
    goto <bb 10>; [34.00%]
  else
    goto <bb 11>; [66.00%]

  <bb 10> [local count: 182536110]:
  # DEBUG BEGIN_STMT
  _7 ={v} base_21(D)->CTRL2;
  _8 = _7 & 2147483647;
  base_21(D)->CTRL2 ={v} _8;
  # DEBUG BEGIN_STMT
  goto <bb 13>; [100.00%]

  <bb 11> [local count: 354334802]:
  # DEBUG BEGIN_STMT
  _9 ={v} base_21(D)->CTRL1;
  _10 = ~errType_17(D);
  _11 = _9 & _10;
  base_21(D)->CTRL1 ={v} _11;
  # DEBUG BEGIN_STMT
  temp_23 ={v} base_21(D)->CTRL1;
  # DEBUG temp => temp_23
  # DEBUG BEGIN_STMT
  _12 = temp_23 & 3072;
  if (_12 == 0)
    goto <bb 12>; [50.00%]
  else
    goto <bb 13>; [50.00%]

  <bb 12> [local count: 177167401]:
  # DEBUG BEGIN_STMT
  _13 ={v} base_21(D)->MCR;
  _14 = _13 & 4292870143;
  base_21(D)->MCR ={v} _14;

  <bb 13> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  SchM_Exit_Can_CAN_EXCLUSIVE_AREA_06 ();
  return;

}


FlexCAN_Disable (struct FLEXCAN_Type * base)
{
  Flexcan_Ip_StatusType returnResult;
  uint32 uS2Ticks;
  uint32 timeElapsed;
  uint32 timeStart;
  long unsigned int _1;
  signed int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  long unsigned int _23;

  <bb 2> [local count: 276913048]:
  # DEBUG BEGIN_STMT
  timeStart = 0;
  # DEBUG BEGIN_STMT
  # DEBUG timeElapsed => 0
  # DEBUG BEGIN_STMT
  uS2Ticks_15 = OsIf_MicrosToTicks (1000000, 0);
  # DEBUG uS2Ticks => uS2Ticks_15
  # DEBUG BEGIN_STMT
  # DEBUG returnResult => 0
  # DEBUG BEGIN_STMT
  _1 ={v} base_16(D)->MCR;
  _2 = (signed int) _1;
  if (_2 >= 0)
    goto <bb 3>; [41.48%]
  else
    goto <bb 6>; [58.52%]

  <bb 3> [local count: 114863532]:
  # DEBUG BEGIN_STMT
  SchM_Enter_Can_CAN_EXCLUSIVE_AREA_05 ();
  # DEBUG BEGIN_STMT
  _3 ={v} base_16(D)->MCR;
  _4 = _3 | 2147483648;
  base_16(D)->MCR ={v} _4;
  # DEBUG BEGIN_STMT
  SchM_Exit_Can_CAN_EXCLUSIVE_AREA_05 ();
  # DEBUG BEGIN_STMT
  _5 = OsIf_GetCounter (0);
  timeStart = _5;
  # DEBUG BEGIN_STMT
  goto <bb 5>; [100.00%]

  <bb 4> [local count: 1014686024]:
  # DEBUG BEGIN_STMT
  _23 = OsIf_GetElapsed (&timeStart, 0);
  timeElapsed_24 = timeElapsed_8 + _23;
  # DEBUG timeElapsed => timeElapsed_24
  # DEBUG BEGIN_STMT
  if (uS2Ticks_15 <= timeElapsed_24)
    goto <bb 6>; [5.50%]
  else
    goto <bb 7>; [94.50%]

  <bb 7> [local count: 958878294]:

  <bb 5> [local count: 1073741824]:
  # timeElapsed_8 = PHI <0(3), timeElapsed_24(7)>
  # DEBUG timeElapsed => timeElapsed_8
  # DEBUG BEGIN_STMT
  _6 ={v} base_16(D)->MCR;
  _7 = _6 & 1048576;
  if (_7 == 0)
    goto <bb 4>; [94.50%]
  else
    goto <bb 6>; [5.50%]

  <bb 6> [local count: 276913047]:
  # returnResult_9 = PHI <0(2), 3(4), 0(5)>
  # DEBUG returnResult => returnResult_9
  # DEBUG BEGIN_STMT
  timeStart ={v} {CLOBBER};
  return returnResult_9;

}


FlexCAN_ExitFreezeMode (struct FLEXCAN_Type * base)
{
  Flexcan_Ip_StatusType returnValue;
  uint32 uS2Ticks;
  uint32 timeElapsed;
  uint32 timeStart;
  long unsigned int _1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  long unsigned int _24;

  <bb 2> [local count: 114863532]:
  # DEBUG BEGIN_STMT
  timeStart = 0;
  # DEBUG BEGIN_STMT
  # DEBUG timeElapsed => 0
  # DEBUG BEGIN_STMT
  uS2Ticks_15 = OsIf_MicrosToTicks (1000000, 0);
  # DEBUG uS2Ticks => uS2Ticks_15
  # DEBUG BEGIN_STMT
  # DEBUG returnValue => 0
  # DEBUG BEGIN_STMT
  SchM_Enter_Can_CAN_EXCLUSIVE_AREA_04 ();
  # DEBUG BEGIN_STMT
  _1 ={v} base_17(D)->MCR;
  _2 = _1 & 4026531839;
  base_17(D)->MCR ={v} _2;
  # DEBUG BEGIN_STMT
  _3 ={v} base_17(D)->MCR;
  _4 = _3 & 3221225471;
  base_17(D)->MCR ={v} _4;
  # DEBUG BEGIN_STMT
  SchM_Exit_Can_CAN_EXCLUSIVE_AREA_04 ();
  # DEBUG BEGIN_STMT
  _5 = OsIf_GetCounter (0);
  timeStart = _5;
  # DEBUG BEGIN_STMT
  goto <bb 4>; [100.00%]

  <bb 3> [local count: 1014686025]:
  # DEBUG BEGIN_STMT
  _24 = OsIf_GetElapsed (&timeStart, 0);
  timeElapsed_25 = timeElapsed_8 + _24;
  # DEBUG timeElapsed => timeElapsed_25
  # DEBUG BEGIN_STMT
  if (uS2Ticks_15 <= timeElapsed_25)
    goto <bb 5>; [5.50%]
  else
    goto <bb 6>; [94.50%]

  <bb 6> [local count: 958878293]:

  <bb 4> [local count: 1073741824]:
  # timeElapsed_8 = PHI <0(2), timeElapsed_25(6)>
  # DEBUG timeElapsed => timeElapsed_8
  # DEBUG BEGIN_STMT
  _6 ={v} base_17(D)->MCR;
  _7 = _6 & 16777216;
  if (_7 != 0)
    goto <bb 3>; [94.50%]
  else
    goto <bb 5>; [5.50%]

  <bb 5> [local count: 114863532]:
  # returnValue_9 = PHI <3(3), 0(4)>
  # DEBUG returnValue => returnValue_9
  # DEBUG BEGIN_STMT
  timeStart ={v} {CLOBBER};
  return returnValue_9;

}


FlexCAN_Enable (struct FLEXCAN_Type * base)
{
  Flexcan_Ip_StatusType returnValue;
  uint32 uS2Ticks;
  uint32 timeElapsed;
  uint32 timeStart;
  long unsigned int _1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _21;

  <bb 2> [local count: 114863532]:
  # DEBUG BEGIN_STMT
  timeStart = 0;
  # DEBUG BEGIN_STMT
  # DEBUG timeElapsed => 0
  # DEBUG BEGIN_STMT
  uS2Ticks_13 = OsIf_MicrosToTicks (1000000, 0);
  # DEBUG uS2Ticks => uS2Ticks_13
  # DEBUG BEGIN_STMT
  # DEBUG returnValue => 0
  # DEBUG BEGIN_STMT
  SchM_Enter_Can_CAN_EXCLUSIVE_AREA_03 ();
  # DEBUG BEGIN_STMT
  _1 ={v} base_15(D)->MCR;
  _2 = _1 & 2147483647;
  base_15(D)->MCR ={v} _2;
  # DEBUG BEGIN_STMT
  SchM_Exit_Can_CAN_EXCLUSIVE_AREA_03 ();
  # DEBUG BEGIN_STMT
  _3 = OsIf_GetCounter (0);
  timeStart = _3;
  # DEBUG BEGIN_STMT
  goto <bb 4>; [100.00%]

  <bb 3> [local count: 1014686025]:
  # DEBUG BEGIN_STMT
  _21 = OsIf_GetElapsed (&timeStart, 0);
  timeElapsed_22 = timeElapsed_6 + _21;
  # DEBUG timeElapsed => timeElapsed_22
  # DEBUG BEGIN_STMT
  if (uS2Ticks_13 <= timeElapsed_22)
    goto <bb 5>; [5.50%]
  else
    goto <bb 6>; [94.50%]

  <bb 6> [local count: 958878293]:

  <bb 4> [local count: 1073741824]:
  # timeElapsed_6 = PHI <0(2), timeElapsed_22(6)>
  # DEBUG timeElapsed => timeElapsed_6
  # DEBUG BEGIN_STMT
  _4 ={v} base_15(D)->MCR;
  _5 = _4 & 16777216;
  if (_5 == 0)
    goto <bb 3>; [94.50%]
  else
    goto <bb 5>; [5.50%]

  <bb 5> [local count: 114863532]:
  # returnValue_7 = PHI <3(3), 0(4)>
  # DEBUG returnValue => returnValue_7
  # DEBUG BEGIN_STMT
  timeStart ={v} {CLOBBER};
  return returnValue_7;

}


FlexCAN_EnterFreezeMode (struct FLEXCAN_Type * base)
{
  Flexcan_Ip_StatusType returnResult;
  uint32 uS2Ticks;
  uint32 timeElapsed;
  uint32 timeStart;
  long unsigned int _1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  signed int _6;
  long unsigned int _7;
  long unsigned int _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _11;
  long unsigned int _30;

  <bb 2> [local count: 114863532]:
  # DEBUG BEGIN_STMT
  timeStart = 0;
  # DEBUG BEGIN_STMT
  # DEBUG timeElapsed => 0
  # DEBUG BEGIN_STMT
  uS2Ticks_20 = OsIf_MicrosToTicks (1000000, 0);
  # DEBUG uS2Ticks => uS2Ticks_20
  # DEBUG BEGIN_STMT
  # DEBUG returnResult => 0
  # DEBUG BEGIN_STMT
  SchM_Enter_Can_CAN_EXCLUSIVE_AREA_02 ();
  # DEBUG BEGIN_STMT
  _1 ={v} base_22(D)->MCR;
  _2 = _1 | 1073741824;
  base_22(D)->MCR ={v} _2;
  # DEBUG BEGIN_STMT
  _3 ={v} base_22(D)->MCR;
  _4 = _3 | 268435456;
  base_22(D)->MCR ={v} _4;
  # DEBUG BEGIN_STMT
  _5 ={v} base_22(D)->MCR;
  _6 = (signed int) _5;
  if (_6 < 0)
    goto <bb 3>; [41.00%]
  else
    goto <bb 4>; [59.00%]

  <bb 3> [local count: 47094048]:
  # DEBUG BEGIN_STMT
  _7 ={v} base_22(D)->MCR;
  _8 = _7 & 2147483647;
  base_22(D)->MCR ={v} _8;

  <bb 4> [local count: 114863532]:
  # DEBUG BEGIN_STMT
  SchM_Exit_Can_CAN_EXCLUSIVE_AREA_02 ();
  # DEBUG BEGIN_STMT
  _9 = OsIf_GetCounter (0);
  timeStart = _9;
  # DEBUG BEGIN_STMT
  goto <bb 6>; [100.00%]

  <bb 5> [local count: 1014686025]:
  # DEBUG BEGIN_STMT
  _30 = OsIf_GetElapsed (&timeStart, 0);
  timeElapsed_31 = timeElapsed_12 + _30;
  # DEBUG timeElapsed => timeElapsed_31
  # DEBUG BEGIN_STMT
  if (uS2Ticks_20 <= timeElapsed_31)
    goto <bb 7>; [5.50%]
  else
    goto <bb 8>; [94.50%]

  <bb 8> [local count: 958878293]:

  <bb 6> [local count: 1073741824]:
  # timeElapsed_12 = PHI <0(4), timeElapsed_31(8)>
  # DEBUG timeElapsed => timeElapsed_12
  # DEBUG BEGIN_STMT
  _10 ={v} base_22(D)->MCR;
  _11 = _10 & 16777216;
  if (_11 == 0)
    goto <bb 5>; [94.50%]
  else
    goto <bb 7>; [5.50%]

  <bb 7> [local count: 114863532]:
  # returnResult_13 = PHI <3(5), 0(6)>
  # DEBUG returnResult => returnResult_13
  # DEBUG BEGIN_STMT
  timeStart ={v} {CLOBBER};
  return returnResult_13;

}


FlexCAN_GetMaxMbNum (const struct FLEXCAN_Type * base)
{
  static const uint32 maxMbNum[3] = {32, 16, 16};
  static struct FLEXCAN_Type * const flexcanBase[3] = {1073889280B, 1073893376B, 1073917952B};
  uint32 ret;
  uint32 i;
  struct FLEXCAN_Type * _1;

  <bb 2> [local count: 268435456]:
  # DEBUG BEGIN_STMT
  # DEBUG ret => 0
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  # DEBUG i => 0
  goto <bb 6>; [100.00%]

  <bb 3> [local count: 805306369]:
  # DEBUG BEGIN_STMT
  _1 = flexcanBase[i_2];
  if (_1 == base_7(D))
    goto <bb 4>; [30.00%]
  else
    goto <bb 5>; [70.00%]

  <bb 4> [local count: 241591910]:
  # DEBUG BEGIN_STMT
  ret_8 = maxMbNum[i_2];
  # DEBUG ret => ret_8

  <bb 5> [local count: 805306368]:
  # ret_3 = PHI <ret_4(3), ret_8(4)>
  # DEBUG ret => ret_3
  # DEBUG BEGIN_STMT
  i_9 = i_2 + 1;
  # DEBUG i => i_9

  <bb 6> [local count: 1073741824]:
  # i_2 = PHI <0(2), i_9(5)>
  # ret_4 = PHI <0(2), ret_3(5)>
  # DEBUG ret => ret_4
  # DEBUG i => i_2
  # DEBUG BEGIN_STMT
  if (i_2 != 3)
    goto <bb 3>; [75.00%]
  else
    goto <bb 7>; [25.00%]

  <bb 7> [local count: 268435456]:
  # ret_5 = PHI <ret_4(6)>
  # DEBUG BEGIN_STMT
  return ret_5;

}


FlexCAN_GetMsgBuffRegion (const struct FLEXCAN_Type * base, uint32 msgBuffIdx)
{
  volatile uint32 * pAddressRet;
  volatile uint32 * RAM;
  uint8 payload_size;
  uint32 mb_index;
  uint8 maxMbNum;
  uint8 i;
  uint32 msgBuffIdxBackup;
  uint32 ramBlockOffset;
  uint8 mb_size;
  long unsigned int base.0_1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  long unsigned int _6;
  long unsigned int _7;
  unsigned char _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _11;
  long unsigned int _21;

  <bb 2> [local count: 566398813]:
  # DEBUG BEGIN_STMT
  # DEBUG arbitration_field_size => 8
  # DEBUG BEGIN_STMT
  # DEBUG mb_size => 0
  # DEBUG BEGIN_STMT
  # DEBUG ramBlockSize => 512
  # DEBUG BEGIN_STMT
  # DEBUG ramBlockOffset => 0
  # DEBUG BEGIN_STMT
  # DEBUG msgBuffIdxBackup => msgBuffIdx_23(D)
  # DEBUG BEGIN_STMT
  # DEBUG i => 0
  # DEBUG BEGIN_STMT
  # DEBUG maxMbNum => 0
  # DEBUG BEGIN_STMT
  # DEBUG mb_index => 0
  # DEBUG BEGIN_STMT
  # DEBUG payload_size => 0
  # DEBUG BEGIN_STMT
  base.0_1 = (long unsigned int) base_24(D);
  _2 = base.0_1 + 128;
  RAM_25 = (volatile uint32 *) _2;
  # DEBUG RAM => RAM_25
  # DEBUG BEGIN_STMT
  # DEBUG pAddressRet => 0B
  # DEBUG BEGIN_STMT
  # DEBUG i => 0
  goto <bb 5>; [100.00%]

  <bb 3> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  payload_size_28 = FlexCAN_GetPayloadSize (base_24(D), 0);
  # DEBUG payload_size => payload_size_28
  # DEBUG BEGIN_STMT
  mb_size_29 = payload_size_28 + 8;
  # DEBUG mb_size => mb_size_29
  # DEBUG BEGIN_STMT
  _3 = (long unsigned int) mb_size_29;
  _4 = 512 / _3;
  maxMbNum_30 = (uint8) _4;
  # DEBUG maxMbNum => maxMbNum_30
  # DEBUG BEGIN_STMT
  _21 = _4 & 255;
  if (msgBuffIdxBackup_15 < _21)
    goto <bb 6>; [5.50%]
  else
    goto <bb 4>; [94.50%]

  <bb 4> [local count: 507343012]:
  # DEBUG BEGIN_STMT
  ramBlockOffset_31 = ramBlockOffset_14 + 128;
  # DEBUG ramBlockOffset => ramBlockOffset_31
  # DEBUG BEGIN_STMT
  msgBuffIdxBackup_32 = msgBuffIdxBackup_15 - _21;
  # DEBUG msgBuffIdxBackup => msgBuffIdxBackup_32
  # DEBUG BEGIN_STMT
  # DEBUG i => 1

  <bb 5> [local count: 1073741824]:
  # mb_size_12 = PHI <0(2), mb_size_29(4)>
  # ramBlockOffset_14 = PHI <0(2), ramBlockOffset_31(4)>
  # msgBuffIdxBackup_15 = PHI <msgBuffIdx_23(D)(2), msgBuffIdxBackup_32(4)>
  # i_16 = PHI <0(2), 1(4)>
  # maxMbNum_17 = PHI <0(2), maxMbNum_30(4)>
  # DEBUG maxMbNum => maxMbNum_17
  # DEBUG i => i_16
  # DEBUG msgBuffIdxBackup => msgBuffIdxBackup_15
  # DEBUG ramBlockOffset => ramBlockOffset_14
  # DEBUG mb_size => mb_size_12
  # DEBUG BEGIN_STMT
  if (i_16 == 0)
    goto <bb 3>; [50.00%]
  else
    goto <bb 6>; [50.00%]

  <bb 6> [local count: 566398813]:
  # mb_size_13 = PHI <mb_size_29(3), mb_size_12(5)>
  # maxMbNum_18 = PHI <maxMbNum_30(3), maxMbNum_17(5)>
  # ramBlockOffset_5 = PHI <ramBlockOffset_14(3), ramBlockOffset_14(5)>
  # msgBuffIdxBackup_22 = PHI <msgBuffIdxBackup_15(3), msgBuffIdxBackup_15(5)>
  # DEBUG maxMbNum => maxMbNum_18
  # DEBUG mb_size => mb_size_13
  # DEBUG BEGIN_STMT
  _6 = (long unsigned int) maxMbNum_18;
  _7 = msgBuffIdxBackup_22 % _6;
  _8 = mb_size_13 >> 2;
  _9 = (long unsigned int) _8;
  _10 = _7 * _9;
  mb_index_33 = ramBlockOffset_5 + _10;
  # DEBUG mb_index => mb_index_33
  # DEBUG BEGIN_STMT
  _11 = mb_index_33 * 4;
  pAddressRet_34 = RAM_25 + _11;
  # DEBUG pAddressRet => pAddressRet_34
  # DEBUG BEGIN_STMT
  return pAddressRet_34;

}


FlexCAN_ComputePayloadSize (uint8 dlcValue)
{
  uint8 ret;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  # DEBUG ret => 8
  # DEBUG BEGIN_STMT
  if (dlcValue_2(D) <= 8)
    goto <bb 4>; [50.00%]
  else
    goto <bb 3>; [50.00%]

  <bb 3> [local count: 536870912]:
  ret_3 = FlexCAN_ComputePayloadSize.part.0 (dlcValue_2(D));

  <bb 4> [local count: 1073741824]:
  # ret_1 = PHI <dlcValue_2(D)(2), ret_3(3)>
<L16>:
<L13>:
  # DEBUG ret => ret_1
  # DEBUG BEGIN_STMT
  return ret_1;

}


FlexCAN_ClearRAM (struct FLEXCAN_Type * base)
{
  volatile uint32 * RAM;
  uint32 RAM_size;
  uint32 databyte;
  long unsigned int _1;
  long unsigned int base.2_2;
  long unsigned int _3;
  long unsigned int _4;
  volatile uint32 * _5;
  long unsigned int _6;
  volatile uint32 * _7;

  <bb 2> [local count: 118111600]:
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  _1 = FlexCAN_GetMaxMbNum (base_13(D));
  RAM_size_14 = _1 * 4;
  # DEBUG RAM_size => RAM_size_14
  # DEBUG BEGIN_STMT
  # DEBUG RXIMR_size => _1
  # DEBUG BEGIN_STMT
  base.2_2 = (long unsigned int) base_13(D);
  _3 = base.2_2 + 128;
  RAM_15 = (volatile uint32 *) _3;
  # DEBUG RAM => RAM_15
  # DEBUG BEGIN_STMT
  # DEBUG databyte => 0
  goto <bb 4>; [100.00%]

  <bb 3> [local count: 955630220]:
  # DEBUG BEGIN_STMT
  _4 = databyte_8 * 4;
  _5 = RAM_15 + _4;
  *_5 ={v} 0;
  # DEBUG BEGIN_STMT
  databyte_20 = databyte_8 + 1;
  # DEBUG databyte => databyte_20

  <bb 4> [local count: 1073741821]:
  # databyte_8 = PHI <0(2), databyte_20(3)>
  # DEBUG databyte => databyte_8
  # DEBUG BEGIN_STMT
  if (databyte_8 < RAM_size_14)
    goto <bb 3>; [89.00%]
  else
    goto <bb 5>; [11.00%]

  <bb 5> [local count: 118111600]:
  # DEBUG BEGIN_STMT
  RAM_16 = &base_13(D)->RXIMR;
  # DEBUG RAM => RAM_16
  # DEBUG BEGIN_STMT
  # DEBUG databyte => 0
  goto <bb 7>; [100.00%]

  <bb 6> [local count: 955630224]:
  # DEBUG BEGIN_STMT
  _6 = databyte_9 * 4;
  _7 = RAM_16 + _6;
  *_7 ={v} 0;
  # DEBUG BEGIN_STMT
  databyte_18 = databyte_9 + 1;
  # DEBUG databyte => databyte_18

  <bb 7> [local count: 1073741824]:
  # databyte_9 = PHI <0(5), databyte_18(6)>
  # DEBUG databyte => databyte_9
  # DEBUG BEGIN_STMT
  if (_1 > databyte_9)
    goto <bb 6>; [89.00%]
  else
    goto <bb 8>; [11.00%]

  <bb 8> [local count: 118111601]:
  return;

}


FlexCAN_SetPNPayloadLowFilter2 (struct FLEXCAN_Type * pBase, const uint8 * pPayload)
{
  unsigned char _1;
  long unsigned int _2;
  long unsigned int _3;
  unsigned char _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  unsigned char _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _11;
  unsigned char _12;
  long unsigned int _13;
  long unsigned int _14;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  _1 = *pPayload_16(D);
  _2 = (long unsigned int) _1;
  _3 = _2 << 24;
  _4 = MEM[(const uint8 *)pPayload_16(D) + 1B];
  _5 = (long unsigned int) _4;
  _6 = _5 << 16;
  _7 = _3 | _6;
  _8 = MEM[(const uint8 *)pPayload_16(D) + 2B];
  _9 = (long unsigned int) _8;
  _10 = _9 << 8;
  _11 = _7 | _10;
  _12 = MEM[(const uint8 *)pPayload_16(D) + 3B];
  _13 = (long unsigned int) _12;
  _14 = _11 | _13;
  pBase_17(D)->PL2_PLMASK_LO ={v} _14;
  return;

}


FlexCAN_SetPNPayloadHighFilter2 (struct FLEXCAN_Type * pBase, const uint8 * pPayload)
{
  unsigned char _1;
  long unsigned int _2;
  long unsigned int _3;
  unsigned char _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  unsigned char _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _11;
  unsigned char _12;
  long unsigned int _13;
  long unsigned int _14;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  _1 = MEM[(const uint8 *)pPayload_15(D) + 4B];
  _2 = (long unsigned int) _1;
  _3 = _2 << 24;
  _4 = MEM[(const uint8 *)pPayload_15(D) + 5B];
  _5 = (long unsigned int) _4;
  _6 = _5 << 16;
  _7 = _3 | _6;
  _8 = MEM[(const uint8 *)pPayload_15(D) + 6B];
  _9 = (long unsigned int) _8;
  _10 = _9 << 8;
  _11 = _7 | _10;
  _12 = MEM[(const uint8 *)pPayload_15(D) + 7B];
  _13 = (long unsigned int) _12;
  _14 = _11 | _13;
  pBase_17(D)->PL2_PLMASK_HI ={v} _14;
  return;

}


FlexCAN_SetPNPayloadLowFilter1 (struct FLEXCAN_Type * pBase, const uint8 * pPayload)
{
  unsigned char _1;
  long unsigned int _2;
  long unsigned int _3;
  unsigned char _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  unsigned char _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _11;
  unsigned char _12;
  long unsigned int _13;
  long unsigned int _14;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  _1 = *pPayload_16(D);
  _2 = (long unsigned int) _1;
  _3 = _2 << 24;
  _4 = MEM[(const uint8 *)pPayload_16(D) + 1B];
  _5 = (long unsigned int) _4;
  _6 = _5 << 16;
  _7 = _3 | _6;
  _8 = MEM[(const uint8 *)pPayload_16(D) + 2B];
  _9 = (long unsigned int) _8;
  _10 = _9 << 8;
  _11 = _7 | _10;
  _12 = MEM[(const uint8 *)pPayload_16(D) + 3B];
  _13 = (long unsigned int) _12;
  _14 = _11 | _13;
  pBase_17(D)->PL1_LO ={v} _14;
  return;

}


FlexCAN_SetPNPayloadHighFilter1 (struct FLEXCAN_Type * pBase, const uint8 * pPayload)
{
  unsigned char _1;
  long unsigned int _2;
  long unsigned int _3;
  unsigned char _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  unsigned char _8;
  long unsigned int _9;
  long unsigned int _10;
  long unsigned int _11;
  unsigned char _12;
  long unsigned int _13;
  long unsigned int _14;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  _1 = MEM[(const uint8 *)pPayload_15(D) + 4B];
  _2 = (long unsigned int) _1;
  _3 = _2 << 24;
  _4 = MEM[(const uint8 *)pPayload_15(D) + 5B];
  _5 = (long unsigned int) _4;
  _6 = _5 << 16;
  _7 = _3 | _6;
  _8 = MEM[(const uint8 *)pPayload_15(D) + 6B];
  _9 = (long unsigned int) _8;
  _10 = _9 << 8;
  _11 = _7 | _10;
  _12 = MEM[(const uint8 *)pPayload_15(D) + 7B];
  _13 = (long unsigned int) _12;
  _14 = _11 | _13;
  pBase_17(D)->PL1_HI ={v} _14;
  return;

}


FlexCAN_SetPNDlcFilter (struct FLEXCAN_Type * pBase, uint8 u8DlcLow, uint8 u8DlcHigh)
{
  uint32 tmp;
  long unsigned int _1;
  long unsigned int _2;
  long unsigned int _3;
  long unsigned int _4;
  unsigned char _14;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  tmp_7 ={v} pBase_6(D)->FLT_DLC;
  # DEBUG tmp => tmp_7
  # DEBUG BEGIN_STMT
  tmp_8 = tmp_7 & 4293984240;
  # DEBUG tmp => tmp_8
  # DEBUG BEGIN_STMT
  _14 = u8DlcHigh_9(D) & 15;
  _1 = (long unsigned int) _14;
  tmp_10 = _1 | tmp_8;
  # DEBUG tmp => tmp_10
  # DEBUG BEGIN_STMT
  _2 = (long unsigned int) u8DlcLow_11(D);
  _3 = _2 << 16;
  _4 = _3 & 983040;
  tmp_12 = _4 | tmp_10;
  # DEBUG tmp => tmp_12
  # DEBUG BEGIN_STMT
  pBase_6(D)->FLT_DLC ={v} tmp_12;
  return;

}


FlexCAN_SetPNIdFilter2 (struct FLEXCAN_Type * pBase, const struct Flexcan_Ip_PnConfigType * pPnConfig)
{
  uint32 u32Tmp;
  _Bool _1;
  _Bool _2;
  _Bool _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _6;
  long unsigned int _7;
  long unsigned int _8;
  long unsigned int iftmp.23_10;
  long unsigned int iftmp.24_11;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  u32Tmp_14 ={v} pBase_13(D)->FLT_ID2_IDMASK;
  # DEBUG u32Tmp => u32Tmp_14
  # DEBUG BEGIN_STMT
  u32Tmp_15 = u32Tmp_14 & 2147483648;
  # DEBUG u32Tmp => u32Tmp_15
  # DEBUG BEGIN_STMT
  _1 = pPnConfig_16(D)->idFilter2.bExtendedId;
  if (_1 != 0)
    goto <bb 4>; [50.00%]
  else
    goto <bb 3>; [50.00%]

  <bb 3> [local count: 536870913]:

  <bb 4> [local count: 1073741824]:
  # iftmp.23_10 = PHI <1073741824(2), 0(3)>
  u32Tmp_17 = iftmp.23_10 | u32Tmp_15;
  # DEBUG u32Tmp => u32Tmp_17
  # DEBUG BEGIN_STMT
  _2 = pPnConfig_16(D)->idFilter2.bRemoteFrame;
  if (_2 != 0)
    goto <bb 6>; [50.00%]
  else
    goto <bb 5>; [50.00%]

  <bb 5> [local count: 536870913]:

  <bb 6> [local count: 1073741824]:
  # iftmp.24_11 = PHI <536870912(4), 0(5)>
  u32Tmp_18 = iftmp.24_11 | u32Tmp_17;
  # DEBUG u32Tmp => u32Tmp_18
  # DEBUG BEGIN_STMT
  _3 = pPnConfig_16(D)->idFilter1.bExtendedId;
  if (_3 != 0)
    goto <bb 7>; [50.00%]
  else
    goto <bb 8>; [50.00%]

  <bb 7> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  _4 = pPnConfig_16(D)->idFilter2.u32Id;
  _5 = _4 & 536870911;
  u32Tmp_20 = _5 | u32Tmp_18;
  # DEBUG u32Tmp => u32Tmp_20
  goto <bb 9>; [100.00%]

  <bb 8> [local count: 536870913]:
  # DEBUG BEGIN_STMT
  _6 = pPnConfig_16(D)->idFilter2.u32Id;
  _7 = _6 << 18;
  _8 = _7 & 536870911;
  u32Tmp_19 = _8 | u32Tmp_18;
  # DEBUG u32Tmp => u32Tmp_19

  <bb 9> [local count: 1073741824]:
  # u32Tmp_9 = PHI <u32Tmp_20(7), u32Tmp_19(8)>
  # DEBUG u32Tmp => u32Tmp_9
  # DEBUG BEGIN_STMT
  pBase_13(D)->FLT_ID2_IDMASK ={v} u32Tmp_9;
  return;

}


FlexCAN_SetPNFilteringSelection (struct FLEXCAN_Type * pBase, const struct Flexcan_Ip_PnConfigType * pPnConfig)
{
  uint32 u32Tmp;
  _Bool _1;
  _Bool _2;
  short unsigned int _3;
  long unsigned int _4;
  long unsigned int _5;
  long unsigned int _6;
  <unnamed type> _7;
  long unsigned int _8;
  <unnamed type> _9;
  long unsigned int _10;
  long unsigned int _11;
  <unnamed type> _12;
  long unsigned int _13;
  long unsigned int _14;
  long unsigned int iftmp.19_15;
  long unsigned int iftmp.20_16;

  <bb 2> [local count: 1073741824]:
  # DEBUG BEGIN_STMT
  # DEBUG BEGIN_STMT
  u32Tmp_19 ={v} pBase_18(D)->CTRL1_PN;
  # DEBUG u32Tmp => u32Tmp_19
  # DEBUG BEGIN_STMT
  u32Tmp_20 = u32Tmp_19 & 4294705344;
  # DEBUG u32Tmp => u32Tmp_20
  # DEBUG BEGIN_STMT
  _1 = pPnConfig_21(D)->bWakeUpTimeout;
  if (_1 != 0)
    goto <bb 4>; [50.00%]
  else
    goto <bb 3>; [50.00%]

  <bb 3> [local count: 536870913]:

  <bb 4> [local count: 1073741824]:
  # iftmp.19_15 = PHI <131072(2), 0(3)>
  u32Tmp_22 = iftmp.19_15 | u32Tmp_20;
  # DEBUG u32Tmp => u32Tmp_22
  # DEBUG BEGIN_STMT
  _2 = pPnConfig_21(D)->bWakeUpMatch;
  if (_2 != 0)
    goto <bb 6>; [50.00%]
  else
    goto <bb 5>; [50.00%]

  <bb 5> [local count: 536870913]:

  <bb 6> [local count: 1073741824]:
  # iftmp.20_16 = PHI <65536(4), 0(5)>
  u32Tmp_23 = iftmp.20_16 | u32Tmp_22;
  # DEBUG u32Tmp => u32Tmp_23
  # DEBUG BEGIN_STMT
  _3 = pPnConfig_21(D)->u16NumMatches;
  _4 = (long unsigned int) _3;
  _5 = _4 << 8;
  _6 = _5 & 65535;
  u32Tmp_24 = _6 | u32Tmp_23;
  # DEBUG u32Tmp => u32Tmp_24
  # DEBUG BEGIN_STMT
  _7 = pPnConfig_21(D)->eFilterComb;
  _8 = _7 & 3;
  u32Tmp_25 = _8 | u32Tmp_24;
  # DEBUG u32Tmp => u32Tmp_25
  # DEBUG BEGIN_STMT
  _9 = pPnConfig_21(D)->eIdFilterType;
  _10 = _9 << 2;
  _11 = _10 & 12;
  u32Tmp_26 = _11 | u32Tmp_25;
  # DEBUG u32Tmp => u32Tmp_26
  # DEBUG BEGIN_STMT
  _12 = pPnConfig_21(D)->ePayloadFilterType;
  _13 = _12 << 4;
  _14 = _13 & 48;
  u32Tmp_27 = _14 | u32Tmp_26;
  # DEBUG u32Tmp => u32Tmp_27
  # DEBUG BEGIN_STMT
  pBase_18(D)->CTRL1_PN ={v} u32Tmp_27;
  return;

}


