; LLVM IR from lichen-community-systems/signaletic :: hosts/daisy/vendor/libDaisy/Drivers/STM32H7xx_HAL_Driver/Src (TransmitReceive)

; 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 i32, align 4
  %15 = alloca i32, align 4
  %16 = alloca i16, align 2
  %17 = alloca i16, align 2
  %18 = 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 4, ptr %14) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #3
  call void @llvm.lifetime.start.p0(i64 2, ptr %16) #3
  call void @llvm.lifetime.start.p0(i64 2, ptr %17) #3
  br label %19

19:                                               ; preds = %5
  %20 = load ptr, ptr %7, align 8, !tbaa !5
  %21 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %20, i32 0, i32 13
  %22 = load i32, ptr %21, align 8, !tbaa !13
  %23 = icmp eq i32 %22, 1
  br i1 %23, label %24, label %25

24:                                               ; preds = %19
  store i32 2, ptr %6, align 4
  store i32 1, ptr %18, align 4
  br label %713

25:                                               ; preds = %19
  %26 = load ptr, ptr %7, align 8, !tbaa !5
  %27 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %26, i32 0, i32 13
  store i32 1, ptr %27, align 8, !tbaa !13
  br label %28

28:                                               ; preds = %25
  br label %29

29:                                               ; preds = %28
  br label %30

30:                                               ; preds = %29
  %31 = call i32 @HAL_GetTick()
  store i32 %31, ptr %14, align 4, !tbaa !11
  %32 = load i16, ptr %10, align 2, !tbaa !9
  store i16 %32, ptr %16, align 2, !tbaa !9
  %33 = load i16, ptr %10, align 2, !tbaa !9
  store i16 %33, ptr %17, align 2, !tbaa !9
  %34 = load ptr, ptr %7, align 8, !tbaa !5
  %35 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %34, i32 0, i32 14
  %36 = load volatile i32, ptr %35, align 4, !tbaa !16
  store i32 %36, ptr %12, align 4, !tbaa !11
  %37 = load ptr, ptr %7, align 8, !tbaa !5
  %38 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %37, i32 0, i32 1
  %39 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %38, i32 0, i32 0
  %40 = load i32, ptr %39, align 8, !tbaa !17
  store i32 %40, ptr %15, align 4, !tbaa !11
  %41 = load i32, ptr %12, align 4, !tbaa !11
  %42 = icmp eq i32 %41, 1
  br i1 %42, label %64, label %43

43:                                               ; preds = %30
  %44 = load i32, ptr %15, align 4, !tbaa !11
  %45 = zext i32 %44 to i64
  %46 = icmp eq i64 %45, 4194304
  br i1 %46, label %47, label %57

47:                                               ; preds = %43
  %48 = load ptr, ptr %7, align 8, !tbaa !5
  %49 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %48, i32 0, i32 1
  %50 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %49, i32 0, i32 1
  %51 = load i32, ptr %50, align 4, !tbaa !18
  %52 = zext i32 %51 to i64
  %53 = icmp eq i64 %52, 0
  br i1 %53, label %54, label %57

54:                                               ; preds = %47
  %55 = load i32, ptr %12, align 4, !tbaa !11
  %56 = icmp eq i32 %55, 4
  br i1 %56, label %64, label %57

57:                                               ; preds = %54, %47, %43
  store i32 2, ptr %13, align 4, !tbaa !11
  br label %58

58:                                               ; preds = %57
  %59 = load ptr, ptr %7, align 8, !tbaa !5
  %60 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %59, i32 0, i32 13
  store i32 0, ptr %60, align 8, !tbaa !13
  br label %61

61:                                               ; preds = %58
  br label %62

62:                                               ; preds = %61
  %63 = load i32, ptr %13, align 4, !tbaa !11
  store i32 %63, ptr %6, align 4
  store i32 1, ptr %18, align 4
  br label %713

64:                                               ; preds = %54, %30
  %65 = load ptr, ptr %8, align 8, !tbaa !5
  %66 = icmp eq ptr %65, null
  br i1 %66, label %74, label %67

67:                                               ; preds = %64
  %68 = load ptr, ptr %9, align 8, !tbaa !5
  %69 = icmp eq ptr %68, null
  br i1 %69, label %74, label %70

70:                                               ; preds = %67
  %71 = load i16, ptr %10, align 2, !tbaa !9
  %72 = zext i16 %71 to i64
  %73 = icmp eq i64 %72, 0
  br i1 %73, label %74, label %81

74:                                               ; preds = %70, %67, %64
  store i32 1, ptr %13, align 4, !tbaa !11
  br label %75

75:                                               ; preds = %74
  %76 = load ptr, ptr %7, align 8, !tbaa !5
  %77 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %76, i32 0, i32 13
  store i32 0, ptr %77, align 8, !tbaa !13
  br label %78

78:                                               ; preds = %75
  br label %79

79:                                               ; preds = %78
  %80 = load i32, ptr %13, align 4, !tbaa !11
  store i32 %80, ptr %6, align 4
  store i32 1, ptr %18, align 4
  br label %713

81:                                               ; preds = %70
  %82 = load ptr, ptr %7, align 8, !tbaa !5
  %83 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %82, i32 0, i32 14
  %84 = load volatile i32, ptr %83, align 4, !tbaa !16
  %85 = icmp ne i32 %84, 4
  br i1 %85, label %86, label %89

86:                                               ; preds = %81
  %87 = load ptr, ptr %7, align 8, !tbaa !5
  %88 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %87, i32 0, i32 14
  store volatile i32 5, ptr %88, align 4, !tbaa !16
  br label %89

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

143:                                              ; preds = %89
  %144 = load ptr, ptr %7, align 8, !tbaa !5
  %145 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %144, i32 0, i32 0
  %146 = load ptr, ptr %145, align 8, !tbaa !28
  %147 = getelementptr inbounds %struct.SPI_TypeDef, ptr %146, i32 0, i32 0
  %148 = load volatile i32, ptr %147, align 4, !tbaa !31
  %149 = zext i32 %148 to i64
  %150 = or i64 %149, 512
  %151 = trunc i64 %150 to i32
  store volatile i32 %151, ptr %147, align 4, !tbaa !31
  br label %152

152:                                              ; preds = %143, %89
  %153 = load ptr, ptr %7, align 8, !tbaa !5
  %154 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %153, i32 0, i32 1
  %155 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %154, i32 0, i32 2
  %156 = load i32, ptr %155, align 8, !tbaa !32
  %157 = zext i32 %156 to i64
  %158 = icmp ugt i64 %157, 15
  br i1 %158, label %159, label %265

159:                                              ; preds = %152
  br label %160

160:                                              ; preds = %236, %159
  %161 = load i16, ptr %16, align 2, !tbaa !9
  %162 = zext i16 %161 to i64
  %163 = icmp ugt i64 %162, 0
  br i1 %163, label %168, label %164

164:                                              ; preds = %160
  %165 = load i16, ptr %17, align 2, !tbaa !9
  %166 = zext i16 %165 to i64
  %167 = icmp ugt i64 %166, 0
  br label %168

168:                                              ; preds = %164, %160
  %169 = phi i1 [ true, %160 ], [ %167, %164 ]
  br i1 %169, label %170, label %237

170:                                              ; preds = %168
  %171 = load ptr, ptr %7, align 8, !tbaa !5
  %172 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %171, i32 0, i32 0
  %173 = load ptr, ptr %172, align 8, !tbaa !28
  %174 = getelementptr inbounds %struct.SPI_TypeDef, ptr %173, i32 0, i32 5
  %175 = load volatile i32, ptr %174, align 4, !tbaa !33
  %176 = zext i32 %175 to i64
  %177 = and i64 %176, 2
  %178 = icmp eq i64 %177, 2
  br i1 %178, label %179, label %203

