; LLVM IR from ctlst-tech/catpilot :: bsp/mcu/core/stm32/h753/hal/src (stm32h7xx_hal_spi)

; Unoptimized IR (clang -disable-llvm-passes):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.__SPI_HandleTypeDef = type { ptr, %struct.SPI_InitTypeDef, ptr, i16, i16, ptr, i16, i16, i32, ptr, ptr, ptr, ptr, i32, i32, i32 }
%struct.SPI_InitTypeDef = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }
%struct.SPI_TypeDef = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, [3 x i32], i32, [3 x i32], i32, i32, i32, i32, i32 }

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #0

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #0

declare i32 @HAL_GetTick() #1

; Function Attrs: nounwind uwtable
declare hidden void @SPI_CloseTransfer(ptr noundef) #2

; Function Attrs: nounwind uwtable
declare hidden i32 @SPI_WaitOnFlagUntilTimeout(ptr noundef, i32 noundef, i32 noundef, i32 noundef, i32 noundef) #2

; Function Attrs: nounwind uwtable
define dso_local i32 @HAL_SPI_TransmitReceive(ptr noundef %0, ptr noundef %1, ptr noundef %2, i16 noundef zeroext %3, i32 noundef %4) #2 {
  %6 = alloca i32, align 4
  %7 = alloca ptr, align 8
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca i16, align 2
  %11 = alloca i32, align 4
  %12 = alloca i32, align 4
  %13 = alloca i32, align 4
  %14 = alloca ptr, align 8
  %15 = alloca ptr, align 8
  %16 = alloca i32, align 4
  %17 = alloca i32, align 4
  %18 = alloca i16, align 2
  %19 = alloca i16, align 2
  %20 = alloca i32, align 4
  store ptr %0, ptr %7, align 8, !tbaa !5
  store ptr %1, ptr %8, align 8, !tbaa !5
  store ptr %2, ptr %9, align 8, !tbaa !5
  store i16 %3, ptr %10, align 2, !tbaa !9
  store i32 %4, ptr %11, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #3
  store i32 0, ptr %13, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #3
  %21 = load ptr, ptr %7, align 8, !tbaa !5
  %22 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %21, i32 0, i32 0
  %23 = load ptr, ptr %22, align 8, !tbaa !13
  %24 = getelementptr inbounds %struct.SPI_TypeDef, ptr %23, i32 0, i32 8
  store ptr %24, ptr %14, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #3
  %25 = load ptr, ptr %7, align 8, !tbaa !5
  %26 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %25, i32 0, i32 0
  %27 = load ptr, ptr %26, align 8, !tbaa !13
  %28 = getelementptr inbounds %struct.SPI_TypeDef, ptr %27, i32 0, i32 10
  store ptr %28, ptr %15, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #3
  call void @llvm.lifetime.start.p0(i64 2, ptr %18) #3
  call void @llvm.lifetime.start.p0(i64 2, ptr %19) #3
  br label %29

29:                                               ; preds = %5
  %30 = load ptr, ptr %7, align 8, !tbaa !5
  %31 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %30, i32 0, i32 13
  %32 = load i32, ptr %31, align 8, !tbaa !16
  %33 = icmp eq i32 %32, 1
  br i1 %33, label %34, label %35

34:                                               ; preds = %29
  store i32 2, ptr %6, align 4
  store i32 1, ptr %20, align 4
  br label %711

35:                                               ; preds = %29
  %36 = load ptr, ptr %7, align 8, !tbaa !5
  %37 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %36, i32 0, i32 13
  store i32 1, ptr %37, align 8, !tbaa !16
  br label %38

38:                                               ; preds = %35
  br label %39

39:                                               ; preds = %38
  br label %40

40:                                               ; preds = %39
  %41 = call i32 @HAL_GetTick()
  store i32 %41, ptr %16, align 4, !tbaa !11
  %42 = load i16, ptr %10, align 2, !tbaa !9
  store i16 %42, ptr %18, align 2, !tbaa !9
  %43 = load i16, ptr %10, align 2, !tbaa !9
  store i16 %43, ptr %19, align 2, !tbaa !9
  %44 = load ptr, ptr %7, align 8, !tbaa !5
  %45 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %44, i32 0, i32 14
  %46 = load volatile i32, ptr %45, align 4, !tbaa !17
  store i32 %46, ptr %12, align 4, !tbaa !11
  %47 = load ptr, ptr %7, align 8, !tbaa !5
  %48 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %47, i32 0, i32 1
  %49 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %48, i32 0, i32 0
  %50 = load i32, ptr %49, align 8, !tbaa !18
  store i32 %50, ptr %17, align 4, !tbaa !11
  %51 = load i32, ptr %12, align 4, !tbaa !11
  %52 = icmp eq i32 %51, 1
  br i1 %52, label %74, label %53

53:                                               ; preds = %40
  %54 = load i32, ptr %17, align 4, !tbaa !11
  %55 = zext i32 %54 to i64
  %56 = icmp eq i64 %55, 4194304
  br i1 %56, label %57, label %67

57:                                               ; preds = %53
  %58 = load ptr, ptr %7, align 8, !tbaa !5
  %59 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %58, i32 0, i32 1
  %60 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %59, i32 0, i32 1
  %61 = load i32, ptr %60, align 4, !tbaa !19
  %62 = zext i32 %61 to i64
  %63 = icmp eq i64 %62, 0
  br i1 %63, label %64, label %67

64:                                               ; preds = %57
  %65 = load i32, ptr %12, align 4, !tbaa !11
  %66 = icmp eq i32 %65, 4
  br i1 %66, label %74, label %67

67:                                               ; preds = %64, %57, %53
  store i32 2, ptr %13, align 4, !tbaa !11
  br label %68

68:                                               ; preds = %67
  %69 = load ptr, ptr %7, align 8, !tbaa !5
  %70 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %69, i32 0, i32 13
  store i32 0, ptr %70, align 8, !tbaa !16
  br label %71

71:                                               ; preds = %68
  br label %72

72:                                               ; preds = %71
  %73 = load i32, ptr %13, align 4, !tbaa !11
  store i32 %73, ptr %6, align 4
  store i32 1, ptr %20, align 4
  br label %711

74:                                               ; preds = %64, %40
  %75 = load ptr, ptr %8, align 8, !tbaa !5
  %76 = icmp eq ptr %75, null
  br i1 %76, label %84, label %77

77:                                               ; preds = %74
  %78 = load ptr, ptr %9, align 8, !tbaa !5
  %79 = icmp eq ptr %78, null
  br i1 %79, label %84, label %80

80:                                               ; preds = %77
  %81 = load i16, ptr %10, align 2, !tbaa !9
  %82 = zext i16 %81 to i64
  %83 = icmp eq i64 %82, 0
  br i1 %83, label %84, label %91

84:                                               ; preds = %80, %77, %74
  store i32 1, ptr %13, align 4, !tbaa !11
  br label %85

85:                                               ; preds = %84
  %86 = load ptr, ptr %7, align 8, !tbaa !5
  %87 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %86, i32 0, i32 13
  store i32 0, ptr %87, align 8, !tbaa !16
  br label %88

88:                                               ; preds = %85
  br label %89

89:                                               ; preds = %88
  %90 = load i32, ptr %13, align 4, !tbaa !11
  store i32 %90, ptr %6, align 4
  store i32 1, ptr %20, align 4
  br label %711

91:                                               ; preds = %80
  %92 = load ptr, ptr %7, align 8, !tbaa !5
  %93 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %92, i32 0, i32 14
  %94 = load volatile i32, ptr %93, align 4, !tbaa !17
  %95 = icmp ne i32 %94, 4
  br i1 %95, label %96, label %99

96:                                               ; preds = %91
  %97 = load ptr, ptr %7, align 8, !tbaa !5
  %98 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %97, i32 0, i32 14
  store volatile i32 5, ptr %98, align 4, !tbaa !17
  br label %99

99:                                               ; preds = %96, %91
  %100 = load ptr, ptr %7, align 8, !tbaa !5
  %101 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %100, i32 0, i32 15
  store volatile i32 0, ptr %101, align 8, !tbaa !20
  %102 = load ptr, ptr %9, align 8, !tbaa !5
  %103 = load ptr, ptr %7, align 8, !tbaa !5
  %104 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %103, i32 0, i32 5
  store ptr %102, ptr %104, align 8, !tbaa !21
  %105 = load i16, ptr %10, align 2, !tbaa !9
  %106 = load ptr, ptr %7, align 8, !tbaa !5
  %107 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %106, i32 0, i32 7
  store volatile i16 %105, ptr %107, align 2, !tbaa !22
  %108 = load i16, ptr %10, align 2, !tbaa !9
  %109 = load ptr, ptr %7, align 8, !tbaa !5
  %110 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %109, i32 0, i32 6
  store i16 %108, ptr %110, align 8, !tbaa !23
  %111 = load ptr, ptr %8, align 8, !tbaa !5
  %112 = load ptr, ptr %7, align 8, !tbaa !5
  %113 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %112, i32 0, i32 2
  store ptr %111, ptr %113, align 8, !tbaa !24
  %114 = load i16, ptr %10, align 2, !tbaa !9
  %115 = load ptr, ptr %7, align 8, !tbaa !5
  %116 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %115, i32 0, i32 4
  store volatile i16 %114, ptr %116, align 2, !tbaa !25
  %117 = load i16, ptr %10, align 2, !tbaa !9
  %118 = load ptr, ptr %7, align 8, !tbaa !5
  %119 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %118, i32 0, i32 3
  store i16 %117, ptr %119, align 8, !tbaa !26
  %120 = load ptr, ptr %7, align 8, !tbaa !5
  %121 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %120, i32 0, i32 9
  store ptr null, ptr %121, align 8, !tbaa !27
  %122 = load ptr, ptr %7, align 8, !tbaa !5
  %123 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %122, i32 0, i32 10
  store ptr null, ptr %123, align 8, !tbaa !28
  %124 = load ptr, ptr %7, align 8, !tbaa !5
  %125 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %124, i32 0, i32 0
  %126 = load ptr, ptr %125, align 8, !tbaa !13
  %127 = getelementptr inbounds %struct.SPI_TypeDef, ptr %126, i32 0, i32 1
  %128 = load volatile i32, ptr %127, align 4, !tbaa !29
  %129 = zext i32 %128 to i64
  %130 = and i64 %129, -65536
  %131 = load i16, ptr %10, align 2, !tbaa !9
  %132 = zext i16 %131 to i64
  %133 = or i64 %130, %132
  %134 = trunc i64 %133 to i32
  %135 = load ptr, ptr %7, align 8, !tbaa !5
  %136 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %135, i32 0, i32 0
  %137 = load ptr, ptr %136, align 8, !tbaa !13
  %138 = getelementptr inbounds %struct.SPI_TypeDef, ptr %137, i32 0, i32 1
  store volatile i32 %134, ptr %138, align 4, !tbaa !29
  %139 = load ptr, ptr %7, align 8, !tbaa !5
  %140 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %139, i32 0, i32 0
  %141 = load ptr, ptr %140, align 8, !tbaa !13
  %142 = getelementptr inbounds %struct.SPI_TypeDef, ptr %141, i32 0, i32 0
  %143 = load volatile i32, ptr %142, align 4, !tbaa !31
  %144 = zext i32 %143 to i64
  %145 = or i64 %144, 1
  %146 = trunc i64 %145 to i32
  store volatile i32 %146, ptr %142, align 4, !tbaa !31
  %147 = load ptr, ptr %7, align 8, !tbaa !5
  %148 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %147, i32 0, i32 1
  %149 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %148, i32 0, i32 0
  %150 = load i32, ptr %149, align 8, !tbaa !18
  %151 = zext i32 %150 to i64
  %152 = icmp eq i64 %151, 4194304
  br i1 %152, label %153, label %162