179:                                              ; preds = %170
  %180 = load i16, ptr %16, align 2, !tbaa !9
  %181 = zext i16 %180 to i64
  %182 = icmp ugt i64 %181, 0
  br i1 %182, label %183, label %203

183:                                              ; preds = %179
  %184 = load ptr, ptr %7, align 8, !tbaa !5
  %185 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %184, i32 0, i32 2
  %186 = load ptr, ptr %185, align 8, !tbaa !23
  %187 = load i32, ptr %186, align 4, !tbaa !11
  %188 = load ptr, ptr %7, align 8, !tbaa !5
  %189 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %188, i32 0, i32 0
  %190 = load ptr, ptr %189, align 8, !tbaa !28
  %191 = getelementptr inbounds %struct.SPI_TypeDef, ptr %190, i32 0, i32 8
  store volatile i32 %187, ptr %191, align 4, !tbaa !11
  %192 = load ptr, ptr %7, align 8, !tbaa !5
  %193 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %192, i32 0, i32 2
  %194 = load ptr, ptr %193, align 8, !tbaa !23
  %195 = getelementptr inbounds i8, ptr %194, i64 4
  store ptr %195, ptr %193, align 8, !tbaa !23
  %196 = load ptr, ptr %7, align 8, !tbaa !5
  %197 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %196, i32 0, i32 4
  %198 = load volatile i16, ptr %197, align 2, !tbaa !24
  %199 = add i16 %198, -1
  store volatile i16 %199, ptr %197, align 2, !tbaa !24
  %200 = load ptr, ptr %7, align 8, !tbaa !5
  %201 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %200, i32 0, i32 4
  %202 = load volatile i16, ptr %201, align 2, !tbaa !24
  store i16 %202, ptr %16, align 2, !tbaa !9
  br label %203

203:                                              ; preds = %183, %179, %170
  %204 = load ptr, ptr %7, align 8, !tbaa !5
  %205 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %204, i32 0, i32 0
  %206 = load ptr, ptr %205, align 8, !tbaa !28
  %207 = getelementptr inbounds %struct.SPI_TypeDef, ptr %206, i32 0, i32 5
  %208 = load volatile i32, ptr %207, align 4, !tbaa !33
  %209 = zext i32 %208 to i64
  %210 = and i64 %209, 32776
  %211 = icmp ne i64 %210, 0
  br i1 %211, label %212, label %236

212:                                              ; preds = %203
  %213 = load i16, ptr %17, align 2, !tbaa !9
  %214 = zext i16 %213 to i64
  %215 = icmp ugt i64 %214, 0
  br i1 %215, label %216, label %236

216:                                              ; preds = %212
  %217 = load ptr, ptr %7, align 8, !tbaa !5
  %218 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %217, i32 0, i32 0
  %219 = load ptr, ptr %218, align 8, !tbaa !28
  %220 = getelementptr inbounds %struct.SPI_TypeDef, ptr %219, i32 0, i32 10
  %221 = load volatile i32, ptr %220, align 4, !tbaa !11
  %222 = load ptr, ptr %7, align 8, !tbaa !5
  %223 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %222, i32 0, i32 5
  %224 = load ptr, ptr %223, align 8, !tbaa !20
  store i32 %221, ptr %224, align 4, !tbaa !11
  %225 = load ptr, ptr %7, align 8, !tbaa !5
  %226 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %225, i32 0, i32 5
  %227 = load ptr, ptr %226, align 8, !tbaa !20
  %228 = getelementptr inbounds i8, ptr %227, i64 4
  store ptr %228, ptr %226, align 8, !tbaa !20
  %229 = load ptr, ptr %7, align 8, !tbaa !5
  %230 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %229, i32 0, i32 7
  %231 = load volatile i16, ptr %230, align 2, !tbaa !21
  %232 = add i16 %231, -1
  store volatile i16 %232, ptr %230, align 2, !tbaa !21
  %233 = load ptr, ptr %7, align 8, !tbaa !5
  %234 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %233, i32 0, i32 7
  %235 = load volatile i16, ptr %234, align 2, !tbaa !21
  store i16 %235, ptr %17, align 2, !tbaa !9
  br label %236

236:                                              ; preds = %216, %212, %203
  br label %160, !llvm.loop !34

237:                                              ; preds = %168
  %238 = call i32 @HAL_GetTick()
  %239 = load i32, ptr %14, align 4, !tbaa !11
  %240 = sub i32 %238, %239
  %241 = load i32, ptr %11, align 4, !tbaa !11
  %242 = icmp uge i32 %240, %241
  br i1 %242, label %243, label %246

243:                                              ; preds = %237
  %244 = load i32, ptr %11, align 4, !tbaa !11
  %245 = icmp ne i32 %244, -1
  br i1 %245, label %249, label %246

246:                                              ; preds = %243, %237
  %247 = load i32, ptr %11, align 4, !tbaa !11
  %248 = icmp eq i32 %247, 0
  br i1 %248, label %249, label %264

249:                                              ; preds = %246, %243
  %250 = load ptr, ptr %7, align 8, !tbaa !5
  call void @SPI_CloseTransfer(ptr noundef %250)
  br label %251

251:                                              ; preds = %249
  %252 = load ptr, ptr %7, align 8, !tbaa !5
  %253 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %252, i32 0, i32 13
  store i32 0, ptr %253, align 8, !tbaa !13
  br label %254

254:                                              ; preds = %251
  br label %255

255:                                              ; preds = %254
  %256 = load ptr, ptr %7, align 8, !tbaa !5
  %257 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %256, i32 0, i32 15
  %258 = load volatile i32, ptr %257, align 8, !tbaa !19
  %259 = zext i32 %258 to i64
  %260 = or i64 %259, 256
  %261 = trunc i64 %260 to i32
  store volatile i32 %261, ptr %257, align 8, !tbaa !19
  %262 = load ptr, ptr %7, align 8, !tbaa !5
  %263 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %262, i32 0, i32 14
  store volatile i32 1, ptr %263, align 4, !tbaa !16
  store i32 1, ptr %6, align 4
  store i32 1, ptr %18, align 4
  br label %713

264:                                              ; preds = %246
  br label %683

265:                                              ; preds = %152
  %266 = load ptr, ptr %7, align 8, !tbaa !5
  %267 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %266, i32 0, i32 1
  %268 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %267, i32 0, i32 2
  %269 = load i32, ptr %268, align 8, !tbaa !32
  %270 = zext i32 %269 to i64
  %271 = icmp ugt i64 %270, 7
  br i1 %271, label %272, label %444

272:                                              ; preds = %265
  br label %273

273:                                              ; preds = %442, %272
  %274 = load i16, ptr %16, align 2, !tbaa !9
  %275 = zext i16 %274 to i64
  %276 = icmp ugt i64 %275, 0
  br i1 %276, label %281, label %277

277:                                              ; preds = %273
  %278 = load i16, ptr %17, align 2, !tbaa !9
  %279 = zext i16 %278 to i64
  %280 = icmp ugt i64 %279, 0
  br label %281

281:                                              ; preds = %277, %273
  %282 = phi i1 [ true, %273 ], [ %280, %277 ]
  br i1 %282, label %283, label %443

283:                                              ; preds = %281
  %284 = load ptr, ptr %7, align 8, !tbaa !5
  %285 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %284, i32 0, i32 0
  %286 = load ptr, ptr %285, align 8, !tbaa !28
  %287 = getelementptr inbounds %struct.SPI_TypeDef, ptr %286, i32 0, i32 5
  %288 = load volatile i32, ptr %287, align 4, !tbaa !33
  %289 = zext i32 %288 to i64
  %290 = and i64 %289, 2
  %291 = icmp eq i64 %290, 2
  br i1 %291, label %292, label %350

292:                                              ; preds = %283
  %293 = load i16, ptr %16, align 2, !tbaa !9
  %294 = zext i16 %293 to i64
  %295 = icmp ugt i64 %294, 0
  br i1 %295, label %296, label %350

296:                                              ; preds = %292
  %297 = load i16, ptr %16, align 2, !tbaa !9
  %298 = zext i16 %297 to i64
  %299 = icmp ugt i64 %298, 1
  br i1 %299, label %300, label %329

300:                                              ; preds = %296
  %301 = load ptr, ptr %7, align 8, !tbaa !5
  %302 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %301, i32 0, i32 1
  %303 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %302, i32 0, i32 14
  %304 = load i32, ptr %303, align 8, !tbaa !36
  %305 = zext i32 %304 to i64
  %306 = icmp ugt i64 %305, 0
  br i1 %306, label %307, label %329

307:                                              ; preds = %300
  %308 = load ptr, ptr %7, align 8, !tbaa !5
  %309 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %308, i32 0, i32 2
  %310 = load ptr, ptr %309, align 8, !tbaa !23
  %311 = load i32, ptr %310, align 4, !tbaa !11
  %312 = load ptr, ptr %7, align 8, !tbaa !5
  %313 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %312, i32 0, i32 0
  %314 = load ptr, ptr %313, align 8, !tbaa !28
  %315 = getelementptr inbounds %struct.SPI_TypeDef, ptr %314, i32 0, i32 8
  store volatile i32 %311, ptr %315, align 4, !tbaa !11
  %316 = load ptr, ptr %7, align 8, !tbaa !5
  %317 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %316, i32 0, i32 2
  %318 = load ptr, ptr %317, align 8, !tbaa !23
  %319 = getelementptr inbounds i8, ptr %318, i64 4
  store ptr %319, ptr %317, align 8, !tbaa !23
  %320 = load ptr, ptr %7, align 8, !tbaa !5
  %321 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %320, i32 0, i32 4
  %322 = load volatile i16, ptr %321, align 2, !tbaa !24
  %323 = zext i16 %322 to i32
  %324 = sub nsw i32 %323, 2
  %325 = trunc i32 %324 to i16
  store volatile i16 %325, ptr %321, align 2, !tbaa !24
  %326 = load ptr, ptr %7, align 8, !tbaa !5
  %327 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %326, i32 0, i32 4
  %328 = load volatile i16, ptr %327, align 2, !tbaa !24
  store i16 %328, ptr %16, align 2, !tbaa !9
  br label %349

329:                                              ; preds = %300, %296
  %330 = load ptr, ptr %7, align 8, !tbaa !5
  %331 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %330, i32 0, i32 2
  %332 = load ptr, ptr %331, align 8, !tbaa !23
  %333 = load i16, ptr %332, align 2, !tbaa !9
  %334 = load ptr, ptr %7, align 8, !tbaa !5
  %335 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %334, i32 0, i32 0
  %336 = load ptr, ptr %335, align 8, !tbaa !28
  %337 = getelementptr inbounds %struct.SPI_TypeDef, ptr %336, i32 0, i32 8
  store volatile i16 %333, ptr %337, align 4, !tbaa !9
  %338 = load ptr, ptr %7, align 8, !tbaa !5
  %339 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %338, i32 0, i32 2
  %340 = load ptr, ptr %339, align 8, !tbaa !23
  %341 = getelementptr inbounds i8, ptr %340, i64 2
  store ptr %341, ptr %339, align 8, !tbaa !23
  %342 = load ptr, ptr %7, align 8, !tbaa !5
  %343 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %342, i32 0, i32 4
  %344 = load volatile i16, ptr %343, align 2, !tbaa !24
  %345 = add i16 %344, -1
  store volatile i16 %345, ptr %343, align 2, !tbaa !24
  %346 = load ptr, ptr %7, align 8, !tbaa !5
  %347 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %346, i32 0, i32 4
  %348 = load volatile i16, ptr %347, align 2, !tbaa !24
  store i16 %348, ptr %16, align 2, !tbaa !9
  br label %349

349:                                              ; preds = %329, %307
  br label %350

350:                                              ; preds = %349, %292, %283
  %351 = load ptr, ptr %7, align 8, !tbaa !5
  %352 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %351, i32 0, i32 0
  %353 = load ptr, ptr %352, align 8, !tbaa !28
  %354 = getelementptr inbounds %struct.SPI_TypeDef, ptr %353, i32 0, i32 5
  %355 = load volatile i32, ptr %354, align 4, !tbaa !33
  %356 = zext i32 %355 to i64
  %357 = and i64 %356, 57344
  %358 = icmp ne i64 %357, 0
  br i1 %358, label %359, label %415

359:                                              ; preds = %350
  %360 = load i16, ptr %17, align 2, !tbaa !9
  %361 = zext i16 %360 to i64
  %362 = icmp ugt i64 %361, 0
  br i1 %362, label %363, label %415

363:                                              ; preds = %359
  %364 = load ptr, ptr %7, align 8, !tbaa !5
  %365 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %364, i32 0, i32 0
  %366 = load ptr, ptr %365, align 8, !tbaa !28
  %367 = getelementptr inbounds %struct.SPI_TypeDef, ptr %366, i32 0, i32 5
  %368 = load volatile i32, ptr %367, align 4, !tbaa !33
  %369 = zext i32 %368 to i64
  %370 = and i64 %369, 32768
  %371 = icmp ne i64 %370, 0
  br i1 %371, label %372, label %394

372:                                              ; preds = %363
  %373 = load ptr, ptr %7, align 8, !tbaa !5
  %374 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %373, i32 0, i32 0
  %375 = load ptr, ptr %374, align 8, !tbaa !28
  %376 = getelementptr inbounds %struct.SPI_TypeDef, ptr %375, i32 0, i32 10
  %377 = load volatile i32, ptr %376, align 4, !tbaa !11
  %378 = load ptr, ptr %7, align 8, !tbaa !5
  %379 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %378, i32 0, i32 5
  %380 = load ptr, ptr %379, align 8, !tbaa !20
  store i32 %377, ptr %380, align 4, !tbaa !11
  %381 = load ptr, ptr %7, align 8, !tbaa !5
  %382 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %381, i32 0, i32 5
  %383 = load ptr, ptr %382, align 8, !tbaa !20
  %384 = getelementptr inbounds i8, ptr %383, i64 4
  store ptr %384, ptr %382, align 8, !tbaa !20
  %385 = load ptr, ptr %7, align 8, !tbaa !5
  %386 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %385, i32 0, i32 7
  %387 = load volatile i16, ptr %386, align 2, !tbaa !21
  %388 = zext i16 %387 to i32
  %389 = sub nsw i32 %388, 2
  %390 = trunc i32 %389 to i16
  store volatile i16 %390, ptr %386, align 2, !tbaa !21
  %391 = load ptr, ptr %7, align 8, !tbaa !5
  %392 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %391, i32 0, i32 7
  %393 = load volatile i16, ptr %392, align 2, !tbaa !21
  store i16 %393, ptr %17, align 2, !tbaa !9
  br label %414