153:                                              ; preds = %99
  %154 = load ptr, ptr %7, align 8, !tbaa !5
  %155 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %154, i32 0, i32 0
  %156 = load ptr, ptr %155, align 8, !tbaa !13
  %157 = getelementptr inbounds %struct.SPI_TypeDef, ptr %156, i32 0, i32 0
  %158 = load volatile i32, ptr %157, align 4, !tbaa !31
  %159 = zext i32 %158 to i64
  %160 = or i64 %159, 512
  %161 = trunc i64 %160 to i32
  store volatile i32 %161, ptr %157, align 4, !tbaa !31
  br label %162

162:                                              ; preds = %153, %99
  %163 = load ptr, ptr %7, align 8, !tbaa !5
  %164 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %163, i32 0, i32 1
  %165 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %164, i32 0, i32 2
  %166 = load i32, ptr %165, align 8, !tbaa !32
  %167 = zext i32 %166 to i64
  %168 = icmp ugt i64 %167, 15
  br i1 %168, label %169, label %275

169:                                              ; preds = %162
  br label %170

170:                                              ; preds = %273, %169
  %171 = load i16, ptr %18, align 2, !tbaa !9
  %172 = zext i16 %171 to i64
  %173 = icmp ugt i64 %172, 0
  br i1 %173, label %178, label %174

174:                                              ; preds = %170
  %175 = load i16, ptr %19, align 2, !tbaa !9
  %176 = zext i16 %175 to i64
  %177 = icmp ugt i64 %176, 0
  br label %178

178:                                              ; preds = %174, %170
  %179 = phi i1 [ true, %170 ], [ %177, %174 ]
  br i1 %179, label %180, label %274

180:                                              ; preds = %178
  %181 = load ptr, ptr %7, align 8, !tbaa !5
  %182 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %181, i32 0, i32 0
  %183 = load ptr, ptr %182, align 8, !tbaa !13
  %184 = getelementptr inbounds %struct.SPI_TypeDef, ptr %183, i32 0, i32 5
  %185 = load volatile i32, ptr %184, align 4, !tbaa !33
  %186 = zext i32 %185 to i64
  %187 = and i64 %186, 2
  %188 = icmp eq i64 %187, 2
  br i1 %188, label %189, label %213

189:                                              ; preds = %180
  %190 = load i16, ptr %18, align 2, !tbaa !9
  %191 = zext i16 %190 to i64
  %192 = icmp ugt i64 %191, 0
  br i1 %192, label %193, label %213

193:                                              ; preds = %189
  %194 = load ptr, ptr %7, align 8, !tbaa !5
  %195 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %194, i32 0, i32 2
  %196 = load ptr, ptr %195, align 8, !tbaa !24
  %197 = load i32, ptr %196, align 4, !tbaa !11
  %198 = load ptr, ptr %7, align 8, !tbaa !5
  %199 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %198, i32 0, i32 0
  %200 = load ptr, ptr %199, align 8, !tbaa !13
  %201 = getelementptr inbounds %struct.SPI_TypeDef, ptr %200, i32 0, i32 8
  store volatile i32 %197, ptr %201, align 4, !tbaa !11
  %202 = load ptr, ptr %7, align 8, !tbaa !5
  %203 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %202, i32 0, i32 2
  %204 = load ptr, ptr %203, align 8, !tbaa !24
  %205 = getelementptr inbounds i8, ptr %204, i64 4
  store ptr %205, ptr %203, align 8, !tbaa !24
  %206 = load ptr, ptr %7, align 8, !tbaa !5
  %207 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %206, i32 0, i32 4
  %208 = load volatile i16, ptr %207, align 2, !tbaa !25
  %209 = add i16 %208, -1
  store volatile i16 %209, ptr %207, align 2, !tbaa !25
  %210 = load ptr, ptr %7, align 8, !tbaa !5
  %211 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %210, i32 0, i32 4
  %212 = load volatile i16, ptr %211, align 2, !tbaa !25
  store i16 %212, ptr %18, align 2, !tbaa !9
  br label %213

213:                                              ; preds = %193, %189, %180
  %214 = load ptr, ptr %7, align 8, !tbaa !5
  %215 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %214, i32 0, i32 0
  %216 = load ptr, ptr %215, align 8, !tbaa !13
  %217 = getelementptr inbounds %struct.SPI_TypeDef, ptr %216, i32 0, i32 5
  %218 = load volatile i32, ptr %217, align 4, !tbaa !33
  %219 = zext i32 %218 to i64
  %220 = and i64 %219, 32776
  %221 = icmp ne i64 %220, 0
  br i1 %221, label %222, label %246

222:                                              ; preds = %213
  %223 = load i16, ptr %19, align 2, !tbaa !9
  %224 = zext i16 %223 to i64
  %225 = icmp ugt i64 %224, 0
  br i1 %225, label %226, label %246

226:                                              ; preds = %222
  %227 = load ptr, ptr %7, align 8, !tbaa !5
  %228 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %227, i32 0, i32 0
  %229 = load ptr, ptr %228, align 8, !tbaa !13
  %230 = getelementptr inbounds %struct.SPI_TypeDef, ptr %229, i32 0, i32 10
  %231 = load volatile i32, ptr %230, align 4, !tbaa !11
  %232 = load ptr, ptr %7, align 8, !tbaa !5
  %233 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %232, i32 0, i32 5
  %234 = load ptr, ptr %233, align 8, !tbaa !21
  store i32 %231, ptr %234, align 4, !tbaa !11
  %235 = load ptr, ptr %7, align 8, !tbaa !5
  %236 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %235, i32 0, i32 5
  %237 = load ptr, ptr %236, align 8, !tbaa !21
  %238 = getelementptr inbounds i8, ptr %237, i64 4
  store ptr %238, ptr %236, align 8, !tbaa !21
  %239 = load ptr, ptr %7, align 8, !tbaa !5
  %240 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %239, i32 0, i32 7
  %241 = load volatile i16, ptr %240, align 2, !tbaa !22
  %242 = add i16 %241, -1
  store volatile i16 %242, ptr %240, align 2, !tbaa !22
  %243 = load ptr, ptr %7, align 8, !tbaa !5
  %244 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %243, i32 0, i32 7
  %245 = load volatile i16, ptr %244, align 2, !tbaa !22
  store i16 %245, ptr %19, align 2, !tbaa !9
  br label %246

246:                                              ; preds = %226, %222, %213
  %247 = call i32 @HAL_GetTick()
  %248 = load i32, ptr %16, align 4, !tbaa !11
  %249 = sub i32 %247, %248
  %250 = load i32, ptr %11, align 4, !tbaa !11
  %251 = icmp uge i32 %249, %250
  br i1 %251, label %252, label %255

252:                                              ; preds = %246
  %253 = load i32, ptr %11, align 4, !tbaa !11
  %254 = icmp ne i32 %253, -1
  br i1 %254, label %258, label %255

255:                                              ; preds = %252, %246
  %256 = load i32, ptr %11, align 4, !tbaa !11
  %257 = icmp eq i32 %256, 0
  br i1 %257, label %258, label %273

258:                                              ; preds = %255, %252
  %259 = load ptr, ptr %7, align 8, !tbaa !5
  call void @SPI_CloseTransfer(ptr noundef %259)
  br label %260

260:                                              ; preds = %258
  %261 = load ptr, ptr %7, align 8, !tbaa !5
  %262 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %261, i32 0, i32 13
  store i32 0, ptr %262, align 8, !tbaa !16
  br label %263

263:                                              ; preds = %260
  br label %264

264:                                              ; preds = %263
  %265 = load ptr, ptr %7, align 8, !tbaa !5
  %266 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %265, i32 0, i32 15
  %267 = load volatile i32, ptr %266, align 8, !tbaa !20
  %268 = zext i32 %267 to i64
  %269 = or i64 %268, 256
  %270 = trunc i64 %269 to i32
  store volatile i32 %270, ptr %266, align 8, !tbaa !20
  %271 = load ptr, ptr %7, align 8, !tbaa !5
  %272 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %271, i32 0, i32 14
  store volatile i32 1, ptr %272, align 4, !tbaa !17
  store i32 3, ptr %6, align 4
  store i32 1, ptr %20, align 4
  br label %711

273:                                              ; preds = %255
  br label %170, !llvm.loop !34

274:                                              ; preds = %178
  br label %681

275:                                              ; preds = %162
  %276 = load ptr, ptr %7, align 8, !tbaa !5
  %277 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %276, i32 0, i32 1
  %278 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %277, i32 0, i32 2
  %279 = load i32, ptr %278, align 8, !tbaa !32
  %280 = zext i32 %279 to i64
  %281 = icmp ugt i64 %280, 7
  br i1 %281, label %282, label %448

282:                                              ; preds = %275
  br label %283