394:                                              ; preds = %363
  %395 = load ptr, ptr %7, align 8, !tbaa !5
  %396 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %395, i32 0, i32 0
  %397 = load ptr, ptr %396, align 8, !tbaa !28
  %398 = getelementptr inbounds %struct.SPI_TypeDef, ptr %397, i32 0, i32 10
  %399 = load volatile i16, ptr %398, align 4, !tbaa !9
  %400 = load ptr, ptr %7, align 8, !tbaa !5
  %401 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %400, i32 0, i32 5
  %402 = load ptr, ptr %401, align 8, !tbaa !20
  store i16 %399, ptr %402, align 2, !tbaa !9
  %403 = load ptr, ptr %7, align 8, !tbaa !5
  %404 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %403, i32 0, i32 5
  %405 = load ptr, ptr %404, align 8, !tbaa !20
  %406 = getelementptr inbounds i8, ptr %405, i64 2
  store ptr %406, ptr %404, align 8, !tbaa !20
  %407 = load ptr, ptr %7, align 8, !tbaa !5
  %408 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %407, i32 0, i32 7
  %409 = load volatile i16, ptr %408, align 2, !tbaa !21
  %410 = add i16 %409, -1
  store volatile i16 %410, ptr %408, align 2, !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 !21
  store i16 %413, ptr %17, align 2, !tbaa !9
  br label %414

414:                                              ; preds = %394, %372
  br label %415

415:                                              ; preds = %414, %359, %350
  %416 = call i32 @HAL_GetTick()
  %417 = load i32, ptr %14, align 4, !tbaa !11
  %418 = sub i32 %416, %417
  %419 = load i32, ptr %11, align 4, !tbaa !11
  %420 = icmp uge i32 %418, %419
  br i1 %420, label %421, label %424

421:                                              ; preds = %415
  %422 = load i32, ptr %11, align 4, !tbaa !11
  %423 = icmp ne i32 %422, -1
  br i1 %423, label %427, label %424

424:                                              ; preds = %421, %415
  %425 = load i32, ptr %11, align 4, !tbaa !11
  %426 = icmp eq i32 %425, 0
  br i1 %426, label %427, label %442

427:                                              ; preds = %424, %421
  %428 = load ptr, ptr %7, align 8, !tbaa !5
  call void @SPI_CloseTransfer(ptr noundef %428)
  br label %429

429:                                              ; preds = %427
  %430 = load ptr, ptr %7, align 8, !tbaa !5
  %431 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %430, i32 0, i32 13
  store i32 0, ptr %431, align 8, !tbaa !13
  br label %432

432:                                              ; preds = %429
  br label %433

433:                                              ; preds = %432
  %434 = load ptr, ptr %7, align 8, !tbaa !5
  %435 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %434, i32 0, i32 15
  %436 = load volatile i32, ptr %435, align 8, !tbaa !19
  %437 = zext i32 %436 to i64
  %438 = or i64 %437, 256
  %439 = trunc i64 %438 to i32
  store volatile i32 %439, ptr %435, align 8, !tbaa !19
  %440 = load ptr, ptr %7, align 8, !tbaa !5
  %441 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %440, i32 0, i32 14
  store volatile i32 1, ptr %441, align 4, !tbaa !16
  store i32 1, ptr %6, align 4
  store i32 1, ptr %18, align 4
  br label %713

442:                                              ; preds = %424
  br label %273, !llvm.loop !37

443:                                              ; preds = %281
  br label %682

444:                                              ; preds = %265
  br label %445

445:                                              ; preds = %680, %444
  %446 = load i16, ptr %16, align 2, !tbaa !9
  %447 = zext i16 %446 to i64
  %448 = icmp ugt i64 %447, 0
  br i1 %448, label %453, label %449

449:                                              ; preds = %445
  %450 = load i16, ptr %17, align 2, !tbaa !9
  %451 = zext i16 %450 to i64
  %452 = icmp ugt i64 %451, 0
  br label %453

453:                                              ; preds = %449, %445
  %454 = phi i1 [ true, %445 ], [ %452, %449 ]
  br i1 %454, label %455, label %681

455:                                              ; preds = %453
  %456 = load ptr, ptr %7, align 8, !tbaa !5
  %457 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %456, i32 0, i32 0
  %458 = load ptr, ptr %457, align 8, !tbaa !28
  %459 = getelementptr inbounds %struct.SPI_TypeDef, ptr %458, i32 0, i32 5
  %460 = load volatile i32, ptr %459, align 4, !tbaa !33
  %461 = zext i32 %460 to i64
  %462 = and i64 %461, 2
  %463 = icmp eq i64 %462, 2
  br i1 %463, label %464, label %556

464:                                              ; preds = %455
  %465 = load i16, ptr %16, align 2, !tbaa !9
  %466 = zext i16 %465 to i64
  %467 = icmp ugt i64 %466, 0
  br i1 %467, label %468, label %556

468:                                              ; preds = %464
  %469 = load i16, ptr %16, align 2, !tbaa !9
  %470 = zext i16 %469 to i64
  %471 = icmp ugt i64 %470, 3
  br i1 %471, label %472, label %501

472:                                              ; preds = %468
  %473 = load ptr, ptr %7, align 8, !tbaa !5
  %474 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %473, i32 0, i32 1
  %475 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %474, i32 0, i32 14
  %476 = load i32, ptr %475, align 8, !tbaa !36
  %477 = zext i32 %476 to i64
  %478 = icmp ugt i64 %477, 64
  br i1 %478, label %479, label %501

479:                                              ; preds = %472
  %480 = load ptr, ptr %7, align 8, !tbaa !5
  %481 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %480, i32 0, i32 2
  %482 = load ptr, ptr %481, align 8, !tbaa !23
  %483 = load i32, ptr %482, align 4, !tbaa !11
  %484 = load ptr, ptr %7, align 8, !tbaa !5
  %485 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %484, i32 0, i32 0
  %486 = load ptr, ptr %485, align 8, !tbaa !28
  %487 = getelementptr inbounds %struct.SPI_TypeDef, ptr %486, i32 0, i32 8
  store volatile i32 %483, ptr %487, align 4, !tbaa !11
  %488 = load ptr, ptr %7, align 8, !tbaa !5
  %489 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %488, i32 0, i32 2
  %490 = load ptr, ptr %489, align 8, !tbaa !23
  %491 = getelementptr inbounds i8, ptr %490, i64 4
  store ptr %491, ptr %489, align 8, !tbaa !23
  %492 = load ptr, ptr %7, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %492, i32 0, i32 4
  %494 = load volatile i16, ptr %493, align 2, !tbaa !24
  %495 = zext i16 %494 to i32
  %496 = sub nsw i32 %495, 4
  %497 = trunc i32 %496 to i16
  store volatile i16 %497, ptr %493, align 2, !tbaa !24
  %498 = load ptr, ptr %7, align 8, !tbaa !5
  %499 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %498, i32 0, i32 4
  %500 = load volatile i16, ptr %499, align 2, !tbaa !24
  store i16 %500, ptr %16, align 2, !tbaa !9
  br label %555

501:                                              ; preds = %472, %468
  %502 = load i16, ptr %16, align 2, !tbaa !9
  %503 = zext i16 %502 to i64
  %504 = icmp ugt i64 %503, 1
  br i1 %504, label %505, label %534

505:                                              ; preds = %501
  %506 = load ptr, ptr %7, align 8, !tbaa !5
  %507 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %506, i32 0, i32 1
  %508 = getelementptr inbounds %struct.SPI_InitTypeDef, ptr %507, i32 0, i32 14
  %509 = load i32, ptr %508, align 8, !tbaa !36
  %510 = zext i32 %509 to i64
  %511 = icmp ugt i64 %510, 0
  br i1 %511, label %512, label %534

512:                                              ; preds = %505
  %513 = load ptr, ptr %7, align 8, !tbaa !5
  %514 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %513, i32 0, i32 2
  %515 = load ptr, ptr %514, align 8, !tbaa !23
  %516 = load i16, ptr %515, align 2, !tbaa !9
  %517 = load ptr, ptr %7, align 8, !tbaa !5
  %518 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %517, i32 0, i32 0
  %519 = load ptr, ptr %518, align 8, !tbaa !28
  %520 = getelementptr inbounds %struct.SPI_TypeDef, ptr %519, i32 0, i32 8
  store volatile i16 %516, ptr %520, align 4, !tbaa !9
  %521 = load ptr, ptr %7, align 8, !tbaa !5
  %522 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %521, i32 0, i32 2
  %523 = load ptr, ptr %522, align 8, !tbaa !23
  %524 = getelementptr inbounds i8, ptr %523, i64 2
  store ptr %524, ptr %522, align 8, !tbaa !23
  %525 = load ptr, ptr %7, align 8, !tbaa !5
  %526 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %525, i32 0, i32 4
  %527 = load volatile i16, ptr %526, align 2, !tbaa !24
  %528 = zext i16 %527 to i32
  %529 = sub nsw i32 %528, 2
  %530 = trunc i32 %529 to i16
  store volatile i16 %530, ptr %526, align 2, !tbaa !24
  %531 = load ptr, ptr %7, align 8, !tbaa !5
  %532 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %531, i32 0, i32 4
  %533 = load volatile i16, ptr %532, align 2, !tbaa !24
  store i16 %533, ptr %16, align 2, !tbaa !9
  br label %554

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

554:                                              ; preds = %534, %512
  br label %555

555:                                              ; preds = %554, %479
  br label %556

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

565:                                              ; preds = %556
  %566 = load i16, ptr %17, align 2, !tbaa !9
  %567 = zext i16 %566 to i64
  %568 = icmp ugt i64 %567, 0
  br i1 %568, label %569, label %653

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

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

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

609:                                              ; preds = %600
  %610 = load ptr, ptr %7, align 8, !tbaa !5
  %611 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %610, i32 0, i32 0
  %612 = load ptr, ptr %611, align 8, !tbaa !28
  %613 = getelementptr inbounds %struct.SPI_TypeDef, ptr %612, i32 0, i32 10
  %614 = load volatile i16, ptr %613, align 4, !tbaa !9
  %615 = load ptr, ptr %7, align 8, !tbaa !5
  %616 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %615, i32 0, i32 5
  %617 = load ptr, ptr %616, align 8, !tbaa !20
  store i16 %614, ptr %617, align 2, !tbaa !9
  %618 = load ptr, ptr %7, align 8, !tbaa !5
  %619 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %618, i32 0, i32 5
  %620 = load ptr, ptr %619, align 8, !tbaa !20
  %621 = getelementptr inbounds i8, ptr %620, i64 2
  store ptr %621, ptr %619, align 8, !tbaa !20
  %622 = load ptr, ptr %7, align 8, !tbaa !5
  %623 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %622, i32 0, i32 7
  %624 = load volatile i16, ptr %623, align 2, !tbaa !21
  %625 = zext i16 %624 to i32
  %626 = sub nsw i32 %625, 2
  %627 = trunc i32 %626 to i16
  store volatile i16 %627, ptr %623, align 2, !tbaa !21
  %628 = load ptr, ptr %7, align 8, !tbaa !5
  %629 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %628, i32 0, i32 7
  %630 = load volatile i16, ptr %629, align 2, !tbaa !21
  store i16 %630, ptr %17, align 2, !tbaa !9
  br label %651

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

651:                                              ; preds = %631, %609
  br label %652

652:                                              ; preds = %651, %578
  br label %653

653:                                              ; preds = %652, %565, %556
  %654 = call i32 @HAL_GetTick()
  %655 = load i32, ptr %14, align 4, !tbaa !11
  %656 = sub i32 %654, %655
  %657 = load i32, ptr %11, align 4, !tbaa !11
  %658 = icmp uge i32 %656, %657
  br i1 %658, label %659, label %662

659:                                              ; preds = %653
  %660 = load i32, ptr %11, align 4, !tbaa !11
  %661 = icmp ne i32 %660, -1
  br i1 %661, label %665, label %662

662:                                              ; preds = %659, %653
  %663 = load i32, ptr %11, align 4, !tbaa !11
  %664 = icmp eq i32 %663, 0
  br i1 %664, label %665, label %680

665:                                              ; preds = %662, %659
  %666 = load ptr, ptr %7, align 8, !tbaa !5
  call void @SPI_CloseTransfer(ptr noundef %666)
  br label %667

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

670:                                              ; preds = %667
  br label %671

671:                                              ; preds = %670
  %672 = load ptr, ptr %7, align 8, !tbaa !5
  %673 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %672, i32 0, i32 15
  %674 = load volatile i32, ptr %673, align 8, !tbaa !19
  %675 = zext i32 %674 to i64
  %676 = or i64 %675, 256
  %677 = trunc i64 %676 to i32
  store volatile i32 %677, ptr %673, align 8, !tbaa !19
  %678 = load ptr, ptr %7, align 8, !tbaa !5
  %679 = getelementptr inbounds %struct.__SPI_HandleTypeDef, ptr %678, i32 0, i32 14
  store volatile i32 1, ptr %679, align 4, !tbaa !16
  store i32 1, ptr %6, align 4
  store i32 1, ptr %18, align 4
  br label %713

680:                                              ; preds = %662
  br label %445, !llvm.loop !39

681:                                              ; preds = %453
  br label %682

682:                                              ; preds = %681, %443
  br label %683

683:                                              ; preds = %682, %264
  %684 = load ptr, ptr %7, align 8, !tbaa !5
  %685 = load i32, ptr %14, align 4, !tbaa !11
  %686 = load i32, ptr %11, align 4, !tbaa !11
  %687 = call i32 @SPI_WaitOnFlagUntilTimeout(ptr noundef %684, i32 noundef 8, i32 noundef 0, i32 noundef %685, i32 noundef %686)
  %688 = icmp ne i32 %687, 0
  br i1 %688, label %689, label %696

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

696:                                              ; preds = %689, %683
  %697 = load ptr, ptr %7, align 8, !tbaa !5
  call void @SPI_CloseTransfer(ptr noundef %697)
  br label %698

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

701:                                              ; preds = %698
  br label %702

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

710:                                              ; preds = %702
  store i32 1, ptr %6, align 4
  store i32 1, ptr %18, align 4
  br label %713

711:                                              ; preds = %702
  %712 = load i32, ptr %13, align 4, !tbaa !11
  store i32 %712, ptr %6, align 4
  store i32 1, ptr %18, align 4
  br label %713