283:                                              ; preds = %446, %282
  %284 = load i16, ptr %18, align 2, !tbaa !9
  %285 = zext i16 %284 to i64
  %286 = icmp ugt i64 %285, 0
  br i1 %286, label %291, label %287

287:                                              ; preds = %283
  %288 = load i16, ptr %19, align 2, !tbaa !9
  %289 = zext i16 %288 to i64
  %290 = icmp ugt i64 %289, 0
  br label %291

291:                                              ; preds = %287, %283
  %292 = phi i1 [ true, %283 ], [ %290, %287 ]
  br i1 %292, label %293, label %447

293:                                              ; preds = %291
  %294 = load ptr, ptr %7, align 8, !tbaa !5
  %295 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %294, i32 0, i32 0
  %296 = load ptr, ptr %295, align 8, !tbaa !13
  %297 = getelementptr inbounds %struct.SPI_TypeDef, ptr %296, i32 0, i32 5
  %298 = load volatile i32, ptr %297, align 4, !tbaa !33
  %299 = zext i32 %298 to i64
  %300 = and i64 %299, 2
  %301 = icmp eq i64 %300, 2
  br i1 %301, label %302, label %357

302:                                              ; preds = %293
  %303 = load i16, ptr %18, align 2, !tbaa !9
  %304 = zext i16 %303 to i64
  %305 = icmp ugt i64 %304, 0
  br i1 %305, label %306, label %357

306:                                              ; preds = %302
  %307 = load i16, ptr %18, align 2, !tbaa !9
  %308 = zext i16 %307 to i64
  %309 = icmp ugt i64 %308, 1
  br i1 %309, label %310, label %339

310:                                              ; preds = %306
  %311 = load ptr, ptr %7, align 8, !tbaa !5
  %312 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %311, i32 0, i32 1
  %313 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %312, i32 0, i32 14
  %314 = load i32, ptr %313, align 8, !tbaa !36
  %315 = zext i32 %314 to i64
  %316 = icmp ugt i64 %315, 0
  br i1 %316, label %317, label %339

317:                                              ; preds = %310
  %318 = load ptr, ptr %7, align 8, !tbaa !5
  %319 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %318, i32 0, i32 2
  %320 = load ptr, ptr %319, align 8, !tbaa !24
  %321 = load i32, ptr %320, align 4, !tbaa !11
  %322 = load ptr, ptr %7, align 8, !tbaa !5
  %323 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %322, i32 0, i32 0
  %324 = load ptr, ptr %323, align 8, !tbaa !13
  %325 = getelementptr inbounds %struct.SPI_TypeDef, ptr %324, i32 0, i32 8
  store volatile i32 %321, ptr %325, align 4, !tbaa !11
  %326 = load ptr, ptr %7, align 8, !tbaa !5
  %327 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %326, i32 0, i32 2
  %328 = load ptr, ptr %327, align 8, !tbaa !24
  %329 = getelementptr inbounds i8, ptr %328, i64 4
  store ptr %329, ptr %327, align 8, !tbaa !24
  %330 = load ptr, ptr %7, align 8, !tbaa !5
  %331 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %330, i32 0, i32 4
  %332 = load volatile i16, ptr %331, align 2, !tbaa !25
  %333 = zext i16 %332 to i32
  %334 = sub nsw i32 %333, 2
  %335 = trunc i32 %334 to i16
  store volatile i16 %335, ptr %331, align 2, !tbaa !25
  %336 = load ptr, ptr %7, align 8, !tbaa !5
  %337 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %336, i32 0, i32 4
  %338 = load volatile i16, ptr %337, align 2, !tbaa !25
  store i16 %338, ptr %18, align 2, !tbaa !9
  br label %356

339:                                              ; preds = %310, %306
  %340 = load ptr, ptr %7, align 8, !tbaa !5
  %341 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %340, i32 0, i32 2
  %342 = load ptr, ptr %341, align 8, !tbaa !24
  %343 = load i16, ptr %342, align 2, !tbaa !9
  %344 = load ptr, ptr %14, align 8, !tbaa !5
  store volatile i16 %343, ptr %344, align 2, !tbaa !9
  %345 = load ptr, ptr %7, align 8, !tbaa !5
  %346 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %345, i32 0, i32 2
  %347 = load ptr, ptr %346, align 8, !tbaa !24
  %348 = getelementptr inbounds i8, ptr %347, i64 2
  store ptr %348, ptr %346, align 8, !tbaa !24
  %349 = load ptr, ptr %7, align 8, !tbaa !5
  %350 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %349, i32 0, i32 4
  %351 = load volatile i16, ptr %350, align 2, !tbaa !25
  %352 = add i16 %351, -1
  store volatile i16 %352, ptr %350, align 2, !tbaa !25
  %353 = load ptr, ptr %7, align 8, !tbaa !5
  %354 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %353, i32 0, i32 4
  %355 = load volatile i16, ptr %354, align 2, !tbaa !25
  store i16 %355, ptr %18, align 2, !tbaa !9
  br label %356

356:                                              ; preds = %339, %317
  br label %357

357:                                              ; preds = %356, %302, %293
  %358 = load ptr, ptr %7, align 8, !tbaa !5
  %359 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %358, i32 0, i32 0
  %360 = load ptr, ptr %359, align 8, !tbaa !13
  %361 = getelementptr inbounds %struct.SPI_TypeDef, ptr %360, i32 0, i32 5
  %362 = load volatile i32, ptr %361, align 4, !tbaa !33
  %363 = zext i32 %362 to i64
  %364 = and i64 %363, 57344
  %365 = icmp ne i64 %364, 0
  br i1 %365, label %366, label %419

366:                                              ; preds = %357
  %367 = load i16, ptr %19, align 2, !tbaa !9
  %368 = zext i16 %367 to i64
  %369 = icmp ugt i64 %368, 0
  br i1 %369, label %370, label %419

370:                                              ; preds = %366
  %371 = load ptr, ptr %7, align 8, !tbaa !5
  %372 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %371, i32 0, i32 0
  %373 = load ptr, ptr %372, align 8, !tbaa !13
  %374 = getelementptr inbounds %struct.SPI_TypeDef, ptr %373, i32 0, i32 5
  %375 = load volatile i32, ptr %374, align 4, !tbaa !33
  %376 = zext i32 %375 to i64
  %377 = and i64 %376, 32768
  %378 = icmp ne i64 %377, 0
  br i1 %378, label %379, label %401

379:                                              ; preds = %370
  %380 = load ptr, ptr %7, align 8, !tbaa !5
  %381 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %380, i32 0, i32 0
  %382 = load ptr, ptr %381, align 8, !tbaa !13
  %383 = getelementptr inbounds %struct.SPI_TypeDef, ptr %382, i32 0, i32 10
  %384 = load volatile i32, ptr %383, align 4, !tbaa !11
  %385 = load ptr, ptr %7, align 8, !tbaa !5
  %386 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %385, i32 0, i32 5
  %387 = load ptr, ptr %386, align 8, !tbaa !21
  store i32 %384, ptr %387, align 4, !tbaa !11
  %388 = load ptr, ptr %7, align 8, !tbaa !5
  %389 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %388, i32 0, i32 5
  %390 = load ptr, ptr %389, align 8, !tbaa !21
  %391 = getelementptr inbounds i8, ptr %390, i64 4
  store ptr %391, ptr %389, align 8, !tbaa !21
  %392 = load ptr, ptr %7, align 8, !tbaa !5
  %393 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %392, i32 0, i32 7
  %394 = load volatile i16, ptr %393, align 2, !tbaa !22
  %395 = zext i16 %394 to i32
  %396 = sub nsw i32 %395, 2
  %397 = trunc i32 %396 to i16
  store volatile i16 %397, ptr %393, align 2, !tbaa !22
  %398 = load ptr, ptr %7, align 8, !tbaa !5
  %399 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %398, i32 0, i32 7
  %400 = load volatile i16, ptr %399, align 2, !tbaa !22
  store i16 %400, ptr %19, align 2, !tbaa !9
  br label %418

401:                                              ; preds = %370
  %402 = load ptr, ptr %15, align 8, !tbaa !5
  %403 = load volatile i16, ptr %402, align 2, !tbaa !9
  %404 = load ptr, ptr %7, align 8, !tbaa !5
  %405 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %404, i32 0, i32 5
  %406 = load ptr, ptr %405, align 8, !tbaa !21
  store i16 %403, ptr %406, align 2, !tbaa !9
  %407 = load ptr, ptr %7, align 8, !tbaa !5
  %408 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %407, i32 0, i32 5
  %409 = load ptr, ptr %408, align 8, !tbaa !21
  %410 = getelementptr inbounds i8, ptr %409, i64 2
  store ptr %410, ptr %408, align 8, !tbaa !21
  %411 = load ptr, ptr %7, align 8, !tbaa !5
  %412 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %411, i32 0, i32 7
  %413 = load volatile i16, ptr %412, align 2, !tbaa !22
  %414 = add i16 %413, -1
  store volatile i16 %414, ptr %412, align 2, !tbaa !22
  %415 = load ptr, ptr %7, align 8, !tbaa !5
  %416 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %415, i32 0, i32 7
  %417 = load volatile i16, ptr %416, align 2, !tbaa !22
  store i16 %417, ptr %19, align 2, !tbaa !9
  br label %418

418:                                              ; preds = %401, %379
  br label %419

419:                                              ; preds = %418, %366, %357
  %420 = call i32 @HAL_GetTick()
  %421 = load i32, ptr %16, align 4, !tbaa !11
  %422 = sub i32 %420, %421
  %423 = load i32, ptr %11, align 4, !tbaa !11
  %424 = icmp uge i32 %422, %423
  br i1 %424, label %425, label %428

425:                                              ; preds = %419
  %426 = load i32, ptr %11, align 4, !tbaa !11
  %427 = icmp ne i32 %426, -1
  br i1 %427, label %431, label %428

428:                                              ; preds = %425, %419
  %429 = load i32, ptr %11, align 4, !tbaa !11
  %430 = icmp eq i32 %429, 0
  br i1 %430, label %431, label %446

431:                                              ; preds = %428, %425
  %432 = load ptr, ptr %7, align 8, !tbaa !5
  call void @SPI_CloseTransfer(ptr noundef %432)
  br label %433

433:                                              ; preds = %431
  %434 = load ptr, ptr %7, align 8, !tbaa !5
  %435 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %434, i32 0, i32 13
  store i32 0, ptr %435, align 8, !tbaa !16
  br label %436