713:                                              ; preds = %711, %710, %671, %433, %255, %79, %62, %24
  call void @llvm.lifetime.end.p0(i64 2, ptr %17) #3
  call void @llvm.lifetime.end.p0(i64 2, ptr %16) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #3
  call void @llvm.lifetime.end.p0(i64 4, 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
  %714 = load i32, ptr %6, align 4
  ret i32 %714
}

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, !12, i64 160}
!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 164}
!17 = !{!14, !12, i64 8}
!18 = !{!14, !12, i64 12}
!19 = !{!14, !12, i64 168}
!20 = !{!14, !6, i64 112}
!21 = !{!14, !10, i64 122}
!22 = !{!14, !10, i64 120}
!23 = !{!14, !6, i64 96}
!24 = !{!14, !10, i64 106}
!25 = !{!14, !10, i64 104}
!26 = !{!14, !6, i64 128}
!27 = !{!14, !6, i64 136}
!28 = !{!14, !6, i64 0}
!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, 3) 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 = getelementptr inbounds i8, ptr %0, i64 160
  %7 = load i32, ptr %6, align 8, !tbaa !5
  %8 = icmp eq i32 %7, 1
  br i1 %8, label %237, label %9

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

15:                                               ; preds = %9
  %16 = load i32, ptr %13, align 8, !tbaa !14
  %17 = icmp eq i32 %16, 4194304
  br i1 %17, label %18, label %23

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

23:                                               ; preds = %18, %15
  store i32 0, ptr %6, align 8, !tbaa !5
  br label %237

24:                                               ; preds = %18, %9
  %25 = icmp eq ptr %1, null
  %26 = icmp eq ptr %2, null
  %or.cond3 = or i1 %25, %26
  %27 = icmp eq i16 %3, 0
  %or.cond6 = or i1 %or.cond3, %27
  br i1 %or.cond6, label %28, label %29

28:                                               ; preds = %24
  store i32 0, ptr %6, align 8, !tbaa !5
  br label %237

29:                                               ; preds = %24
  %30 = load volatile i32, ptr %11, align 4, !tbaa !13
  %.not = icmp eq i32 %30, 4
  br i1 %.not, label %32, label %31

31:                                               ; preds = %29
  store volatile i32 5, ptr %11, align 4, !tbaa !13
  br label %32

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

51:                                               ; preds = %32
  %52 = load volatile i32, ptr %41, align 4, !tbaa !26
  %53 = or i32 %52, 512
  store volatile i32 %53, ptr %41, align 4, !tbaa !26
  br label %54

54:                                               ; preds = %51, %32
  %55 = getelementptr inbounds i8, ptr %0, i64 16
  %56 = load i32, ptr %55, align 8, !tbaa !27
  %57 = icmp ugt i32 %56, 15
  br i1 %57, label %.lr.ph, label %98

.lr.ph:                                           ; preds = %54
  %58 = getelementptr inbounds i8, ptr %41, i64 20
  %59 = getelementptr inbounds i8, ptr %41, i64 32
  %60 = getelementptr inbounds i8, ptr %41, i64 48
  br label %61

61:                                               ; preds = %.lr.ph, %86
  %62 = phi ptr [ %2, %.lr.ph ], [ %87, %86 ]
  %63 = phi ptr [ %1, %.lr.ph ], [ %76, %86 ]
  %64 = phi i1 [ true, %.lr.ph ], [ %89, %86 ]
  %65 = phi i1 [ true, %.lr.ph ], [ %88, %86 ]
  %.0222 = phi i16 [ %3, %.lr.ph ], [ %.1, %86 ]
  %.0198221 = phi i16 [ %3, %.lr.ph ], [ %.1199, %86 ]
  %66 = load volatile i32, ptr %58, align 4, !tbaa !28
  %67 = and i32 %66, 2
  %68 = icmp ne i32 %67, 0
  %or.cond9 = and i1 %65, %68
  br i1 %or.cond9, label %69, label %75

69:                                               ; preds = %61
  %70 = load i32, ptr %63, align 4, !tbaa !29
  store volatile i32 %70, ptr %59, align 4, !tbaa !29
  %71 = getelementptr inbounds i8, ptr %63, i64 4
  store ptr %71, ptr %37, align 8, !tbaa !20
  %72 = load volatile i16, ptr %38, align 2, !tbaa !21
  %73 = add i16 %72, -1
  store volatile i16 %73, ptr %38, align 2, !tbaa !21
  %74 = load volatile i16, ptr %38, align 2, !tbaa !21
  br label %75

75:                                               ; preds = %69, %61
  %76 = phi ptr [ %71, %69 ], [ %63, %61 ]
  %.1199 = phi i16 [ %74, %69 ], [ %.0198221, %61 ]
  %77 = load volatile i32, ptr %58, align 4, !tbaa !28
  %78 = and i32 %77, 32776
  %79 = icmp ne i32 %78, 0
  %or.cond12 = select i1 %79, i1 %64, i1 false
  br i1 %or.cond12, label %80, label %86

80:                                               ; preds = %75
  %81 = load volatile i32, ptr %60, align 4, !tbaa !29
  store i32 %81, ptr %62, align 4, !tbaa !29
  %82 = getelementptr inbounds i8, ptr %62, i64 4
  store ptr %82, ptr %34, align 8, !tbaa !17
  %83 = load volatile i16, ptr %35, align 2, !tbaa !18
  %84 = add i16 %83, -1
  store volatile i16 %84, ptr %35, align 2, !tbaa !18
  %85 = load volatile i16, ptr %35, align 2, !tbaa !18
  br label %86

86:                                               ; preds = %80, %75
  %87 = phi ptr [ %82, %80 ], [ %62, %75 ]
  %.1 = phi i16 [ %85, %80 ], [ %.0222, %75 ]
  %88 = icmp ne i16 %.1199, 0
  %89 = icmp ne i16 %.1, 0
  %90 = select i1 %88, i1 true, i1 %89
  br i1 %90, label %61, label %._crit_edge, !llvm.loop !30

._crit_edge:                                      ; preds = %86
  %91 = tail call i32 @HAL_GetTick() #3
  %92 = sub i32 %91, %10
  %93 = icmp uge i32 %92, %4
  %94 = icmp ne i32 %4, -1
  %or.cond14 = and i1 %94, %93
  br i1 %or.cond14, label %95, label %.loopexit

95:                                               ; preds = %._crit_edge
  tail call void @SPI_CloseTransfer(ptr noundef nonnull %0)
  store i32 0, ptr %6, align 8, !tbaa !5
  %96 = load volatile i32, ptr %33, align 8, !tbaa !16
  %97 = or i32 %96, 256
  store volatile i32 %97, ptr %33, align 8, !tbaa !16
  store volatile i32 1, ptr %11, align 4, !tbaa !13
  br label %237

98:                                               ; preds = %54
  %99 = icmp ugt i32 %56, 7
  %100 = getelementptr inbounds i8, ptr %0, i64 64
  %101 = icmp ne i32 %4, -1
  br i1 %99, label %.preheader218, label %.preheader219

.preheader218:                                    ; preds = %98, %146
  %.2200 = phi i16 [ %.3201, %146 ], [ %3, %98 ]
  %.2 = phi i16 [ %.3, %146 ], [ %3, %98 ]
  %102 = icmp ne i16 %.2200, 0
  %103 = icmp ne i16 %.2, 0
  %104 = select i1 %102, i1 true, i1 %103
  br i1 %104, label %105, label %.loopexit

105:                                              ; preds = %.preheader218
  %106 = load ptr, ptr %0, align 8, !tbaa !23
  %107 = getelementptr inbounds i8, ptr %106, i64 20
  %108 = load volatile i32, ptr %107, align 4, !tbaa !28
  %109 = and i32 %108, 2
  %110 = icmp ne i32 %109, 0
  %or.cond19 = and i1 %102, %110
  br i1 %or.cond19, label %111, label %127

111:                                              ; preds = %105
  %112 = icmp ugt i16 %.2200, 1
  br i1 %112, label %113, label %._crit_edge228