436:                                              ; preds = %433
  br label %437

437:                                              ; preds = %436
  %438 = load ptr, ptr %7, align 8, !tbaa !5
  %439 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %438, i32 0, i32 15
  %440 = load volatile i32, ptr %439, align 8, !tbaa !20
  %441 = zext i32 %440 to i64
  %442 = or i64 %441, 256
  %443 = trunc i64 %442 to i32
  store volatile i32 %443, ptr %439, align 8, !tbaa !20
  %444 = load ptr, ptr %7, align 8, !tbaa !5
  %445 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %444, i32 0, i32 14
  store volatile i32 1, ptr %445, align 4, !tbaa !17
  store i32 3, ptr %6, align 4
  store i32 1, ptr %20, align 4
  br label %711

446:                                              ; preds = %428
  br label %283, !llvm.loop !37

447:                                              ; preds = %291
  br label %680

448:                                              ; preds = %275
  br label %449

449:                                              ; preds = %678, %448
  %450 = load i16, ptr %18, align 2, !tbaa !9
  %451 = zext i16 %450 to i64
  %452 = icmp ugt i64 %451, 0
  br i1 %452, label %457, label %453

453:                                              ; preds = %449
  %454 = load i16, ptr %19, align 2, !tbaa !9
  %455 = zext i16 %454 to i64
  %456 = icmp ugt i64 %455, 0
  br label %457

457:                                              ; preds = %453, %449
  %458 = phi i1 [ true, %449 ], [ %456, %453 ]
  br i1 %458, label %459, label %679

459:                                              ; preds = %457
  %460 = load ptr, ptr %7, align 8, !tbaa !5
  %461 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %460, i32 0, i32 0
  %462 = load ptr, ptr %461, align 8, !tbaa !13
  %463 = getelementptr inbounds %struct.SPI_TypeDef, ptr %462, i32 0, i32 5
  %464 = load volatile i32, ptr %463, align 4, !tbaa !33
  %465 = zext i32 %464 to i64
  %466 = and i64 %465, 2
  %467 = icmp eq i64 %466, 2
  br i1 %467, label %468, label %557

468:                                              ; preds = %459
  %469 = load i16, ptr %18, align 2, !tbaa !9
  %470 = zext i16 %469 to i64
  %471 = icmp ugt i64 %470, 0
  br i1 %471, label %472, label %557

472:                                              ; preds = %468
  %473 = load i16, ptr %18, align 2, !tbaa !9
  %474 = zext i16 %473 to i64
  %475 = icmp ugt i64 %474, 3
  br i1 %475, label %476, label %505

476:                                              ; preds = %472
  %477 = load ptr, ptr %7, align 8, !tbaa !5
  %478 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %477, i32 0, i32 1
  %479 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %478, i32 0, i32 14
  %480 = load i32, ptr %479, align 8, !tbaa !36
  %481 = zext i32 %480 to i64
  %482 = icmp ugt i64 %481, 64
  br i1 %482, label %483, label %505

483:                                              ; preds = %476
  %484 = load ptr, ptr %7, align 8, !tbaa !5
  %485 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %484, i32 0, i32 2
  %486 = load ptr, ptr %485, align 8, !tbaa !24
  %487 = load i32, ptr %486, align 4, !tbaa !11
  %488 = load ptr, ptr %7, align 8, !tbaa !5
  %489 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %488, i32 0, i32 0
  %490 = load ptr, ptr %489, align 8, !tbaa !13
  %491 = getelementptr inbounds %struct.SPI_TypeDef, ptr %490, i32 0, i32 8
  store volatile i32 %487, ptr %491, align 4, !tbaa !11
  %492 = load ptr, ptr %7, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %492, i32 0, i32 2
  %494 = load ptr, ptr %493, align 8, !tbaa !24
  %495 = getelementptr inbounds i8, ptr %494, i64 4
  store ptr %495, ptr %493, align 8, !tbaa !24
  %496 = load ptr, ptr %7, align 8, !tbaa !5
  %497 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %496, i32 0, i32 4
  %498 = load volatile i16, ptr %497, align 2, !tbaa !25
  %499 = zext i16 %498 to i32
  %500 = sub nsw i32 %499, 4
  %501 = trunc i32 %500 to i16
  store volatile i16 %501, ptr %497, align 2, !tbaa !25
  %502 = load ptr, ptr %7, align 8, !tbaa !5
  %503 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %502, i32 0, i32 4
  %504 = load volatile i16, ptr %503, align 2, !tbaa !25
  store i16 %504, ptr %18, align 2, !tbaa !9
  br label %556

505:                                              ; preds = %476, %472
  %506 = load i16, ptr %18, align 2, !tbaa !9
  %507 = zext i16 %506 to i64
  %508 = icmp ugt i64 %507, 1
  br i1 %508, label %509, label %535

509:                                              ; preds = %505
  %510 = load ptr, ptr %7, align 8, !tbaa !5
  %511 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %510, i32 0, i32 1
  %512 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %511, i32 0, i32 14
  %513 = load i32, ptr %512, align 8, !tbaa !36
  %514 = zext i32 %513 to i64
  %515 = icmp ugt i64 %514, 0
  br i1 %515, label %516, label %535

516:                                              ; preds = %509
  %517 = load ptr, ptr %7, align 8, !tbaa !5
  %518 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %517, i32 0, i32 2
  %519 = load ptr, ptr %518, align 8, !tbaa !24
  %520 = load i16, ptr %519, align 2, !tbaa !9
  %521 = load ptr, ptr %14, align 8, !tbaa !5
  store volatile i16 %520, ptr %521, align 2, !tbaa !9
  %522 = load ptr, ptr %7, align 8, !tbaa !5
  %523 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %522, i32 0, i32 2
  %524 = load ptr, ptr %523, align 8, !tbaa !24
  %525 = getelementptr inbounds i8, ptr %524, i64 2
  store ptr %525, ptr %523, align 8, !tbaa !24
  %526 = load ptr, ptr %7, align 8, !tbaa !5
  %527 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %526, i32 0, i32 4
  %528 = load volatile i16, ptr %527, align 2, !tbaa !25
  %529 = zext i16 %528 to i32
  %530 = sub nsw i32 %529, 2
  %531 = trunc i32 %530 to i16
  store volatile i16 %531, ptr %527, align 2, !tbaa !25
  %532 = load ptr, ptr %7, align 8, !tbaa !5
  %533 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %532, i32 0, i32 4
  %534 = load volatile i16, ptr %533, align 2, !tbaa !25
  store i16 %534, ptr %18, align 2, !tbaa !9
  br label %555

535:                                              ; preds = %509, %505
  %536 = load ptr, ptr %7, align 8, !tbaa !5
  %537 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %536, i32 0, i32 2
  %538 = load ptr, ptr %537, align 8, !tbaa !24
  %539 = load i8, ptr %538, align 1, !tbaa !38
  %540 = load ptr, ptr %7, align 8, !tbaa !5
  %541 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %540, i32 0, i32 0
  %542 = load ptr, ptr %541, align 8, !tbaa !13
  %543 = getelementptr inbounds %struct.SPI_TypeDef, ptr %542, i32 0, i32 8
  store volatile i8 %539, ptr %543, align 4, !tbaa !38
  %544 = load ptr, ptr %7, align 8, !tbaa !5
  %545 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %544, i32 0, i32 2
  %546 = load ptr, ptr %545, align 8, !tbaa !24
  %547 = getelementptr inbounds i8, ptr %546, i64 1
  store ptr %547, ptr %545, align 8, !tbaa !24
  %548 = load ptr, ptr %7, align 8, !tbaa !5
  %549 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %548, i32 0, i32 4
  %550 = load volatile i16, ptr %549, align 2, !tbaa !25
  %551 = add i16 %550, -1
  store volatile i16 %551, ptr %549, align 2, !tbaa !25
  %552 = load ptr, ptr %7, align 8, !tbaa !5
  %553 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %552, i32 0, i32 4
  %554 = load volatile i16, ptr %553, align 2, !tbaa !25
  store i16 %554, ptr %18, align 2, !tbaa !9
  br label %555

555:                                              ; preds = %535, %516
  br label %556

556:                                              ; preds = %555, %483
  br label %557

557:                                              ; preds = %556, %468, %459
  %558 = load ptr, ptr %7, align 8, !tbaa !5
  %559 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %558, i32 0, i32 0
  %560 = load ptr, ptr %559, align 8, !tbaa !13
  %561 = getelementptr inbounds %struct.SPI_TypeDef, ptr %560, i32 0, i32 5
  %562 = load volatile i32, ptr %561, align 4, !tbaa !33
  %563 = zext i32 %562 to i64
  %564 = and i64 %563, 57344
  %565 = icmp ne i64 %564, 0
  br i1 %565, label %566, label %651

566:                                              ; preds = %557
  %567 = load i16, ptr %19, align 2, !tbaa !9
  %568 = zext i16 %567 to i64
  %569 = icmp ugt i64 %568, 0
  br i1 %569, label %570, label %651

570:                                              ; preds = %566
  %571 = load ptr, ptr %7, align 8, !tbaa !5
  %572 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %571, i32 0, i32 0
  %573 = load ptr, ptr %572, align 8, !tbaa !13
  %574 = getelementptr inbounds %struct.SPI_TypeDef, ptr %573, i32 0, i32 5
  %575 = load volatile i32, ptr %574, align 4, !tbaa !33
  %576 = zext i32 %575 to i64
  %577 = and i64 %576, 32768
  %578 = icmp ne i64 %577, 0
  br i1 %578, label %579, label %601