._crit_edge228:                                   ; preds = %111
  %.pre229 = load ptr, ptr %37, align 8, !tbaa !20
  br label %119

113:                                              ; preds = %111
  %114 = load i32, ptr %100, align 8, !tbaa !32
  %.not214 = icmp eq i32 %114, 0
  %.pre230 = load ptr, ptr %37, align 8, !tbaa !20
  br i1 %.not214, label %119, label %115

115:                                              ; preds = %113
  %116 = load i32, ptr %.pre230, align 4, !tbaa !29
  %117 = getelementptr inbounds i8, ptr %106, i64 32
  store volatile i32 %116, ptr %117, align 4, !tbaa !29
  %118 = getelementptr inbounds i8, ptr %.pre230, i64 4
  br label %.sink.split

119:                                              ; preds = %._crit_edge228, %113
  %120 = phi ptr [ %.pre229, %._crit_edge228 ], [ %.pre230, %113 ]
  %121 = load i16, ptr %120, align 2, !tbaa !33
  %122 = getelementptr inbounds i8, ptr %106, i64 32
  store volatile i16 %121, ptr %122, align 4, !tbaa !33
  %123 = getelementptr inbounds i8, ptr %120, i64 2
  br label %.sink.split

.sink.split:                                      ; preds = %119, %115
  %.sink = phi ptr [ %118, %115 ], [ %123, %119 ]
  %.sink235 = phi i16 [ -2, %115 ], [ -1, %119 ]
  store ptr %.sink, ptr %37, align 8, !tbaa !20
  %124 = load volatile i16, ptr %38, align 2, !tbaa !21
  %125 = add i16 %124, %.sink235
  store volatile i16 %125, ptr %38, align 2, !tbaa !21
  %126 = load volatile i16, ptr %38, align 2, !tbaa !21
  br label %127

127:                                              ; preds = %.sink.split, %105
  %.3201 = phi i16 [ %.2200, %105 ], [ %126, %.sink.split ]
  %128 = load volatile i32, ptr %107, align 4, !tbaa !28
  %129 = and i32 %128, 57344
  %130 = icmp ne i32 %129, 0
  %or.cond22 = select i1 %130, i1 %103, i1 false
  br i1 %or.cond22, label %131, label %146

131:                                              ; preds = %127
  %132 = load volatile i32, ptr %107, align 4, !tbaa !28
  %133 = and i32 %132, 32768
  %.not215 = icmp eq i32 %133, 0
  %134 = getelementptr inbounds i8, ptr %106, i64 48
  br i1 %.not215, label %139, label %135

135:                                              ; preds = %131
  %136 = load volatile i32, ptr %134, align 4, !tbaa !29
  %137 = load ptr, ptr %34, align 8, !tbaa !17
  store i32 %136, ptr %137, align 4, !tbaa !29
  %138 = getelementptr inbounds i8, ptr %137, i64 4
  br label %.sink.split236

139:                                              ; preds = %131
  %140 = load volatile i16, ptr %134, align 4, !tbaa !33
  %141 = load ptr, ptr %34, align 8, !tbaa !17
  store i16 %140, ptr %141, align 2, !tbaa !33
  %142 = getelementptr inbounds i8, ptr %141, i64 2
  br label %.sink.split236

.sink.split236:                                   ; preds = %139, %135
  %.sink240 = phi ptr [ %138, %135 ], [ %142, %139 ]
  %.sink239 = phi i16 [ -2, %135 ], [ -1, %139 ]
  store ptr %.sink240, ptr %34, align 8, !tbaa !17
  %143 = load volatile i16, ptr %35, align 2, !tbaa !18
  %144 = add i16 %143, %.sink239
  store volatile i16 %144, ptr %35, align 2, !tbaa !18
  %145 = load volatile i16, ptr %35, align 2, !tbaa !18
  br label %146

146:                                              ; preds = %.sink.split236, %127
  %.3 = phi i16 [ %.2, %127 ], [ %145, %.sink.split236 ]
  %147 = tail call i32 @HAL_GetTick() #3
  %148 = sub i32 %147, %10
  %149 = icmp uge i32 %148, %4
  %or.cond24 = and i1 %101, %149
  br i1 %or.cond24, label %150, label %.preheader218, !llvm.loop !34

150:                                              ; preds = %146
  tail call void @SPI_CloseTransfer(ptr noundef nonnull %0)
  store i32 0, ptr %6, align 8, !tbaa !5
  %151 = load volatile i32, ptr %33, align 8, !tbaa !16
  %152 = or i32 %151, 256
  store volatile i32 %152, ptr %33, align 8, !tbaa !16
  store volatile i32 1, ptr %11, align 4, !tbaa !13
  br label %237

.preheader219:                                    ; preds = %98, %224
  %.4202 = phi i16 [ %.5203, %224 ], [ %3, %98 ]
  %.4 = phi i16 [ %.5, %224 ], [ %3, %98 ]
  %153 = icmp ne i16 %.4202, 0
  %154 = icmp ne i16 %.4, 0
  %155 = select i1 %153, i1 true, i1 %154
  br i1 %155, label %156, label %.loopexit

156:                                              ; preds = %.preheader219
  %157 = load ptr, ptr %0, align 8, !tbaa !23
  %158 = getelementptr inbounds i8, ptr %157, i64 20
  %159 = load volatile i32, ptr %158, align 4, !tbaa !28
  %160 = and i32 %159, 2
  %161 = icmp ne i32 %160, 0
  %or.cond29 = and i1 %153, %161
  br i1 %or.cond29, label %162, label %193

162:                                              ; preds = %156
  %163 = icmp ugt i16 %.4202, 3
  br i1 %163, label %164, label %174

164:                                              ; preds = %162
  %165 = load i32, ptr %100, align 8, !tbaa !32
  %166 = icmp ugt i32 %165, 64
  %.pre226.pre231 = load ptr, ptr %37, align 8, !tbaa !20
  br i1 %166, label %167, label %.thread

167:                                              ; preds = %164
  %168 = load i32, ptr %.pre226.pre231, align 4, !tbaa !29
  %169 = getelementptr inbounds i8, ptr %157, i64 32
  store volatile i32 %168, ptr %169, align 4, !tbaa !29
  %170 = getelementptr inbounds i8, ptr %.pre226.pre231, i64 4
  store ptr %170, ptr %37, align 8, !tbaa !20
  %171 = load volatile i16, ptr %38, align 2, !tbaa !21
  %172 = add i16 %171, -4
  store volatile i16 %172, ptr %38, align 2, !tbaa !21
  %173 = load volatile i16, ptr %38, align 2, !tbaa !21
  br label %193

174:                                              ; preds = %162
  %175 = icmp ugt i16 %.4202, 1
  br i1 %175, label %..thread_crit_edge, label %._crit_edge224

._crit_edge224:                                   ; preds = %174
  %.pre225 = load ptr, ptr %37, align 8, !tbaa !20
  br label %184

..thread_crit_edge:                               ; preds = %174
  %.pre = load i32, ptr %100, align 8, !tbaa !32
  %.pre226.pre = load ptr, ptr %37, align 8, !tbaa !20
  br label %.thread

.thread:                                          ; preds = %..thread_crit_edge, %164
  %.pre226 = phi ptr [ %.pre226.pre, %..thread_crit_edge ], [ %.pre226.pre231, %164 ]
  %176 = phi i32 [ %.pre, %..thread_crit_edge ], [ %165, %164 ]
  %.not212 = icmp eq i32 %176, 0
  br i1 %.not212, label %184, label %177

177:                                              ; preds = %.thread
  %178 = load i16, ptr %.pre226, align 2, !tbaa !33
  %179 = getelementptr inbounds i8, ptr %157, i64 32
  store volatile i16 %178, ptr %179, align 4, !tbaa !33
  %180 = getelementptr inbounds i8, ptr %.pre226, i64 2
  store ptr %180, ptr %37, align 8, !tbaa !20
  %181 = load volatile i16, ptr %38, align 2, !tbaa !21
  %182 = add i16 %181, -2
  store volatile i16 %182, ptr %38, align 2, !tbaa !21
  %183 = load volatile i16, ptr %38, align 2, !tbaa !21
  br label %193

184:                                              ; preds = %._crit_edge224, %.thread
  %185 = phi ptr [ %.pre225, %._crit_edge224 ], [ %.pre226, %.thread ]
  %186 = load i8, ptr %185, align 1, !tbaa !35
  %187 = getelementptr inbounds i8, ptr %157, i64 32
  store volatile i8 %186, ptr %187, align 4, !tbaa !35
  %188 = load ptr, ptr %37, align 8, !tbaa !20
  %189 = getelementptr inbounds i8, ptr %188, i64 1
  store ptr %189, ptr %37, align 8, !tbaa !20
  %190 = load volatile i16, ptr %38, align 2, !tbaa !21
  %191 = add i16 %190, -1
  store volatile i16 %191, ptr %38, align 2, !tbaa !21
  %192 = load volatile i16, ptr %38, align 2, !tbaa !21
  %.pre227 = load ptr, ptr %0, align 8, !tbaa !23
  br label %193

193:                                              ; preds = %167, %184, %177, %156
  %194 = phi ptr [ %157, %167 ], [ %157, %177 ], [ %.pre227, %184 ], [ %157, %156 ]
  %.5203 = phi i16 [ %173, %167 ], [ %183, %177 ], [ %192, %184 ], [ %.4202, %156 ]
  %195 = getelementptr inbounds i8, ptr %194, i64 20
  %196 = load volatile i32, ptr %195, align 4, !tbaa !28
  %197 = and i32 %196, 57344
  %198 = icmp ne i32 %197, 0
  %or.cond32 = select i1 %198, i1 %154, i1 false
  br i1 %or.cond32, label %199, label %224

199:                                              ; preds = %193
  %200 = load volatile i32, ptr %195, align 4, !tbaa !28
  %201 = and i32 %200, 32768
  %.not213 = icmp eq i32 %201, 0
  br i1 %.not213, label %207, label %202

202:                                              ; preds = %199
  %203 = getelementptr inbounds i8, ptr %194, i64 48
  %204 = load volatile i32, ptr %203, align 4, !tbaa !29
  %205 = load ptr, ptr %34, align 8, !tbaa !17
  store i32 %204, ptr %205, align 4, !tbaa !29
  %206 = getelementptr inbounds i8, ptr %205, i64 4
  br label %.sink.split241

207:                                              ; preds = %199
  %208 = load volatile i32, ptr %195, align 4, !tbaa !28
  %209 = and i32 %208, 24576
  %210 = icmp ugt i32 %209, 8192
  %211 = getelementptr inbounds i8, ptr %194, i64 48
  br i1 %210, label %212, label %216

212:                                              ; preds = %207
  %213 = load volatile i16, ptr %211, align 4, !tbaa !33
  %214 = load ptr, ptr %34, align 8, !tbaa !17
  store i16 %213, ptr %214, align 2, !tbaa !33
  %215 = getelementptr inbounds i8, ptr %214, i64 2
  br label %.sink.split241

216:                                              ; preds = %207
  %217 = load volatile i8, ptr %211, align 4, !tbaa !35
  %218 = load ptr, ptr %34, align 8, !tbaa !17
  store i8 %217, ptr %218, align 1, !tbaa !35
  %219 = load ptr, ptr %34, align 8, !tbaa !17
  %220 = getelementptr inbounds i8, ptr %219, i64 1
  br label %.sink.split241

.sink.split241:                                   ; preds = %212, %216, %202
  %.sink245 = phi ptr [ %206, %202 ], [ %220, %216 ], [ %215, %212 ]
  %.sink244 = phi i16 [ -4, %202 ], [ -1, %216 ], [ -2, %212 ]
  store ptr %.sink245, ptr %34, align 8, !tbaa !17
  %221 = load volatile i16, ptr %35, align 2, !tbaa !18
  %222 = add i16 %221, %.sink244
  store volatile i16 %222, ptr %35, align 2, !tbaa !18
  %223 = load volatile i16, ptr %35, align 2, !tbaa !18
  br label %224

224:                                              ; preds = %.sink.split241, %193
  %.5 = phi i16 [ %.4, %193 ], [ %223, %.sink.split241 ]
  %225 = tail call i32 @HAL_GetTick() #3
  %226 = sub i32 %225, %10
  %227 = icmp uge i32 %226, %4
  %or.cond34 = and i1 %101, %227
  br i1 %or.cond34, label %228, label %.preheader219, !llvm.loop !36

228:                                              ; preds = %224
  tail call void @SPI_CloseTransfer(ptr noundef nonnull %0)
  store i32 0, ptr %6, align 8, !tbaa !5
  %229 = load volatile i32, ptr %33, align 8, !tbaa !16
  %230 = or i32 %229, 256
  store volatile i32 %230, ptr %33, align 8, !tbaa !16
  store volatile i32 1, ptr %11, align 4, !tbaa !13
  br label %237

.loopexit:                                        ; preds = %.preheader219, %.preheader218, %._crit_edge
  %231 = tail call i32 @SPI_WaitOnFlagUntilTimeout(ptr noundef nonnull %0, i32 noundef 8, i32 noundef 0, i32 noundef %10, i32 noundef %4)
  %.not216 = icmp eq i32 %231, 0
  br i1 %.not216, label %235, label %232

232:                                              ; preds = %.loopexit
  %233 = load volatile i32, ptr %33, align 8, !tbaa !16
  %234 = or i32 %233, 32
  store volatile i32 %234, ptr %33, align 8, !tbaa !16
  br label %235

235:                                              ; preds = %232, %.loopexit
  tail call void @SPI_CloseTransfer(ptr noundef nonnull %0)
  store i32 0, ptr %6, align 8, !tbaa !5
  store volatile i32 1, ptr %11, align 4, !tbaa !13
  %236 = load volatile i32, ptr %33, align 8, !tbaa !16
  %.not217 = icmp ne i32 %236, 0
  %. = zext i1 %.not217 to i32
  br label %237

237:                                              ; preds = %235, %5, %228, %150, %95, %28, %23
  %.0204 = phi i32 [ 1, %28 ], [ 1, %95 ], [ 1, %150 ], [ 1, %228 ], [ 2, %23 ], [ 2, %5 ], [ %., %235 ]
  ret i32 %.0204
}

; 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, !11, i64 160}
!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 164}
!14 = !{!6, !11, i64 8}
!15 = !{!6, !11, i64 12}
!16 = !{!6, !11, i64 168}
!17 = !{!6, !7, i64 112}
!18 = !{!6, !12, i64 122}
!19 = !{!6, !12, i64 120}
!20 = !{!6, !7, i64 96}
!21 = !{!6, !12, i64 106}
!22 = !{!6, !12, i64 104}
!23 = !{!6, !7, i64 0}
!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,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,MemCpyOptPass,ReassociatePass,SCCPPass,SROAPass,SimplifyCFGPass,TailCallElimPass