579:                                              ; preds = %570
  %580 = load ptr, ptr %7, align 8, !tbaa !5
  %581 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %580, i32 0, i32 0
  %582 = load ptr, ptr %581, align 8, !tbaa !13
  %583 = getelementptr inbounds %struct.SPI_TypeDef, ptr %582, i32 0, i32 10
  %584 = load volatile i32, ptr %583, align 4, !tbaa !11
  %585 = load ptr, ptr %7, align 8, !tbaa !5
  %586 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %585, i32 0, i32 5
  %587 = load ptr, ptr %586, align 8, !tbaa !21
  store i32 %584, ptr %587, align 4, !tbaa !11
  %588 = load ptr, ptr %7, align 8, !tbaa !5
  %589 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %588, i32 0, i32 5
  %590 = load ptr, ptr %589, align 8, !tbaa !21
  %591 = getelementptr inbounds i8, ptr %590, i64 4
  store ptr %591, ptr %589, align 8, !tbaa !21
  %592 = load ptr, ptr %7, align 8, !tbaa !5
  %593 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %592, i32 0, i32 7
  %594 = load volatile i16, ptr %593, align 2, !tbaa !22
  %595 = zext i16 %594 to i32
  %596 = sub nsw i32 %595, 4
  %597 = trunc i32 %596 to i16
  store volatile i16 %597, ptr %593, align 2, !tbaa !22
  %598 = load ptr, ptr %7, align 8, !tbaa !5
  %599 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %598, i32 0, i32 7
  %600 = load volatile i16, ptr %599, align 2, !tbaa !22
  store i16 %600, ptr %19, align 2, !tbaa !9
  br label %650

601:                                              ; preds = %570
  %602 = load ptr, ptr %7, align 8, !tbaa !5
  %603 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %602, i32 0, i32 0
  %604 = load ptr, ptr %603, align 8, !tbaa !13
  %605 = getelementptr inbounds %struct.SPI_TypeDef, ptr %604, i32 0, i32 5
  %606 = load volatile i32, ptr %605, align 4, !tbaa !33
  %607 = zext i32 %606 to i64
  %608 = and i64 %607, 24576
  %609 = icmp ugt i64 %608, 8192
  br i1 %609, label %610, label %629

610:                                              ; preds = %601
  %611 = load ptr, ptr %15, align 8, !tbaa !5
  %612 = load volatile i16, ptr %611, align 2, !tbaa !9
  %613 = load ptr, ptr %7, align 8, !tbaa !5
  %614 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %613, i32 0, i32 5
  %615 = load ptr, ptr %614, align 8, !tbaa !21
  store i16 %612, ptr %615, align 2, !tbaa !9
  %616 = load ptr, ptr %7, align 8, !tbaa !5
  %617 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %616, i32 0, i32 5
  %618 = load ptr, ptr %617, align 8, !tbaa !21
  %619 = getelementptr inbounds i8, ptr %618, i64 2
  store ptr %619, ptr %617, align 8, !tbaa !21
  %620 = load ptr, ptr %7, align 8, !tbaa !5
  %621 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %620, i32 0, i32 7
  %622 = load volatile i16, ptr %621, align 2, !tbaa !22
  %623 = zext i16 %622 to i32
  %624 = sub nsw i32 %623, 2
  %625 = trunc i32 %624 to i16
  store volatile i16 %625, ptr %621, align 2, !tbaa !22
  %626 = load ptr, ptr %7, align 8, !tbaa !5
  %627 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %626, i32 0, i32 7
  %628 = load volatile i16, ptr %627, align 2, !tbaa !22
  store i16 %628, ptr %19, align 2, !tbaa !9
  br label %649

629:                                              ; preds = %601
  %630 = load ptr, ptr %7, align 8, !tbaa !5
  %631 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %630, i32 0, i32 0
  %632 = load ptr, ptr %631, align 8, !tbaa !13
  %633 = getelementptr inbounds %struct.SPI_TypeDef, ptr %632, i32 0, i32 10
  %634 = load volatile i8, ptr %633, align 4, !tbaa !38
  %635 = load ptr, ptr %7, align 8, !tbaa !5
  %636 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %635, i32 0, i32 5
  %637 = load ptr, ptr %636, align 8, !tbaa !21
  store i8 %634, ptr %637, align 1, !tbaa !38
  %638 = load ptr, ptr %7, align 8, !tbaa !5
  %639 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %638, i32 0, i32 5
  %640 = load ptr, ptr %639, align 8, !tbaa !21
  %641 = getelementptr inbounds i8, ptr %640, i64 1
  store ptr %641, ptr %639, align 8, !tbaa !21
  %642 = load ptr, ptr %7, align 8, !tbaa !5
  %643 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %642, i32 0, i32 7
  %644 = load volatile i16, ptr %643, align 2, !tbaa !22
  %645 = add i16 %644, -1
  store volatile i16 %645, ptr %643, align 2, !tbaa !22
  %646 = load ptr, ptr %7, align 8, !tbaa !5
  %647 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %646, i32 0, i32 7
  %648 = load volatile i16, ptr %647, align 2, !tbaa !22
  store i16 %648, ptr %19, align 2, !tbaa !9
  br label %649

649:                                              ; preds = %629, %610
  br label %650

650:                                              ; preds = %649, %579
  br label %651

651:                                              ; preds = %650, %566, %557
  %652 = call i32 @HAL_GetTick()
  %653 = load i32, ptr %16, align 4, !tbaa !11
  %654 = sub i32 %652, %653
  %655 = load i32, ptr %11, align 4, !tbaa !11
  %656 = icmp uge i32 %654, %655
  br i1 %656, label %657, label %660

657:                                              ; preds = %651
  %658 = load i32, ptr %11, align 4, !tbaa !11
  %659 = icmp ne i32 %658, -1
  br i1 %659, label %663, label %660

660:                                              ; preds = %657, %651
  %661 = load i32, ptr %11, align 4, !tbaa !11
  %662 = icmp eq i32 %661, 0
  br i1 %662, label %663, label %678

663:                                              ; preds = %660, %657
  %664 = load ptr, ptr %7, align 8, !tbaa !5
  call void @SPI_CloseTransfer(ptr noundef %664)
  br label %665

665:                                              ; preds = %663
  %666 = load ptr, ptr %7, align 8, !tbaa !5
  %667 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %666, i32 0, i32 13
  store i32 0, ptr %667, align 8, !tbaa !16
  br label %668

668:                                              ; preds = %665
  br label %669

669:                                              ; preds = %668
  %670 = load ptr, ptr %7, align 8, !tbaa !5
  %671 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %670, i32 0, i32 15
  %672 = load volatile i32, ptr %671, align 8, !tbaa !20
  %673 = zext i32 %672 to i64
  %674 = or i64 %673, 256
  %675 = trunc i64 %674 to i32
  store volatile i32 %675, ptr %671, align 8, !tbaa !20
  %676 = load ptr, ptr %7, align 8, !tbaa !5
  %677 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %676, i32 0, i32 14
  store volatile i32 1, ptr %677, align 4, !tbaa !17
  store i32 3, ptr %6, align 4
  store i32 1, ptr %20, align 4
  br label %711

678:                                              ; preds = %660
  br label %449, !llvm.loop !39

679:                                              ; preds = %457
  br label %680

680:                                              ; preds = %679, %447
  br label %681

681:                                              ; preds = %680, %274
  %682 = load ptr, ptr %7, align 8, !tbaa !5
  %683 = load i32, ptr %16, align 4, !tbaa !11
  %684 = load i32, ptr %11, align 4, !tbaa !11
  %685 = call i32 @SPI_WaitOnFlagUntilTimeout(ptr noundef %682, i32 noundef 8, i32 noundef 0, i32 noundef %683, i32 noundef %684)
  %686 = icmp ne i32 %685, 0
  br i1 %686, label %687, label %694

687:                                              ; preds = %681
  %688 = load ptr, ptr %7, align 8, !tbaa !5
  %689 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %688, i32 0, i32 15
  %690 = load volatile i32, ptr %689, align 8, !tbaa !20
  %691 = zext i32 %690 to i64
  %692 = or i64 %691, 32
  %693 = trunc i64 %692 to i32
  store volatile i32 %693, ptr %689, align 8, !tbaa !20
  br label %694

694:                                              ; preds = %687, %681
  %695 = load ptr, ptr %7, align 8, !tbaa !5
  call void @SPI_CloseTransfer(ptr noundef %695)
  br label %696

696:                                              ; preds = %694
  %697 = load ptr, ptr %7, align 8, !tbaa !5
  %698 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %697, i32 0, i32 13
  store i32 0, ptr %698, align 8, !tbaa !16
  br label %699

699:                                              ; preds = %696
  br label %700

700:                                              ; preds = %699
  %701 = load ptr, ptr %7, align 8, !tbaa !5
  %702 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %701, i32 0, i32 14
  store volatile i32 1, ptr %702, align 4, !tbaa !17
  %703 = load ptr, ptr %7, align 8, !tbaa !5
  %704 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %703, i32 0, i32 15
  %705 = load volatile i32, ptr %704, align 8, !tbaa !20
  %706 = zext i32 %705 to i64
  %707 = icmp ne i64 %706, 0
  br i1 %707, label %708, label %709

708:                                              ; preds = %700
  store i32 1, ptr %6, align 4
  store i32 1, ptr %20, align 4
  br label %711

709:                                              ; preds = %700
  %710 = load i32, ptr %13, align 4, !tbaa !11
  store i32 %710, ptr %6, align 4
  store i32 1, ptr %20, align 4
  br label %711

711:                                              ; preds = %709, %708, %669, %437, %264, %89, %72, %34
  call void @llvm.lifetime.end.p0(i64 2, ptr %19) #3
  call void @llvm.lifetime.end.p0(i64 2, ptr %18) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #3
  %712 = load i32, ptr %6, align 4
  ret i32 %712
}

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"short", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"int", !7, i64 0}
!13 = !{!14, !6, i64 0}
!14 = !{!"__SPI_HandleTypeDef", !6, i64 0, !15, i64 8, !6, i64 96, !10, i64 104, !10, i64 106, !6, i64 112, !10, i64 120, !10, i64 122, !12, i64 124, !6, i64 128, !6, i64 136, !6, i64 144, !6, i64 152, !12, i64 160, !12, i64 164, !12, i64 168}
!15 = !{!"", !12, i64 0, !12, i64 4, !12, i64 8, !12, i64 12, !12, i64 16, !12, i64 20, !12, i64 24, !12, i64 28, !12, i64 32, !12, i64 36, !12, i64 40, !12, i64 44, !12, i64 48, !12, i64 52, !12, i64 56, !12, i64 60, !12, i64 64, !12, i64 68, !12, i64 72, !12, i64 76, !12, i64 80, !12, i64 84}
!16 = !{!14, !12, i64 160}
!17 = !{!14, !12, i64 164}
!18 = !{!14, !12, i64 8}
!19 = !{!14, !12, i64 12}
!20 = !{!14, !12, i64 168}
!21 = !{!14, !6, i64 112}
!22 = !{!14, !10, i64 122}
!23 = !{!14, !10, i64 120}
!24 = !{!14, !6, i64 96}
!25 = !{!14, !10, i64 106}
!26 = !{!14, !10, i64 104}
!27 = !{!14, !6, i64 128}
!28 = !{!14, !6, i64 136}
!29 = !{!30, !12, i64 4}
!30 = !{!"", !12, i64 0, !12, i64 4, !12, i64 8, !12, i64 12, !12, i64 16, !12, i64 20, !12, i64 24, !12, i64 28, !12, i64 32, !7, i64 36, !12, i64 48, !7, i64 52, !12, i64 64, !12, i64 68, !12, i64 72, !12, i64 76, !12, i64 80}
!31 = !{!30, !12, i64 0}
!32 = !{!14, !12, i64 16}
!33 = !{!30, !12, i64 20}
!34 = distinct !{!34, !35}
!35 = !{!"llvm.loop.mustprogress"}
!36 = !{!14, !12, i64 64}
!37 = distinct !{!37, !35}
!38 = !{!7, !7, i64 0}
!39 = distinct !{!39, !35}


; Optimized IR (opt -passes='default<O3>'):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

declare i32 @HAL_GetTick() local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare hidden void @SPI_CloseTransfer(ptr noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
declare hidden i32 @SPI_WaitOnFlagUntilTimeout(ptr noundef, i32 noundef, i32 noundef, i32 noundef, i32 noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
define dso_local range(i32 0, 4) i32 @HAL_SPI_TransmitReceive(ptr noundef %0, ptr noundef %1, ptr noundef %2, i16 noundef zeroext %3, i32 noundef %4) local_unnamed_addr #1 {
  %6 = load ptr, ptr %0, align 8, !tbaa !5
  %7 = getelementptr inbounds i8, ptr %6, i64 32
  %8 = getelementptr inbounds i8, ptr %6, i64 48
  %9 = getelementptr inbounds i8, ptr %0, i64 160
  %10 = load i32, ptr %9, align 8, !tbaa !13
  %11 = icmp eq i32 %10, 1
  br i1 %11, label %265, label %12

12:                                               ; preds = %5
  store i32 1, ptr %9, align 8, !tbaa !13
  %13 = tail call i32 @HAL_GetTick() #3
  %14 = getelementptr inbounds i8, ptr %0, i64 164
  %15 = load volatile i32, ptr %14, align 4, !tbaa !14
  %16 = getelementptr inbounds i8, ptr %0, i64 8
  %17 = icmp eq i32 %15, 1
  br i1 %17, label %27, label %18

18:                                               ; preds = %12
  %19 = load i32, ptr %16, align 8, !tbaa !15
  %20 = icmp eq i32 %19, 4194304
  br i1 %20, label %21, label %26

21:                                               ; preds = %18
  %22 = getelementptr inbounds i8, ptr %0, i64 12
  %23 = load i32, ptr %22, align 4, !tbaa !16
  %24 = icmp eq i32 %23, 0
  %25 = icmp eq i32 %15, 4
  %or.cond = and i1 %25, %24
  br i1 %or.cond, label %27, label %26

26:                                               ; preds = %21, %18
  store i32 0, ptr %9, align 8, !tbaa !13
  br label %265

27:                                               ; preds = %21, %12
  %28 = icmp eq ptr %1, null
  %29 = icmp eq ptr %2, null
  %or.cond3 = or i1 %28, %29
  %30 = icmp eq i16 %3, 0
  %or.cond6 = or i1 %or.cond3, %30
  br i1 %or.cond6, label %31, label %32

31:                                               ; preds = %27
  store i32 0, ptr %9, align 8, !tbaa !13
  br label %265

32:                                               ; preds = %27
  %33 = load volatile i32, ptr %14, align 4, !tbaa !14
  %.not = icmp eq i32 %33, 4
  br i1 %.not, label %35, label %34

34:                                               ; preds = %32
  store volatile i32 5, ptr %14, align 4, !tbaa !14
  br label %35

35:                                               ; preds = %34, %32
  %36 = getelementptr inbounds i8, ptr %0, i64 168
  store volatile i32 0, ptr %36, align 8, !tbaa !17
  %37 = getelementptr inbounds i8, ptr %0, i64 112
  store ptr %2, ptr %37, align 8, !tbaa !18
  %38 = getelementptr inbounds i8, ptr %0, i64 122
  store volatile i16 %3, ptr %38, align 2, !tbaa !19
  %39 = getelementptr inbounds i8, ptr %0, i64 120
  store i16 %3, ptr %39, align 8, !tbaa !20
  %40 = getelementptr inbounds i8, ptr %0, i64 96
  store ptr %1, ptr %40, align 8, !tbaa !21
  %41 = getelementptr inbounds i8, ptr %0, i64 106
  store volatile i16 %3, ptr %41, align 2, !tbaa !22
  %42 = getelementptr inbounds i8, ptr %0, i64 104
  store i16 %3, ptr %42, align 8, !tbaa !23
  %43 = getelementptr inbounds i8, ptr %0, i64 128
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %43, i8 0, i64 16, i1 false)
  %44 = load ptr, ptr %0, align 8, !tbaa !5
  %45 = getelementptr inbounds i8, ptr %44, i64 4
  %46 = load volatile i32, ptr %45, align 4, !tbaa !24
  %47 = and i32 %46, -65536
  %48 = zext i16 %3 to i32
  %49 = or disjoint i32 %47, %48
  store volatile i32 %49, ptr %45, align 4, !tbaa !24
  %50 = load volatile i32, ptr %44, align 4, !tbaa !26
  %51 = or i32 %50, 1
  store volatile i32 %51, ptr %44, align 4, !tbaa !26
  %52 = load i32, ptr %16, align 8, !tbaa !15
  %53 = icmp eq i32 %52, 4194304
  br i1 %53, label %54, label %57

54:                                               ; preds = %35
  %55 = load volatile i32, ptr %44, align 4, !tbaa !26
  %56 = or i32 %55, 512
  store volatile i32 %56, ptr %44, align 4, !tbaa !26
  br label %57

57:                                               ; preds = %54, %35
  %58 = getelementptr inbounds i8, ptr %0, i64 16
  %59 = load i32, ptr %58, align 8, !tbaa !27
  %60 = icmp ugt i32 %59, 15
  br i1 %60, label %.preheader, label %128

.preheader:                                       ; preds = %57
  %.not226 = icmp eq i32 %4, -1
  br i1 %.not226, label %.lr.ph, label %.preheader.split

.lr.ph:                                           ; preds = %.preheader, %88
  %61 = phi i1 [ %91, %88 ], [ true, %.preheader ]
  %62 = phi i1 [ %90, %88 ], [ true, %.preheader ]
  %.0.us225 = phi i16 [ %.1.us, %88 ], [ %3, %.preheader ]
  %.0200.us224 = phi i16 [ %.1201.us, %88 ], [ %3, %.preheader ]
  %63 = load ptr, ptr %0, align 8, !tbaa !5
  %64 = getelementptr inbounds i8, ptr %63, i64 20
  %65 = load volatile i32, ptr %64, align 4, !tbaa !28
  %66 = and i32 %65, 2
  %67 = icmp ne i32 %66, 0
  %or.cond9.us = and i1 %62, %67
  br i1 %or.cond9.us, label %68, label %76

68:                                               ; preds = %.lr.ph
  %69 = load ptr, ptr %40, align 8, !tbaa !21
  %70 = load i32, ptr %69, align 4, !tbaa !29
  %71 = getelementptr inbounds i8, ptr %63, i64 32
  store volatile i32 %70, ptr %71, align 4, !tbaa !29
  %72 = getelementptr inbounds i8, ptr %69, i64 4
  store ptr %72, ptr %40, align 8, !tbaa !21
  %73 = load volatile i16, ptr %41, align 2, !tbaa !22
  %74 = add i16 %73, -1
  store volatile i16 %74, ptr %41, align 2, !tbaa !22
  %75 = load volatile i16, ptr %41, align 2, !tbaa !22
  br label %76

76:                                               ; preds = %68, %.lr.ph
  %.1201.us = phi i16 [ %75, %68 ], [ %.0200.us224, %.lr.ph ]
  %77 = load volatile i32, ptr %64, align 4, !tbaa !28
  %78 = and i32 %77, 32776
  %79 = icmp ne i32 %78, 0
  %or.cond12.us = select i1 %79, i1 %61, i1 false
  br i1 %or.cond12.us, label %80, label %88

80:                                               ; preds = %76
  %81 = getelementptr inbounds i8, ptr %63, i64 48
  %82 = load volatile i32, ptr %81, align 4, !tbaa !29
  %83 = load ptr, ptr %37, align 8, !tbaa !18
  store i32 %82, ptr %83, align 4, !tbaa !29
  %84 = getelementptr inbounds i8, ptr %83, i64 4
  store ptr %84, ptr %37, align 8, !tbaa !18
  %85 = load volatile i16, ptr %38, align 2, !tbaa !19
  %86 = add i16 %85, -1
  store volatile i16 %86, ptr %38, align 2, !tbaa !19
  %87 = load volatile i16, ptr %38, align 2, !tbaa !19
  br label %88

88:                                               ; preds = %80, %76
  %.1.us = phi i16 [ %87, %80 ], [ %.0.us225, %76 ]
  %89 = tail call i32 @HAL_GetTick() #3
  %90 = icmp ne i16 %.1201.us, 0
  %91 = icmp ne i16 %.1.us, 0
  %92 = select i1 %90, i1 true, i1 %91
  br i1 %92, label %.lr.ph, label %.loopexit

.preheader.split:                                 ; preds = %.preheader, %122
  %.0200 = phi i16 [ %.1201, %122 ], [ %3, %.preheader ]
  %.0 = phi i16 [ %.1, %122 ], [ %3, %.preheader ]
  %93 = icmp ne i16 %.0200, 0
  %94 = icmp ne i16 %.0, 0
  %95 = select i1 %93, i1 true, i1 %94
  br i1 %95, label %96, label %.loopexit

96:                                               ; preds = %.preheader.split
  %97 = load ptr, ptr %0, align 8, !tbaa !5
  %98 = getelementptr inbounds i8, ptr %97, i64 20
  %99 = load volatile i32, ptr %98, align 4, !tbaa !28
  %100 = and i32 %99, 2
  %101 = icmp ne i32 %100, 0
  %or.cond9 = and i1 %93, %101
  br i1 %or.cond9, label %102, label %110

102:                                              ; preds = %96
  %103 = load ptr, ptr %40, align 8, !tbaa !21
  %104 = load i32, ptr %103, align 4, !tbaa !29
  %105 = getelementptr inbounds i8, ptr %97, i64 32
  store volatile i32 %104, ptr %105, align 4, !tbaa !29
  %106 = getelementptr inbounds i8, ptr %103, i64 4
  store ptr %106, ptr %40, align 8, !tbaa !21
  %107 = load volatile i16, ptr %41, align 2, !tbaa !22
  %108 = add i16 %107, -1
  store volatile i16 %108, ptr %41, align 2, !tbaa !22
  %109 = load volatile i16, ptr %41, align 2, !tbaa !22
  br label %110

110:                                              ; preds = %102, %96
  %.1201 = phi i16 [ %109, %102 ], [ %.0200, %96 ]
  %111 = load volatile i32, ptr %98, align 4, !tbaa !28
  %112 = and i32 %111, 32776
  %113 = icmp ne i32 %112, 0
  %or.cond12 = select i1 %113, i1 %94, i1 false
  br i1 %or.cond12, label %114, label %122

114:                                              ; preds = %110
  %115 = getelementptr inbounds i8, ptr %97, i64 48
  %116 = load volatile i32, ptr %115, align 4, !tbaa !29
  %117 = load ptr, ptr %37, align 8, !tbaa !18
  store i32 %116, ptr %117, align 4, !tbaa !29
  %118 = getelementptr inbounds i8, ptr %117, i64 4
  store ptr %118, ptr %37, align 8, !tbaa !18
  %119 = load volatile i16, ptr %38, align 2, !tbaa !19
  %120 = add i16 %119, -1
  store volatile i16 %120, ptr %38, align 2, !tbaa !19
  %121 = load volatile i16, ptr %38, align 2, !tbaa !19
  br label %122

122:                                              ; preds = %114, %110
  %.1 = phi i16 [ %121, %114 ], [ %.0, %110 ]
  %123 = tail call i32 @HAL_GetTick() #3
  %124 = sub i32 %123, %13
  %.not227 = icmp ult i32 %124, %4
  br i1 %.not227, label %.preheader.split, label %125, !llvm.loop !30

125:                                              ; preds = %122
  tail call void @SPI_CloseTransfer(ptr noundef nonnull %0)
  store i32 0, ptr %9, align 8, !tbaa !13
  %126 = load volatile i32, ptr %36, align 8, !tbaa !17
  %127 = or i32 %126, 256
  store volatile i32 %127, ptr %36, align 8, !tbaa !17
  store volatile i32 1, ptr %14, align 4, !tbaa !14
  br label %265

128:                                              ; preds = %57
  %129 = icmp ugt i32 %59, 7
  %130 = getelementptr inbounds i8, ptr %0, i64 64
  %131 = icmp ne i32 %4, -1
  br i1 %129, label %.preheader220, label %.preheader222

.preheader220:                                    ; preds = %128, %175
  %.2202 = phi i16 [ %.3203, %175 ], [ %3, %128 ]
  %.2 = phi i16 [ %.3, %175 ], [ %3, %128 ]
  %132 = icmp ne i16 %.2202, 0
  %133 = icmp ne i16 %.2, 0
  %134 = select i1 %132, i1 true, i1 %133
  br i1 %134, label %135, label %.loopexit

135:                                              ; preds = %.preheader220
  %136 = load ptr, ptr %0, align 8, !tbaa !5
  %137 = getelementptr inbounds i8, ptr %136, i64 20
  %138 = load volatile i32, ptr %137, align 4, !tbaa !28
  %139 = and i32 %138, 2
  %140 = icmp ne i32 %139, 0
  %or.cond19 = and i1 %132, %140
  br i1 %or.cond19, label %141, label %156

141:                                              ; preds = %135
  %142 = icmp ugt i16 %.2202, 1
  br i1 %142, label %143, label %._crit_edge234

._crit_edge234:                                   ; preds = %141
  %.pre235 = load ptr, ptr %40, align 8, !tbaa !21
  br label %149

143:                                              ; preds = %141
  %144 = load i32, ptr %130, align 8, !tbaa !32
  %.not216 = icmp eq i32 %144, 0
  %.pre236 = load ptr, ptr %40, align 8, !tbaa !21
  br i1 %.not216, label %149, label %145

145:                                              ; preds = %143
  %146 = load i32, ptr %.pre236, align 4, !tbaa !29
  %147 = getelementptr inbounds i8, ptr %136, i64 32
  store volatile i32 %146, ptr %147, align 4, !tbaa !29
  %148 = getelementptr inbounds i8, ptr %.pre236, i64 4
  br label %.sink.split

149:                                              ; preds = %._crit_edge234, %143
  %150 = phi ptr [ %.pre235, %._crit_edge234 ], [ %.pre236, %143 ]
  %151 = load i16, ptr %150, align 2, !tbaa !33
  store volatile i16 %151, ptr %7, align 2, !tbaa !33
  %152 = getelementptr inbounds i8, ptr %150, i64 2
  br label %.sink.split

.sink.split:                                      ; preds = %149, %145
  %.sink = phi ptr [ %148, %145 ], [ %152, %149 ]
  %.sink243 = phi i16 [ -2, %145 ], [ -1, %149 ]
  store ptr %.sink, ptr %40, align 8, !tbaa !21
  %153 = load volatile i16, ptr %41, align 2, !tbaa !22
  %154 = add i16 %153, %.sink243
  store volatile i16 %154, ptr %41, align 2, !tbaa !22
  %155 = load volatile i16, ptr %41, align 2, !tbaa !22
  br label %156

156:                                              ; preds = %.sink.split, %135
  %.3203 = phi i16 [ %.2202, %135 ], [ %155, %.sink.split ]
  %157 = load volatile i32, ptr %137, align 4, !tbaa !28
  %158 = and i32 %157, 57344
  %159 = icmp ne i32 %158, 0
  %or.cond22 = select i1 %159, i1 %133, i1 false
  br i1 %or.cond22, label %160, label %175

160:                                              ; preds = %156
  %161 = load volatile i32, ptr %137, align 4, !tbaa !28
  %162 = and i32 %161, 32768
  %.not217 = icmp eq i32 %162, 0
  br i1 %.not217, label %168, label %163

163:                                              ; preds = %160
  %164 = getelementptr inbounds i8, ptr %136, i64 48
  %165 = load volatile i32, ptr %164, align 4, !tbaa !29
  %166 = load ptr, ptr %37, align 8, !tbaa !18
  store i32 %165, ptr %166, align 4, !tbaa !29
  %167 = getelementptr inbounds i8, ptr %166, i64 4
  br label %.sink.split244

168:                                              ; preds = %160
  %169 = load volatile i16, ptr %8, align 2, !tbaa !33
  %170 = load ptr, ptr %37, align 8, !tbaa !18
  store i16 %169, ptr %170, align 2, !tbaa !33
  %171 = getelementptr inbounds i8, ptr %170, i64 2
  br label %.sink.split244

.sink.split244:                                   ; preds = %168, %163
  %.sink248 = phi ptr [ %167, %163 ], [ %171, %168 ]
  %.sink247 = phi i16 [ -2, %163 ], [ -1, %168 ]
  store ptr %.sink248, ptr %37, align 8, !tbaa !18
  %172 = load volatile i16, ptr %38, align 2, !tbaa !19
  %173 = add i16 %172, %.sink247
  store volatile i16 %173, ptr %38, align 2, !tbaa !19
  %174 = load volatile i16, ptr %38, align 2, !tbaa !19
  br label %175

175:                                              ; preds = %.sink.split244, %156
  %.3 = phi i16 [ %.2, %156 ], [ %174, %.sink.split244 ]
  %176 = tail call i32 @HAL_GetTick() #3
  %177 = sub i32 %176, %13
  %178 = icmp uge i32 %177, %4
  %or.cond24 = and i1 %131, %178
  br i1 %or.cond24, label %179, label %.preheader220, !llvm.loop !34

179:                                              ; preds = %175
  tail call void @SPI_CloseTransfer(ptr noundef nonnull %0)
  store i32 0, ptr %9, align 8, !tbaa !13
  %180 = load volatile i32, ptr %36, align 8, !tbaa !17
  %181 = or i32 %180, 256
  store volatile i32 %181, ptr %36, align 8, !tbaa !17
  store volatile i32 1, ptr %14, align 4, !tbaa !14
  br label %265

.preheader222:                                    ; preds = %128, %252
  %.4204 = phi i16 [ %.5205, %252 ], [ %3, %128 ]
  %.4 = phi i16 [ %.5, %252 ], [ %3, %128 ]
  %182 = icmp ne i16 %.4204, 0
  %183 = icmp ne i16 %.4, 0
  %184 = select i1 %182, i1 true, i1 %183
  br i1 %184, label %185, label %.loopexit

185:                                              ; preds = %.preheader222
  %186 = load ptr, ptr %0, align 8, !tbaa !5
  %187 = getelementptr inbounds i8, ptr %186, i64 20
  %188 = load volatile i32, ptr %187, align 4, !tbaa !28
  %189 = and i32 %188, 2
  %190 = icmp ne i32 %189, 0
  %or.cond29 = and i1 %182, %190
  br i1 %or.cond29, label %191, label %221

191:                                              ; preds = %185
  %192 = icmp ugt i16 %.4204, 3
  br i1 %192, label %193, label %203

193:                                              ; preds = %191
  %194 = load i32, ptr %130, align 8, !tbaa !32
  %195 = icmp ugt i32 %194, 64
  %.pre232.pre237 = load ptr, ptr %40, align 8, !tbaa !21
  br i1 %195, label %196, label %.thread

196:                                              ; preds = %193
  %197 = load i32, ptr %.pre232.pre237, align 4, !tbaa !29
  %198 = getelementptr inbounds i8, ptr %186, i64 32
  store volatile i32 %197, ptr %198, align 4, !tbaa !29
  %199 = getelementptr inbounds i8, ptr %.pre232.pre237, i64 4
  store ptr %199, ptr %40, align 8, !tbaa !21
  %200 = load volatile i16, ptr %41, align 2, !tbaa !22
  %201 = add i16 %200, -4
  store volatile i16 %201, ptr %41, align 2, !tbaa !22
  %202 = load volatile i16, ptr %41, align 2, !tbaa !22
  br label %221

203:                                              ; preds = %191
  %204 = icmp ugt i16 %.4204, 1
  br i1 %204, label %..thread_crit_edge, label %._crit_edge

._crit_edge:                                      ; preds = %203
  %.pre231 = load ptr, ptr %40, align 8, !tbaa !21
  br label %212

..thread_crit_edge:                               ; preds = %203
  %.pre = load i32, ptr %130, align 8, !tbaa !32
  %.pre232.pre = load ptr, ptr %40, align 8, !tbaa !21
  br label %.thread

.thread:                                          ; preds = %..thread_crit_edge, %193
  %.pre232 = phi ptr [ %.pre232.pre, %..thread_crit_edge ], [ %.pre232.pre237, %193 ]
  %205 = phi i32 [ %.pre, %..thread_crit_edge ], [ %194, %193 ]
  %.not214 = icmp eq i32 %205, 0
  br i1 %.not214, label %212, label %206

206:                                              ; preds = %.thread
  %207 = load i16, ptr %.pre232, align 2, !tbaa !33
  store volatile i16 %207, ptr %7, align 2, !tbaa !33
  %208 = getelementptr inbounds i8, ptr %.pre232, i64 2
  store ptr %208, ptr %40, align 8, !tbaa !21
  %209 = load volatile i16, ptr %41, align 2, !tbaa !22
  %210 = add i16 %209, -2
  store volatile i16 %210, ptr %41, align 2, !tbaa !22
  %211 = load volatile i16, ptr %41, align 2, !tbaa !22
  br label %221

212:                                              ; preds = %._crit_edge, %.thread
  %213 = phi ptr [ %.pre231, %._crit_edge ], [ %.pre232, %.thread ]
  %214 = load i8, ptr %213, align 1, !tbaa !35
  %215 = getelementptr inbounds i8, ptr %186, i64 32
  store volatile i8 %214, ptr %215, align 4, !tbaa !35
  %216 = load ptr, ptr %40, align 8, !tbaa !21
  %217 = getelementptr inbounds i8, ptr %216, i64 1
  store ptr %217, ptr %40, align 8, !tbaa !21
  %218 = load volatile i16, ptr %41, align 2, !tbaa !22
  %219 = add i16 %218, -1
  store volatile i16 %219, ptr %41, align 2, !tbaa !22
  %220 = load volatile i16, ptr %41, align 2, !tbaa !22
  %.pre233 = load ptr, ptr %0, align 8, !tbaa !5
  br label %221

221:                                              ; preds = %196, %212, %206, %185
  %222 = phi ptr [ %186, %196 ], [ %186, %206 ], [ %.pre233, %212 ], [ %186, %185 ]
  %.5205 = phi i16 [ %202, %196 ], [ %211, %206 ], [ %220, %212 ], [ %.4204, %185 ]
  %223 = getelementptr inbounds i8, ptr %222, i64 20
  %224 = load volatile i32, ptr %223, align 4, !tbaa !28
  %225 = and i32 %224, 57344
  %226 = icmp ne i32 %225, 0
  %or.cond32 = select i1 %226, i1 %183, i1 false
  br i1 %or.cond32, label %227, label %252

227:                                              ; preds = %221
  %228 = load volatile i32, ptr %223, align 4, !tbaa !28
  %229 = and i32 %228, 32768
  %.not215 = icmp eq i32 %229, 0
  br i1 %.not215, label %235, label %230

230:                                              ; preds = %227
  %231 = getelementptr inbounds i8, ptr %222, i64 48
  %232 = load volatile i32, ptr %231, align 4, !tbaa !29
  %233 = load ptr, ptr %37, align 8, !tbaa !18
  store i32 %232, ptr %233, align 4, !tbaa !29
  %234 = getelementptr inbounds i8, ptr %233, i64 4
  br label %.sink.split249

235:                                              ; preds = %227
  %236 = load volatile i32, ptr %223, align 4, !tbaa !28
  %237 = and i32 %236, 24576
  %238 = icmp ugt i32 %237, 8192
  br i1 %238, label %239, label %243

239:                                              ; preds = %235
  %240 = load volatile i16, ptr %8, align 2, !tbaa !33
  %241 = load ptr, ptr %37, align 8, !tbaa !18
  store i16 %240, ptr %241, align 2, !tbaa !33
  %242 = getelementptr inbounds i8, ptr %241, i64 2
  br label %.sink.split249

243:                                              ; preds = %235
  %244 = getelementptr inbounds i8, ptr %222, i64 48
  %245 = load volatile i8, ptr %244, align 4, !tbaa !35
  %246 = load ptr, ptr %37, align 8, !tbaa !18
  store i8 %245, ptr %246, align 1, !tbaa !35
  %247 = load ptr, ptr %37, align 8, !tbaa !18
  %248 = getelementptr inbounds i8, ptr %247, i64 1
  br label %.sink.split249

.sink.split249:                                   ; preds = %239, %243, %230
  %.sink253 = phi ptr [ %234, %230 ], [ %248, %243 ], [ %242, %239 ]
  %.sink252 = phi i16 [ -4, %230 ], [ -1, %243 ], [ -2, %239 ]
  store ptr %.sink253, ptr %37, align 8, !tbaa !18
  %249 = load volatile i16, ptr %38, align 2, !tbaa !19
  %250 = add i16 %249, %.sink252
  store volatile i16 %250, ptr %38, align 2, !tbaa !19
  %251 = load volatile i16, ptr %38, align 2, !tbaa !19
  br label %252

252:                                              ; preds = %.sink.split249, %221
  %.5 = phi i16 [ %.4, %221 ], [ %251, %.sink.split249 ]
  %253 = tail call i32 @HAL_GetTick() #3
  %254 = sub i32 %253, %13
  %255 = icmp uge i32 %254, %4
  %or.cond34 = and i1 %131, %255
  br i1 %or.cond34, label %256, label %.preheader222, !llvm.loop !36

256:                                              ; preds = %252
  tail call void @SPI_CloseTransfer(ptr noundef nonnull %0)
  store i32 0, ptr %9, align 8, !tbaa !13
  %257 = load volatile i32, ptr %36, align 8, !tbaa !17
  %258 = or i32 %257, 256
  store volatile i32 %258, ptr %36, align 8, !tbaa !17
  store volatile i32 1, ptr %14, align 4, !tbaa !14
  br label %265

.loopexit:                                        ; preds = %.preheader222, %.preheader220, %.preheader.split, %88
  %259 = tail call i32 @SPI_WaitOnFlagUntilTimeout(ptr noundef nonnull %0, i32 noundef 8, i32 noundef 0, i32 noundef %13, i32 noundef %4)
  %.not218 = icmp eq i32 %259, 0
  br i1 %.not218, label %263, label %260

260:                                              ; preds = %.loopexit
  %261 = load volatile i32, ptr %36, align 8, !tbaa !17
  %262 = or i32 %261, 32
  store volatile i32 %262, ptr %36, align 8, !tbaa !17
  br label %263

263:                                              ; preds = %260, %.loopexit
  tail call void @SPI_CloseTransfer(ptr noundef nonnull %0)
  store i32 0, ptr %9, align 8, !tbaa !13
  store volatile i32 1, ptr %14, align 4, !tbaa !14
  %264 = load volatile i32, ptr %36, align 8, !tbaa !17
  %.not219 = icmp ne i32 %264, 0
  %. = zext i1 %.not219 to i32
  br label %265

265:                                              ; preds = %263, %5, %256, %179, %125, %31, %26
  %.0206 = phi i32 [ 1, %31 ], [ 3, %125 ], [ 3, %179 ], [ 3, %256 ], [ 2, %26 ], [ 2, %5 ], [ %., %263 ]
  ret i32 %.0206
}

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #2

attributes #0 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #3 = { nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !7, i64 0}
!6 = !{!"__SPI_HandleTypeDef", !7, i64 0, !10, i64 8, !7, i64 96, !12, i64 104, !12, i64 106, !7, i64 112, !12, i64 120, !12, i64 122, !11, i64 124, !7, i64 128, !7, i64 136, !7, i64 144, !7, i64 152, !11, i64 160, !11, i64 164, !11, i64 168}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"", !11, i64 0, !11, i64 4, !11, i64 8, !11, i64 12, !11, i64 16, !11, i64 20, !11, i64 24, !11, i64 28, !11, i64 32, !11, i64 36, !11, i64 40, !11, i64 44, !11, i64 48, !11, i64 52, !11, i64 56, !11, i64 60, !11, i64 64, !11, i64 68, !11, i64 72, !11, i64 76, !11, i64 80, !11, i64 84}
!11 = !{!"int", !8, i64 0}
!12 = !{!"short", !8, i64 0}
!13 = !{!6, !11, i64 160}
!14 = !{!6, !11, i64 164}
!15 = !{!6, !11, i64 8}
!16 = !{!6, !11, i64 12}
!17 = !{!6, !11, i64 168}
!18 = !{!6, !7, i64 112}
!19 = !{!6, !12, i64 122}
!20 = !{!6, !12, i64 120}
!21 = !{!6, !7, i64 96}
!22 = !{!6, !12, i64 106}
!23 = !{!6, !12, i64 104}
!24 = !{!25, !11, i64 4}
!25 = !{!"", !11, i64 0, !11, i64 4, !11, i64 8, !11, i64 12, !11, i64 16, !11, i64 20, !11, i64 24, !11, i64 28, !11, i64 32, !8, i64 36, !11, i64 48, !8, i64 52, !11, i64 64, !11, i64 68, !11, i64 72, !11, i64 76, !11, i64 80}
!26 = !{!25, !11, i64 0}
!27 = !{!6, !11, i64 16}
!28 = !{!25, !11, i64 20}
!29 = !{!11, !11, i64 0}
!30 = distinct !{!30, !31}
!31 = !{!"llvm.loop.mustprogress"}
!32 = !{!6, !11, i64 64}
!33 = !{!12, !12, i64 0}
!34 = distinct !{!34, !31}
!35 = !{!8, !8, i64 0}
!36 = distinct !{!36, !31}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LICMPass,LoopInstSimplifyPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,MemCpyOptPass,ReassociatePass,SCCPPass,SROAPass,SimplifyCFGPass,TailCallElimPass