; LLVM IR from introlab/odas :: src/system (steer2demixing)

; 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.steer2demixing_gss_obj = type { i32, i32, i32, float, float, float, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.tracks_obj = type { i32, ptr, ptr, ptr, ptr }
%struct.freqs_obj = type { i32, i32, ptr }
%struct.cmatrix_obj = type { ptr, ptr, i32, i32 }
%struct.demixings_obj = type { i32, i32, i32, ptr }
%struct.masks_obj = type { i32, i32, ptr }
%struct.steers_obj = type { i32, i32, i32, ptr }

; 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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #1

; Function Attrs: nounwind uwtable
define dso_local void @steer2demixing_gss_process(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5, ptr noundef %6, ptr noundef %7) #2 {
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca ptr, align 8
  %15 = alloca ptr, align 8
  %16 = alloca ptr, align 8
  %17 = alloca i32, align 4
  %18 = alloca i32, align 4
  %19 = alloca i32, align 4
  %20 = alloca i32, align 4
  %21 = alloca i32, align 4
  %22 = alloca i32, align 4
  %23 = alloca i32, align 4
  %24 = alloca i32, align 4
  %25 = alloca i32, align 4
  %26 = alloca float, align 4
  %27 = alloca float, align 4
  %28 = alloca float, align 4
  %29 = alloca float, align 4
  %30 = alloca float, align 4
  %31 = alloca float, align 4
  %32 = alloca float, align 4
  %33 = alloca float, align 4
  %34 = alloca float, align 4
  %35 = alloca float, align 4
  store ptr %0, ptr %9, align 8, !tbaa !5
  store ptr %1, ptr %10, align 8, !tbaa !5
  store ptr %2, ptr %11, align 8, !tbaa !5
  store ptr %3, ptr %12, align 8, !tbaa !5
  store ptr %4, ptr %13, align 8, !tbaa !5
  store ptr %5, ptr %14, align 8, !tbaa !5
  store ptr %6, ptr %15, align 8, !tbaa !5
  store ptr %7, ptr %16, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #4
  store i32 0, ptr %20, align 4, !tbaa !9
  store i32 0, ptr %17, align 4, !tbaa !9
  br label %36

36:                                               ; preds = %55, %8
  %37 = load i32, ptr %17, align 4, !tbaa !9
  %38 = load ptr, ptr %9, align 8, !tbaa !5
  %39 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %38, i32 0, i32 0
  %40 = load i32, ptr %39, align 8, !tbaa !11
  %41 = icmp ult i32 %37, %40
  br i1 %41, label %42, label %58

42:                                               ; preds = %36
  %43 = load ptr, ptr %11, align 8, !tbaa !5
  %44 = getelementptr inbounds %struct.tracks_obj, ptr %43, i32 0, i32 1
  %45 = load ptr, ptr %44, align 8, !tbaa !14
  %46 = load i32, ptr %17, align 4, !tbaa !9
  %47 = zext i32 %46 to i64
  %48 = getelementptr inbounds i64, ptr %45, i64 %47
  %49 = load i64, ptr %48, align 8, !tbaa !16
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %51, label %54

51:                                               ; preds = %42
  %52 = load i32, ptr %20, align 4, !tbaa !9
  %53 = add i32 %52, 1
  store i32 %53, ptr %20, align 4, !tbaa !9
  br label %54

54:                                               ; preds = %51, %42
  br label %55

55:                                               ; preds = %54
  %56 = load i32, ptr %17, align 4, !tbaa !9
  %57 = add i32 %56, 1
  store i32 %57, ptr %17, align 4, !tbaa !9
  br label %36, !llvm.loop !18

58:                                               ; preds = %36
  %59 = load i32, ptr %20, align 4, !tbaa !9
  %60 = icmp ugt i32 %59, 0
  br i1 %60, label %61, label %1248

61:                                               ; preds = %58
  store i32 0, ptr %18, align 4, !tbaa !9
  br label %62

62:                                               ; preds = %1244, %61
  %63 = load i32, ptr %18, align 4, !tbaa !9
  %64 = load ptr, ptr %9, align 8, !tbaa !5
  %65 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %64, i32 0, i32 2
  %66 = load i32, ptr %65, align 8, !tbaa !20
  %67 = icmp ult i32 %63, %66
  br i1 %67, label %68, label %1247

68:                                               ; preds = %62
  store i32 0, ptr %19, align 4, !tbaa !9
  br label %69

69:                                               ; preds = %168, %68
  %70 = load i32, ptr %19, align 4, !tbaa !9
  %71 = load ptr, ptr %9, align 8, !tbaa !5
  %72 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %71, i32 0, i32 1
  %73 = load i32, ptr %72, align 4, !tbaa !21
  %74 = icmp ult i32 %70, %73
  br i1 %74, label %75, label %171

75:                                               ; preds = %69
  %76 = load i32, ptr %18, align 4, !tbaa !9
  %77 = load ptr, ptr %9, align 8, !tbaa !5
  %78 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %77, i32 0, i32 1
  %79 = load i32, ptr %78, align 4, !tbaa !21
  %80 = mul i32 %76, %79
  %81 = load i32, ptr %19, align 4, !tbaa !9
  %82 = add i32 %80, %81
  store i32 %82, ptr %23, align 4, !tbaa !9
  %83 = load ptr, ptr %14, align 8, !tbaa !5
  %84 = getelementptr inbounds %struct.freqs_obj, ptr %83, i32 0, i32 2
  %85 = load ptr, ptr %84, align 8, !tbaa !22
  %86 = load i32, ptr %19, align 4, !tbaa !9
  %87 = zext i32 %86 to i64
  %88 = getelementptr inbounds ptr, ptr %85, i64 %87
  %89 = load ptr, ptr %88, align 8, !tbaa !5
  %90 = load i32, ptr %18, align 4, !tbaa !9
  %91 = mul i32 %90, 2
  %92 = add i32 %91, 0
  %93 = zext i32 %92 to i64
  %94 = getelementptr inbounds float, ptr %89, i64 %93
  %95 = load float, ptr %94, align 4, !tbaa !24
  %96 = load ptr, ptr %9, align 8, !tbaa !5
  %97 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %96, i32 0, i32 6
  %98 = load ptr, ptr %97, align 8, !tbaa !25
  %99 = getelementptr inbounds %struct.cmatrix_obj, ptr %98, i32 0, i32 0
  %100 = load ptr, ptr %99, align 8, !tbaa !26
  %101 = load i32, ptr %19, align 4, !tbaa !9
  %102 = zext i32 %101 to i64
  %103 = getelementptr inbounds float, ptr %100, i64 %102
  store float %95, ptr %103, align 4, !tbaa !24
  %104 = load ptr, ptr %14, align 8, !tbaa !5
  %105 = getelementptr inbounds %struct.freqs_obj, ptr %104, i32 0, i32 2
  %106 = load ptr, ptr %105, align 8, !tbaa !22
  %107 = load i32, ptr %19, align 4, !tbaa !9
  %108 = zext i32 %107 to i64
  %109 = getelementptr inbounds ptr, ptr %106, i64 %108
  %110 = load ptr, ptr %109, align 8, !tbaa !5
  %111 = load i32, ptr %18, align 4, !tbaa !9
  %112 = mul i32 %111, 2
  %113 = add i32 %112, 1
  %114 = zext i32 %113 to i64
  %115 = getelementptr inbounds float, ptr %110, i64 %114
  %116 = load float, ptr %115, align 4, !tbaa !24
  %117 = load ptr, ptr %9, align 8, !tbaa !5
  %118 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %117, i32 0, i32 6
  %119 = load ptr, ptr %118, align 8, !tbaa !25
  %120 = getelementptr inbounds %struct.cmatrix_obj, ptr %119, i32 0, i32 1
  %121 = load ptr, ptr %120, align 8, !tbaa !28
  %122 = load i32, ptr %19, align 4, !tbaa !9
  %123 = zext i32 %122 to i64
  %124 = getelementptr inbounds float, ptr %121, i64 %123
  store float %116, ptr %124, align 4, !tbaa !24
  %125 = load ptr, ptr %14, align 8, !tbaa !5
  %126 = getelementptr inbounds %struct.freqs_obj, ptr %125, i32 0, i32 2
  %127 = load ptr, ptr %126, align 8, !tbaa !22
  %128 = load i32, ptr %19, align 4, !tbaa !9
  %129 = zext i32 %128 to i64
  %130 = getelementptr inbounds ptr, ptr %127, i64 %129
  %131 = load ptr, ptr %130, align 8, !tbaa !5
  %132 = load i32, ptr %18, align 4, !tbaa !9
  %133 = mul i32 %132, 2
  %134 = add i32 %133, 0
  %135 = zext i32 %134 to i64
  %136 = getelementptr inbounds float, ptr %131, i64 %135
  %137 = load float, ptr %136, align 4, !tbaa !24
  %138 = load ptr, ptr %9, align 8, !tbaa !5
  %139 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %138, i32 0, i32 7
  %140 = load ptr, ptr %139, align 8, !tbaa !29
  %141 = getelementptr inbounds %struct.cmatrix_obj, ptr %140, i32 0, i32 0
  %142 = load ptr, ptr %141, align 8, !tbaa !26
  %143 = load i32, ptr %19, align 4, !tbaa !9
  %144 = zext i32 %143 to i64
  %145 = getelementptr inbounds float, ptr %142, i64 %144
  store float %137, ptr %145, align 4, !tbaa !24
  %146 = load ptr, ptr %14, align 8, !tbaa !5
  %147 = getelementptr inbounds %struct.freqs_obj, ptr %146, i32 0, i32 2
  %148 = load ptr, ptr %147, align 8, !tbaa !22
  %149 = load i32, ptr %19, align 4, !tbaa !9
  %150 = zext i32 %149 to i64
  %151 = getelementptr inbounds ptr, ptr %148, i64 %150
  %152 = load ptr, ptr %151, align 8, !tbaa !5
  %153 = load i32, ptr %18, align 4, !tbaa !9
  %154 = mul i32 %153, 2
  %155 = add i32 %154, 1
  %156 = zext i32 %155 to i64
  %157 = getelementptr inbounds float, ptr %152, i64 %156
  %158 = load float, ptr %157, align 4, !tbaa !24
  %159 = fmul float -1.000000e+00, %158
  %160 = load ptr, ptr %9, align 8, !tbaa !5
  %161 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %160, i32 0, i32 7
  %162 = load ptr, ptr %161, align 8, !tbaa !29
  %163 = getelementptr inbounds %struct.cmatrix_obj, ptr %162, i32 0, i32 1
  %164 = load ptr, ptr %163, align 8, !tbaa !28
  %165 = load i32, ptr %19, align 4, !tbaa !9
  %166 = zext i32 %165 to i64
  %167 = getelementptr inbounds float, ptr %164, i64 %166
  store float %159, ptr %167, align 4, !tbaa !24
  br label %168

168:                                              ; preds = %75
  %169 = load i32, ptr %19, align 4, !tbaa !9
  %170 = add i32 %169, 1
  store i32 %170, ptr %19, align 4, !tbaa !9
  br label %69, !llvm.loop !30

171:                                              ; preds = %69
  store i32 0, ptr %21, align 4, !tbaa !9
  %172 = load ptr, ptr %9, align 8, !tbaa !5
  %173 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %172, i32 0, i32 14
  %174 = load ptr, ptr %173, align 8, !tbaa !31
  %175 = load i32, ptr %20, align 4, !tbaa !9
  %176 = sub i32 %175, 1
  %177 = zext i32 %176 to i64
  %178 = getelementptr inbounds ptr, ptr %174, i64 %177
  %179 = load ptr, ptr %178, align 8, !tbaa !5
  call void @cmatrix_zero(ptr noundef %179)
  store i32 0, ptr %17, align 4, !tbaa !9
  br label %180

180:                                              ; preds = %480, %171
  %181 = load i32, ptr %17, align 4, !tbaa !9
  %182 = load ptr, ptr %9, align 8, !tbaa !5
  %183 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %182, i32 0, i32 0
  %184 = load i32, ptr %183, align 8, !tbaa !11
  %185 = icmp ult i32 %181, %184
  br i1 %185, label %186, label %483

186:                                              ; preds = %180
  %187 = load ptr, ptr %11, align 8, !tbaa !5
  %188 = getelementptr inbounds %struct.tracks_obj, ptr %187, i32 0, i32 1
  %189 = load ptr, ptr %188, align 8, !tbaa !14
  %190 = load i32, ptr %17, align 4, !tbaa !9
  %191 = zext i32 %190 to i64
  %192 = getelementptr inbounds i64, ptr %189, i64 %191
  %193 = load i64, ptr %192, align 8, !tbaa !16
  %194 = icmp ne i64 %193, 0
  br i1 %194, label %195, label %479

195:                                              ; preds = %186
  %196 = load ptr, ptr %11, align 8, !tbaa !5
  %197 = getelementptr inbounds %struct.tracks_obj, ptr %196, i32 0, i32 1
  %198 = load ptr, ptr %197, align 8, !tbaa !14
  %199 = load i32, ptr %17, align 4, !tbaa !9
  %200 = zext i32 %199 to i64
  %201 = getelementptr inbounds i64, ptr %198, i64 %200
  %202 = load i64, ptr %201, align 8, !tbaa !16
  %203 = load ptr, ptr %10, align 8, !tbaa !5
  %204 = getelementptr inbounds %struct.tracks_obj, ptr %203, i32 0, i32 1
  %205 = load ptr, ptr %204, align 8, !tbaa !14
  %206 = load i32, ptr %17, align 4, !tbaa !9
  %207 = zext i32 %206 to i64
  %208 = getelementptr inbounds i64, ptr %205, i64 %207
  %209 = load i64, ptr %208, align 8, !tbaa !16
  %210 = icmp eq i64 %202, %209
  br i1 %210, label %211, label %291

211:                                              ; preds = %195
  store i32 0, ptr %19, align 4, !tbaa !9
  br label %212

212:                                              ; preds = %287, %211
  %213 = load i32, ptr %19, align 4, !tbaa !9
  %214 = load ptr, ptr %9, align 8, !tbaa !5
  %215 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %214, i32 0, i32 1
  %216 = load i32, ptr %215, align 4, !tbaa !21
  %217 = icmp ult i32 %213, %216
  br i1 %217, label %218, label %290

218:                                              ; preds = %212
  %219 = load i32, ptr %18, align 4, !tbaa !9
  %220 = load ptr, ptr %9, align 8, !tbaa !5
  %221 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %220, i32 0, i32 1
  %222 = load i32, ptr %221, align 4, !tbaa !21
  %223 = mul i32 %219, %222
  %224 = load i32, ptr %19, align 4, !tbaa !9
  %225 = add i32 %223, %224
  store i32 %225, ptr %23, align 4, !tbaa !9
  %226 = load i32, ptr %21, align 4, !tbaa !9
  %227 = load ptr, ptr %9, align 8, !tbaa !5
  %228 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %227, i32 0, i32 1
  %229 = load i32, ptr %228, align 4, !tbaa !21
  %230 = mul i32 %226, %229
  %231 = load i32, ptr %19, align 4, !tbaa !9
  %232 = add i32 %230, %231
  store i32 %232, ptr %24, align 4, !tbaa !9
  %233 = load ptr, ptr %15, align 8, !tbaa !5
  %234 = getelementptr inbounds %struct.demixings_obj, ptr %233, i32 0, i32 3
  %235 = load ptr, ptr %234, align 8, !tbaa !32
  %236 = load i32, ptr %17, align 4, !tbaa !9
  %237 = zext i32 %236 to i64
  %238 = getelementptr inbounds ptr, ptr %235, i64 %237
  %239 = load ptr, ptr %238, align 8, !tbaa !5
  %240 = load i32, ptr %23, align 4, !tbaa !9
  %241 = mul i32 %240, 2
  %242 = add i32 %241, 0
  %243 = zext i32 %242 to i64
  %244 = getelementptr inbounds float, ptr %239, i64 %243
  %245 = load float, ptr %244, align 4, !tbaa !24
  store float %245, ptr %28, align 4, !tbaa !24
  %246 = load ptr, ptr %15, align 8, !tbaa !5
  %247 = getelementptr inbounds %struct.demixings_obj, ptr %246, i32 0, i32 3
  %248 = load ptr, ptr %247, align 8, !tbaa !32
  %249 = load i32, ptr %17, align 4, !tbaa !9
  %250 = zext i32 %249 to i64
  %251 = getelementptr inbounds ptr, ptr %248, i64 %250
  %252 = load ptr, ptr %251, align 8, !tbaa !5
  %253 = load i32, ptr %23, align 4, !tbaa !9
  %254 = mul i32 %253, 2
  %255 = add i32 %254, 1
  %256 = zext i32 %255 to i64
  %257 = getelementptr inbounds float, ptr %252, i64 %256
  %258 = load float, ptr %257, align 4, !tbaa !24
  store float %258, ptr %29, align 4, !tbaa !24
  %259 = load float, ptr %28, align 4, !tbaa !24
  %260 = load ptr, ptr %9, align 8, !tbaa !5
  %261 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %260, i32 0, i32 14
  %262 = load ptr, ptr %261, align 8, !tbaa !31
  %263 = load i32, ptr %20, align 4, !tbaa !9
  %264 = sub i32 %263, 1
  %265 = zext i32 %264 to i64
  %266 = getelementptr inbounds ptr, ptr %262, i64 %265
  %267 = load ptr, ptr %266, align 8, !tbaa !5
  %268 = getelementptr inbounds %struct.cmatrix_obj, ptr %267, i32 0, i32 0
  %269 = load ptr, ptr %268, align 8, !tbaa !26
  %270 = load i32, ptr %24, align 4, !tbaa !9
  %271 = zext i32 %270 to i64
  %272 = getelementptr inbounds float, ptr %269, i64 %271
  store float %259, ptr %272, align 4, !tbaa !24
  %273 = load float, ptr %29, align 4, !tbaa !24
  %274 = load ptr, ptr %9, align 8, !tbaa !5
  %275 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %274, i32 0, i32 14
  %276 = load ptr, ptr %275, align 8, !tbaa !31
  %277 = load i32, ptr %20, align 4, !tbaa !9
  %278 = sub i32 %277, 1
  %279 = zext i32 %278 to i64
  %280 = getelementptr inbounds ptr, ptr %276, i64 %279
  %281 = load ptr, ptr %280, align 8, !tbaa !5
  %282 = getelementptr inbounds %struct.cmatrix_obj, ptr %281, i32 0, i32 1
  %283 = load ptr, ptr %282, align 8, !tbaa !28
  %284 = load i32, ptr %24, align 4, !tbaa !9
  %285 = zext i32 %284 to i64
  %286 = getelementptr inbounds float, ptr %283, i64 %285
  store float %273, ptr %286, align 4, !tbaa !24
  br label %287

287:                                              ; preds = %218
  %288 = load i32, ptr %19, align 4, !tbaa !9
  %289 = add i32 %288, 1
  store i32 %289, ptr %19, align 4, !tbaa !9
  br label %212, !llvm.loop !34

290:                                              ; preds = %212
  br label %476

291:                                              ; preds = %195
  %292 = load ptr, ptr %9, align 8, !tbaa !5
  %293 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %292, i32 0, i32 3
  %294 = load float, ptr %293, align 4, !tbaa !35
  store float %294, ptr %30, align 4, !tbaa !24
  store i32 0, ptr %19, align 4, !tbaa !9
  br label %295

295:                                              ; preds = %368, %291
  %296 = load i32, ptr %19, align 4, !tbaa !9
  %297 = load ptr, ptr %9, align 8, !tbaa !5
  %298 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %297, i32 0, i32 1
  %299 = load i32, ptr %298, align 4, !tbaa !21
  %300 = icmp ult i32 %296, %299
  br i1 %300, label %301, label %371

301:                                              ; preds = %295
  %302 = load i32, ptr %18, align 4, !tbaa !9
  %303 = load ptr, ptr %9, align 8, !tbaa !5
  %304 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %303, i32 0, i32 1
  %305 = load i32, ptr %304, align 4, !tbaa !21
  %306 = mul i32 %302, %305
  %307 = load i32, ptr %19, align 4, !tbaa !9
  %308 = add i32 %306, %307
  store i32 %308, ptr %23, align 4, !tbaa !9
  %309 = load i32, ptr %17, align 4, !tbaa !9
  %310 = load ptr, ptr %9, align 8, !tbaa !5
  %311 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %310, i32 0, i32 1
  %312 = load i32, ptr %311, align 4, !tbaa !21
  %313 = mul i32 %309, %312
  %314 = load i32, ptr %19, align 4, !tbaa !9
  %315 = add i32 %313, %314
  store i32 %315, ptr %22, align 4, !tbaa !9
  %316 = load i32, ptr %21, align 4, !tbaa !9
  %317 = load ptr, ptr %9, align 8, !tbaa !5
  %318 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %317, i32 0, i32 1
  %319 = load i32, ptr %318, align 4, !tbaa !21
  %320 = mul i32 %316, %319
  %321 = load i32, ptr %19, align 4, !tbaa !9
  %322 = add i32 %320, %321
  store i32 %322, ptr %24, align 4, !tbaa !9
  %323 = load ptr, ptr %13, align 8, !tbaa !5
  %324 = getelementptr inbounds %struct.masks_obj, ptr %323, i32 0, i32 2
  %325 = load ptr, ptr %324, align 8, !tbaa !36
  %326 = load i32, ptr %22, align 4, !tbaa !9
  %327 = zext i32 %326 to i64
  %328 = getelementptr inbounds i8, ptr %325, i64 %327
  %329 = load i8, ptr %328, align 1, !tbaa !38
  %330 = sext i8 %329 to i32
  %331 = icmp eq i32 %330, 1
  br i1 %331, label %332, label %367

332:                                              ; preds = %301
  %333 = load ptr, ptr %12, align 8, !tbaa !5
  %334 = getelementptr inbounds %struct.steers_obj, ptr %333, i32 0, i32 3
  %335 = load ptr, ptr %334, align 8, !tbaa !39
  %336 = load i32, ptr %17, align 4, !tbaa !9
  %337 = zext i32 %336 to i64
  %338 = getelementptr inbounds ptr, ptr %335, i64 %337
  %339 = load ptr, ptr %338, align 8, !tbaa !5
  %340 = load i32, ptr %23, align 4, !tbaa !9
  %341 = mul i32 %340, 2
  %342 = add i32 %341, 0
  %343 = zext i32 %342 to i64
  %344 = getelementptr inbounds float, ptr %339, i64 %343
  %345 = load float, ptr %344, align 4, !tbaa !24
  store float %345, ptr %26, align 4, !tbaa !24
  %346 = load ptr, ptr %12, align 8, !tbaa !5
  %347 = getelementptr inbounds %struct.steers_obj, ptr %346, i32 0, i32 3
  %348 = load ptr, ptr %347, align 8, !tbaa !39
  %349 = load i32, ptr %17, align 4, !tbaa !9
  %350 = zext i32 %349 to i64
  %351 = getelementptr inbounds ptr, ptr %348, i64 %350
  %352 = load ptr, ptr %351, align 8, !tbaa !5
  %353 = load i32, ptr %23, align 4, !tbaa !9
  %354 = mul i32 %353, 2
  %355 = add i32 %354, 1
  %356 = zext i32 %355 to i64
  %357 = getelementptr inbounds float, ptr %352, i64 %356
  %358 = load float, ptr %357, align 4, !tbaa !24
  store float %358, ptr %27, align 4, !tbaa !24
  %359 = load float, ptr %26, align 4, !tbaa !24
  %360 = load float, ptr %26, align 4, !tbaa !24
  %361 = load float, ptr %27, align 4, !tbaa !24
  %362 = load float, ptr %27, align 4, !tbaa !24
  %363 = fmul float %361, %362
  %364 = call float @llvm.fmuladd.f32(float %359, float %360, float %363)
  %365 = load float, ptr %30, align 4, !tbaa !24
  %366 = fadd float %365, %364
  store float %366, ptr %30, align 4, !tbaa !24
  br label %367

367:                                              ; preds = %332, %301
  br label %368

368:                                              ; preds = %367
  %369 = load i32, ptr %19, align 4, !tbaa !9
  %370 = add i32 %369, 1
  store i32 %370, ptr %19, align 4, !tbaa !9
  br label %295, !llvm.loop !41

371:                                              ; preds = %295
  store i32 0, ptr %19, align 4, !tbaa !9
  br label %372

372:                                              ; preds = %472, %371
  %373 = load i32, ptr %19, align 4, !tbaa !9
  %374 = load ptr, ptr %9, align 8, !tbaa !5
  %375 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %374, i32 0, i32 1
  %376 = load i32, ptr %375, align 4, !tbaa !21
  %377 = icmp ult i32 %373, %376
  br i1 %377, label %378, label %475

378:                                              ; preds = %372
  %379 = load i32, ptr %18, align 4, !tbaa !9
  %380 = load ptr, ptr %9, align 8, !tbaa !5
  %381 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %380, i32 0, i32 1
  %382 = load i32, ptr %381, align 4, !tbaa !21
  %383 = mul i32 %379, %382
  %384 = load i32, ptr %19, align 4, !tbaa !9
  %385 = add i32 %383, %384
  store i32 %385, ptr %23, align 4, !tbaa !9
  %386 = load i32, ptr %17, align 4, !tbaa !9
  %387 = load ptr, ptr %9, align 8, !tbaa !5
  %388 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %387, i32 0, i32 1
  %389 = load i32, ptr %388, align 4, !tbaa !21
  %390 = mul i32 %386, %389
  %391 = load i32, ptr %19, align 4, !tbaa !9
  %392 = add i32 %390, %391
  store i32 %392, ptr %22, align 4, !tbaa !9
  %393 = load i32, ptr %21, align 4, !tbaa !9
  %394 = load ptr, ptr %9, align 8, !tbaa !5
  %395 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %394, i32 0, i32 1
  %396 = load i32, ptr %395, align 4, !tbaa !21
  %397 = mul i32 %393, %396
  %398 = load i32, ptr %19, align 4, !tbaa !9
  %399 = add i32 %397, %398
  store i32 %399, ptr %24, align 4, !tbaa !9
  %400 = load ptr, ptr %13, align 8, !tbaa !5
  %401 = getelementptr inbounds %struct.masks_obj, ptr %400, i32 0, i32 2
  %402 = load ptr, ptr %401, align 8, !tbaa !36
  %403 = load i32, ptr %22, align 4, !tbaa !9
  %404 = zext i32 %403 to i64
  %405 = getelementptr inbounds i8, ptr %402, i64 %404
  %406 = load i8, ptr %405, align 1, !tbaa !38
  %407 = sext i8 %406 to i32
  %408 = icmp eq i32 %407, 1
  br i1 %408, label %409, label %471

409:                                              ; preds = %378
  %410 = load ptr, ptr %12, align 8, !tbaa !5
  %411 = getelementptr inbounds %struct.steers_obj, ptr %410, i32 0, i32 3
  %412 = load ptr, ptr %411, align 8, !tbaa !39
  %413 = load i32, ptr %17, align 4, !tbaa !9
  %414 = zext i32 %413 to i64
  %415 = getelementptr inbounds ptr, ptr %412, i64 %414
  %416 = load ptr, ptr %415, align 8, !tbaa !5
  %417 = load i32, ptr %23, align 4, !tbaa !9
  %418 = mul i32 %417, 2
  %419 = add i32 %418, 0
  %420 = zext i32 %419 to i64
  %421 = getelementptr inbounds float, ptr %416, i64 %420
  %422 = load float, ptr %421, align 4, !tbaa !24
  store float %422, ptr %26, align 4, !tbaa !24
  %423 = load ptr, ptr %12, align 8, !tbaa !5
  %424 = getelementptr inbounds %struct.steers_obj, ptr %423, i32 0, i32 3
  %425 = load ptr, ptr %424, align 8, !tbaa !39
  %426 = load i32, ptr %17, align 4, !tbaa !9
  %427 = zext i32 %426 to i64
  %428 = getelementptr inbounds ptr, ptr %425, i64 %427
  %429 = load ptr, ptr %428, align 8, !tbaa !5
  %430 = load i32, ptr %23, align 4, !tbaa !9
  %431 = mul i32 %430, 2
  %432 = add i32 %431, 1
  %433 = zext i32 %432 to i64
  %434 = getelementptr inbounds float, ptr %429, i64 %433
  %435 = load float, ptr %434, align 4, !tbaa !24
  store float %435, ptr %27, align 4, !tbaa !24
  %436 = load float, ptr %26, align 4, !tbaa !24
  %437 = load float, ptr %30, align 4, !tbaa !24
  %438 = fdiv float %436, %437
  store float %438, ptr %28, align 4, !tbaa !24
  %439 = load float, ptr %27, align 4, !tbaa !24
  %440 = fmul float -1.000000e+00, %439
  %441 = load float, ptr %30, align 4, !tbaa !24
  %442 = fdiv float %440, %441
  store float %442, ptr %29, align 4, !tbaa !24
  %443 = load float, ptr %28, align 4, !tbaa !24
  %444 = load ptr, ptr %9, align 8, !tbaa !5
  %445 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %444, i32 0, i32 14
  %446 = load ptr, ptr %445, align 8, !tbaa !31
  %447 = load i32, ptr %20, align 4, !tbaa !9
  %448 = sub i32 %447, 1
  %449 = zext i32 %448 to i64
  %450 = getelementptr inbounds ptr, ptr %446, i64 %449
  %451 = load ptr, ptr %450, align 8, !tbaa !5
  %452 = getelementptr inbounds %struct.cmatrix_obj, ptr %451, i32 0, i32 0
  %453 = load ptr, ptr %452, align 8, !tbaa !26
  %454 = load i32, ptr %24, align 4, !tbaa !9
  %455 = zext i32 %454 to i64
  %456 = getelementptr inbounds float, ptr %453, i64 %455
  store float %443, ptr %456, align 4, !tbaa !24
  %457 = load float, ptr %29, align 4, !tbaa !24
  %458 = load ptr, ptr %9, align 8, !tbaa !5
  %459 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %458, i32 0, i32 14
  %460 = load ptr, ptr %459, align 8, !tbaa !31
  %461 = load i32, ptr %20, align 4, !tbaa !9
  %462 = sub i32 %461, 1
  %463 = zext i32 %462 to i64
  %464 = getelementptr inbounds ptr, ptr %460, i64 %463
  %465 = load ptr, ptr %464, align 8, !tbaa !5
  %466 = getelementptr inbounds %struct.cmatrix_obj, ptr %465, i32 0, i32 1
  %467 = load ptr, ptr %466, align 8, !tbaa !28
  %468 = load i32, ptr %24, align 4, !tbaa !9
  %469 = zext i32 %468 to i64
  %470 = getelementptr inbounds float, ptr %467, i64 %469
  store float %457, ptr %470, align 4, !tbaa !24
  br label %471

471:                                              ; preds = %409, %378
  br label %472

472:                                              ; preds = %471
  %473 = load i32, ptr %19, align 4, !tbaa !9
  %474 = add i32 %473, 1
  store i32 %474, ptr %19, align 4, !tbaa !9
  br label %372, !llvm.loop !42

475:                                              ; preds = %372
  br label %476

476:                                              ; preds = %475, %290
  %477 = load i32, ptr %21, align 4, !tbaa !9
  %478 = add i32 %477, 1
  store i32 %478, ptr %21, align 4, !tbaa !9
  br label %479

479:                                              ; preds = %476, %186
  br label %480

480:                                              ; preds = %479
  %481 = load i32, ptr %17, align 4, !tbaa !9
  %482 = add i32 %481, 1
  store i32 %482, ptr %17, align 4, !tbaa !9
  br label %180, !llvm.loop !43

483:                                              ; preds = %180
  %484 = load ptr, ptr %9, align 8, !tbaa !5
  %485 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %484, i32 0, i32 8
  %486 = load ptr, ptr %485, align 8, !tbaa !44
  %487 = load i32, ptr %20, align 4, !tbaa !9
  %488 = sub i32 %487, 1
  %489 = zext i32 %488 to i64
  %490 = getelementptr inbounds ptr, ptr %486, i64 %489
  %491 = load ptr, ptr %490, align 8, !tbaa !5
  %492 = load ptr, ptr %9, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %492, i32 0, i32 14
  %494 = load ptr, ptr %493, align 8, !tbaa !31
  %495 = load i32, ptr %20, align 4, !tbaa !9
  %496 = sub i32 %495, 1
  %497 = zext i32 %496 to i64
  %498 = getelementptr inbounds ptr, ptr %494, i64 %497
  %499 = load ptr, ptr %498, align 8, !tbaa !5
  %500 = load ptr, ptr %9, align 8, !tbaa !5
  %501 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %500, i32 0, i32 6
  %502 = load ptr, ptr %501, align 8, !tbaa !25
  call void @cmatrix_mul(ptr noundef %491, ptr noundef %499, ptr noundef %502)
  %503 = load ptr, ptr %9, align 8, !tbaa !5
  %504 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %503, i32 0, i32 9
  %505 = load ptr, ptr %504, align 8, !tbaa !45
  %506 = load i32, ptr %20, align 4, !tbaa !9
  %507 = sub i32 %506, 1
  %508 = zext i32 %507 to i64
  %509 = getelementptr inbounds ptr, ptr %505, i64 %508
  %510 = load ptr, ptr %509, align 8, !tbaa !5
  %511 = load ptr, ptr %9, align 8, !tbaa !5
  %512 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %511, i32 0, i32 8
  %513 = load ptr, ptr %512, align 8, !tbaa !44
  %514 = load i32, ptr %20, align 4, !tbaa !9
  %515 = sub i32 %514, 1
  %516 = zext i32 %515 to i64
  %517 = getelementptr inbounds ptr, ptr %513, i64 %516
  %518 = load ptr, ptr %517, align 8, !tbaa !5
  call void @cmatrix_hermitian(ptr noundef %510, ptr noundef %518)
  %519 = load ptr, ptr %9, align 8, !tbaa !5
  %520 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %519, i32 0, i32 10
  %521 = load ptr, ptr %520, align 8, !tbaa !46
  %522 = load i32, ptr %20, align 4, !tbaa !9
  %523 = sub i32 %522, 1
  %524 = zext i32 %523 to i64
  %525 = getelementptr inbounds ptr, ptr %521, i64 %524
  %526 = load ptr, ptr %525, align 8, !tbaa !5
  %527 = load ptr, ptr %9, align 8, !tbaa !5
  %528 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %527, i32 0, i32 8
  %529 = load ptr, ptr %528, align 8, !tbaa !44
  %530 = load i32, ptr %20, align 4, !tbaa !9
  %531 = sub i32 %530, 1
  %532 = zext i32 %531 to i64
  %533 = getelementptr inbounds ptr, ptr %529, i64 %532
  %534 = load ptr, ptr %533, align 8, !tbaa !5
  %535 = load ptr, ptr %9, align 8, !tbaa !5
  %536 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %535, i32 0, i32 9
  %537 = load ptr, ptr %536, align 8, !tbaa !45
  %538 = load i32, ptr %20, align 4, !tbaa !9
  %539 = sub i32 %538, 1
  %540 = zext i32 %539 to i64
  %541 = getelementptr inbounds ptr, ptr %537, i64 %540
  %542 = load ptr, ptr %541, align 8, !tbaa !5
  call void @cmatrix_mul(ptr noundef %526, ptr noundef %534, ptr noundef %542)
  %543 = load ptr, ptr %9, align 8, !tbaa !5
  %544 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %543, i32 0, i32 11
  %545 = load ptr, ptr %544, align 8, !tbaa !47
  %546 = load i32, ptr %20, align 4, !tbaa !9
  %547 = sub i32 %546, 1
  %548 = zext i32 %547 to i64
  %549 = getelementptr inbounds ptr, ptr %545, i64 %548
  %550 = load ptr, ptr %549, align 8, !tbaa !5
  %551 = load ptr, ptr %9, align 8, !tbaa !5
  %552 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %551, i32 0, i32 10
  %553 = load ptr, ptr %552, align 8, !tbaa !46
  %554 = load i32, ptr %20, align 4, !tbaa !9
  %555 = sub i32 %554, 1
  %556 = zext i32 %555 to i64
  %557 = getelementptr inbounds ptr, ptr %553, i64 %556
  %558 = load ptr, ptr %557, align 8, !tbaa !5
  call void @cmatrix_copy_cmatrix(ptr noundef %550, ptr noundef %558)
  store i32 0, ptr %21, align 4, !tbaa !9
  br label %559

559:                                              ; preds = %598, %483
  %560 = load i32, ptr %21, align 4, !tbaa !9
  %561 = load i32, ptr %20, align 4, !tbaa !9
  %562 = icmp ult i32 %560, %561
  br i1 %562, label %563, label %601

563:                                              ; preds = %559
  %564 = load ptr, ptr %9, align 8, !tbaa !5
  %565 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %564, i32 0, i32 11
  %566 = load ptr, ptr %565, align 8, !tbaa !47
  %567 = load i32, ptr %20, align 4, !tbaa !9
  %568 = sub i32 %567, 1
  %569 = zext i32 %568 to i64
  %570 = getelementptr inbounds ptr, ptr %566, i64 %569
  %571 = load ptr, ptr %570, align 8, !tbaa !5
  %572 = getelementptr inbounds %struct.cmatrix_obj, ptr %571, i32 0, i32 0
  %573 = load ptr, ptr %572, align 8, !tbaa !26
  %574 = load i32, ptr %21, align 4, !tbaa !9
  %575 = load i32, ptr %20, align 4, !tbaa !9
  %576 = mul i32 %574, %575
  %577 = load i32, ptr %21, align 4, !tbaa !9
  %578 = add i32 %576, %577
  %579 = zext i32 %578 to i64
  %580 = getelementptr inbounds float, ptr %573, i64 %579
  store float 0.000000e+00, ptr %580, align 4, !tbaa !24
  %581 = load ptr, ptr %9, align 8, !tbaa !5
  %582 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %581, i32 0, i32 11
  %583 = load ptr, ptr %582, align 8, !tbaa !47
  %584 = load i32, ptr %20, align 4, !tbaa !9
  %585 = sub i32 %584, 1
  %586 = zext i32 %585 to i64
  %587 = getelementptr inbounds ptr, ptr %583, i64 %586
  %588 = load ptr, ptr %587, align 8, !tbaa !5
  %589 = getelementptr inbounds %struct.cmatrix_obj, ptr %588, i32 0, i32 1
  %590 = load ptr, ptr %589, align 8, !tbaa !28
  %591 = load i32, ptr %21, align 4, !tbaa !9
  %592 = load i32, ptr %20, align 4, !tbaa !9
  %593 = mul i32 %591, %592
  %594 = load i32, ptr %21, align 4, !tbaa !9
  %595 = add i32 %593, %594
  %596 = zext i32 %595 to i64
  %597 = getelementptr inbounds float, ptr %590, i64 %596
  store float 0.000000e+00, ptr %597, align 4, !tbaa !24
  br label %598

598:                                              ; preds = %563
  %599 = load i32, ptr %21, align 4, !tbaa !9
  %600 = add i32 %599, 1
  store i32 %600, ptr %21, align 4, !tbaa !9
  br label %559, !llvm.loop !48

601:                                              ; preds = %559
  store i32 0, ptr %21, align 4, !tbaa !9
  %602 = load ptr, ptr %9, align 8, !tbaa !5
  %603 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %602, i32 0, i32 12
  %604 = load ptr, ptr %603, align 8, !tbaa !49
  %605 = load i32, ptr %20, align 4, !tbaa !9
  %606 = sub i32 %605, 1
  %607 = zext i32 %606 to i64
  %608 = getelementptr inbounds ptr, ptr %604, i64 %607
  %609 = load ptr, ptr %608, align 8, !tbaa !5
  call void @cmatrix_zero(ptr noundef %609)
  %610 = load ptr, ptr %9, align 8, !tbaa !5
  %611 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %610, i32 0, i32 13
  %612 = load ptr, ptr %611, align 8, !tbaa !50
  %613 = load i32, ptr %20, align 4, !tbaa !9
  %614 = sub i32 %613, 1
  %615 = zext i32 %614 to i64
  %616 = getelementptr inbounds ptr, ptr %612, i64 %615
  %617 = load ptr, ptr %616, align 8, !tbaa !5
  call void @cmatrix_zero(ptr noundef %617)
  store i32 0, ptr %17, align 4, !tbaa !9
  br label %618

618:                                              ; preds = %768, %601
  %619 = load i32, ptr %17, align 4, !tbaa !9
  %620 = load ptr, ptr %9, align 8, !tbaa !5
  %621 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %620, i32 0, i32 0
  %622 = load i32, ptr %621, align 8, !tbaa !11
  %623 = icmp ult i32 %619, %622
  br i1 %623, label %624, label %771

624:                                              ; preds = %618
  %625 = load ptr, ptr %11, align 8, !tbaa !5
  %626 = getelementptr inbounds %struct.tracks_obj, ptr %625, i32 0, i32 1
  %627 = load ptr, ptr %626, align 8, !tbaa !14
  %628 = load i32, ptr %17, align 4, !tbaa !9
  %629 = zext i32 %628 to i64
  %630 = getelementptr inbounds i64, ptr %627, i64 %629
  %631 = load i64, ptr %630, align 8, !tbaa !16
  %632 = icmp ne i64 %631, 0
  br i1 %632, label %633, label %767

633:                                              ; preds = %624
  store i32 0, ptr %19, align 4, !tbaa !9
  br label %634

634:                                              ; preds = %761, %633
  %635 = load i32, ptr %19, align 4, !tbaa !9
  %636 = load ptr, ptr %9, align 8, !tbaa !5
  %637 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %636, i32 0, i32 1
  %638 = load i32, ptr %637, align 4, !tbaa !21
  %639 = icmp ult i32 %635, %638
  br i1 %639, label %640, label %764

640:                                              ; preds = %634
  %641 = load i32, ptr %18, align 4, !tbaa !9
  %642 = load ptr, ptr %9, align 8, !tbaa !5
  %643 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %642, i32 0, i32 1
  %644 = load i32, ptr %643, align 4, !tbaa !21
  %645 = mul i32 %641, %644
  %646 = load i32, ptr %19, align 4, !tbaa !9
  %647 = add i32 %645, %646
  store i32 %647, ptr %23, align 4, !tbaa !9
  %648 = load i32, ptr %17, align 4, !tbaa !9
  %649 = load ptr, ptr %9, align 8, !tbaa !5
  %650 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %649, i32 0, i32 1
  %651 = load i32, ptr %650, align 4, !tbaa !21
  %652 = mul i32 %648, %651
  %653 = load i32, ptr %19, align 4, !tbaa !9
  %654 = add i32 %652, %653
  store i32 %654, ptr %22, align 4, !tbaa !9
  %655 = load i32, ptr %19, align 4, !tbaa !9
  %656 = load i32, ptr %20, align 4, !tbaa !9
  %657 = mul i32 %655, %656
  %658 = load i32, ptr %21, align 4, !tbaa !9
  %659 = add i32 %657, %658
  store i32 %659, ptr %25, align 4, !tbaa !9
  %660 = load i32, ptr %21, align 4, !tbaa !9
  %661 = load ptr, ptr %9, align 8, !tbaa !5
  %662 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %661, i32 0, i32 1
  %663 = load i32, ptr %662, align 4, !tbaa !21
  %664 = mul i32 %660, %663
  %665 = load i32, ptr %19, align 4, !tbaa !9
  %666 = add i32 %664, %665
  store i32 %666, ptr %24, align 4, !tbaa !9
  %667 = load ptr, ptr %13, align 8, !tbaa !5
  %668 = getelementptr inbounds %struct.masks_obj, ptr %667, i32 0, i32 2
  %669 = load ptr, ptr %668, align 8, !tbaa !36
  %670 = load i32, ptr %22, align 4, !tbaa !9
  %671 = zext i32 %670 to i64
  %672 = getelementptr inbounds i8, ptr %669, i64 %671
  %673 = load i8, ptr %672, align 1, !tbaa !38
  %674 = sext i8 %673 to i32
  %675 = icmp eq i32 %674, 1
  br i1 %675, label %676, label %760

676:                                              ; preds = %640
  %677 = load ptr, ptr %12, align 8, !tbaa !5
  %678 = getelementptr inbounds %struct.steers_obj, ptr %677, i32 0, i32 3
  %679 = load ptr, ptr %678, align 8, !tbaa !39
  %680 = load i32, ptr %17, align 4, !tbaa !9
  %681 = zext i32 %680 to i64
  %682 = getelementptr inbounds ptr, ptr %679, i64 %681
  %683 = load ptr, ptr %682, align 8, !tbaa !5
  %684 = load i32, ptr %23, align 4, !tbaa !9
  %685 = mul i32 %684, 2
  %686 = add i32 %685, 0
  %687 = zext i32 %686 to i64
  %688 = getelementptr inbounds float, ptr %683, i64 %687
  %689 = load float, ptr %688, align 4, !tbaa !24
  store float %689, ptr %26, align 4, !tbaa !24
  %690 = load ptr, ptr %12, align 8, !tbaa !5
  %691 = getelementptr inbounds %struct.steers_obj, ptr %690, i32 0, i32 3
  %692 = load ptr, ptr %691, align 8, !tbaa !39
  %693 = load i32, ptr %17, align 4, !tbaa !9
  %694 = zext i32 %693 to i64
  %695 = getelementptr inbounds ptr, ptr %692, i64 %694
  %696 = load ptr, ptr %695, align 8, !tbaa !5
  %697 = load i32, ptr %23, align 4, !tbaa !9
  %698 = mul i32 %697, 2
  %699 = add i32 %698, 1
  %700 = zext i32 %699 to i64
  %701 = getelementptr inbounds float, ptr %696, i64 %700
  %702 = load float, ptr %701, align 4, !tbaa !24
  store float %702, ptr %27, align 4, !tbaa !24
  %703 = load float, ptr %26, align 4, !tbaa !24
  %704 = load ptr, ptr %9, align 8, !tbaa !5
  %705 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %704, i32 0, i32 12
  %706 = load ptr, ptr %705, align 8, !tbaa !49
  %707 = load i32, ptr %20, align 4, !tbaa !9
  %708 = sub i32 %707, 1
  %709 = zext i32 %708 to i64
  %710 = getelementptr inbounds ptr, ptr %706, i64 %709
  %711 = load ptr, ptr %710, align 8, !tbaa !5
  %712 = getelementptr inbounds %struct.cmatrix_obj, ptr %711, i32 0, i32 0
  %713 = load ptr, ptr %712, align 8, !tbaa !26
  %714 = load i32, ptr %25, align 4, !tbaa !9
  %715 = zext i32 %714 to i64
  %716 = getelementptr inbounds float, ptr %713, i64 %715
  store float %703, ptr %716, align 4, !tbaa !24
  %717 = load float, ptr %27, align 4, !tbaa !24
  %718 = load ptr, ptr %9, align 8, !tbaa !5
  %719 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %718, i32 0, i32 12
  %720 = load ptr, ptr %719, align 8, !tbaa !49
  %721 = load i32, ptr %20, align 4, !tbaa !9
  %722 = sub i32 %721, 1
  %723 = zext i32 %722 to i64
  %724 = getelementptr inbounds ptr, ptr %720, i64 %723
  %725 = load ptr, ptr %724, align 8, !tbaa !5
  %726 = getelementptr inbounds %struct.cmatrix_obj, ptr %725, i32 0, i32 1
  %727 = load ptr, ptr %726, align 8, !tbaa !28
  %728 = load i32, ptr %25, align 4, !tbaa !9
  %729 = zext i32 %728 to i64
  %730 = getelementptr inbounds float, ptr %727, i64 %729
  store float %717, ptr %730, align 4, !tbaa !24
  %731 = load float, ptr %26, align 4, !tbaa !24
  %732 = load ptr, ptr %9, align 8, !tbaa !5
  %733 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %732, i32 0, i32 13
  %734 = load ptr, ptr %733, align 8, !tbaa !50
  %735 = load i32, ptr %20, align 4, !tbaa !9
  %736 = sub i32 %735, 1
  %737 = zext i32 %736 to i64
  %738 = getelementptr inbounds ptr, ptr %734, i64 %737
  %739 = load ptr, ptr %738, align 8, !tbaa !5
  %740 = getelementptr inbounds %struct.cmatrix_obj, ptr %739, i32 0, i32 0
  %741 = load ptr, ptr %740, align 8, !tbaa !26
  %742 = load i32, ptr %24, align 4, !tbaa !9
  %743 = zext i32 %742 to i64
  %744 = getelementptr inbounds float, ptr %741, i64 %743
  store float %731, ptr %744, align 4, !tbaa !24
  %745 = load float, ptr %27, align 4, !tbaa !24
  %746 = fmul float -1.000000e+00, %745
  %747 = load ptr, ptr %9, align 8, !tbaa !5
  %748 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %747, i32 0, i32 13
  %749 = load ptr, ptr %748, align 8, !tbaa !50
  %750 = load i32, ptr %20, align 4, !tbaa !9
  %751 = sub i32 %750, 1
  %752 = zext i32 %751 to i64
  %753 = getelementptr inbounds ptr, ptr %749, i64 %752
  %754 = load ptr, ptr %753, align 8, !tbaa !5
  %755 = getelementptr inbounds %struct.cmatrix_obj, ptr %754, i32 0, i32 1
  %756 = load ptr, ptr %755, align 8, !tbaa !28
  %757 = load i32, ptr %24, align 4, !tbaa !9
  %758 = zext i32 %757 to i64
  %759 = getelementptr inbounds float, ptr %756, i64 %758
  store float %746, ptr %759, align 4, !tbaa !24
  br label %760

760:                                              ; preds = %676, %640
  br label %761

761:                                              ; preds = %760
  %762 = load i32, ptr %19, align 4, !tbaa !9
  %763 = add i32 %762, 1
  store i32 %763, ptr %19, align 4, !tbaa !9
  br label %634, !llvm.loop !51

764:                                              ; preds = %634
  %765 = load i32, ptr %21, align 4, !tbaa !9
  %766 = add i32 %765, 1
  store i32 %766, ptr %21, align 4, !tbaa !9
  br label %767

767:                                              ; preds = %764, %624
  br label %768

768:                                              ; preds = %767
  %769 = load i32, ptr %17, align 4, !tbaa !9
  %770 = add i32 %769, 1
  store i32 %770, ptr %17, align 4, !tbaa !9
  br label %618, !llvm.loop !52

771:                                              ; preds = %618
  %772 = load ptr, ptr %9, align 8, !tbaa !5
  %773 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %772, i32 0, i32 18
  %774 = load ptr, ptr %773, align 8, !tbaa !53
  %775 = load i32, ptr %20, align 4, !tbaa !9
  %776 = sub i32 %775, 1
  %777 = zext i32 %776 to i64
  %778 = getelementptr inbounds ptr, ptr %774, i64 %777
  %779 = load ptr, ptr %778, align 8, !tbaa !5
  %780 = load ptr, ptr %9, align 8, !tbaa !5
  %781 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %780, i32 0, i32 11
  %782 = load ptr, ptr %781, align 8, !tbaa !47
  %783 = load i32, ptr %20, align 4, !tbaa !9
  %784 = sub i32 %783, 1
  %785 = zext i32 %784 to i64
  %786 = getelementptr inbounds ptr, ptr %782, i64 %785
  %787 = load ptr, ptr %786, align 8, !tbaa !5
  %788 = load ptr, ptr %9, align 8, !tbaa !5
  %789 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %788, i32 0, i32 8
  %790 = load ptr, ptr %789, align 8, !tbaa !44
  %791 = load i32, ptr %20, align 4, !tbaa !9
  %792 = sub i32 %791, 1
  %793 = zext i32 %792 to i64
  %794 = getelementptr inbounds ptr, ptr %790, i64 %793
  %795 = load ptr, ptr %794, align 8, !tbaa !5
  call void @cmatrix_mul(ptr noundef %779, ptr noundef %787, ptr noundef %795)
  %796 = load ptr, ptr %9, align 8, !tbaa !5
  %797 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %796, i32 0, i32 19
  %798 = load ptr, ptr %797, align 8, !tbaa !54
  %799 = load i32, ptr %20, align 4, !tbaa !9
  %800 = sub i32 %799, 1
  %801 = zext i32 %800 to i64
  %802 = getelementptr inbounds ptr, ptr %798, i64 %801
  %803 = load ptr, ptr %802, align 8, !tbaa !5
  %804 = load ptr, ptr %9, align 8, !tbaa !5
  %805 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %804, i32 0, i32 18
  %806 = load ptr, ptr %805, align 8, !tbaa !53
  %807 = load i32, ptr %20, align 4, !tbaa !9
  %808 = sub i32 %807, 1
  %809 = zext i32 %808 to i64
  %810 = getelementptr inbounds ptr, ptr %806, i64 %809
  %811 = load ptr, ptr %810, align 8, !tbaa !5
  call void @cmatrix_scale(ptr noundef %803, ptr noundef %811, float noundef 4.000000e+00)
  %812 = load ptr, ptr %9, align 8, !tbaa !5
  %813 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %812, i32 0, i32 20
  %814 = load ptr, ptr %813, align 8, !tbaa !55
  %815 = load i32, ptr %20, align 4, !tbaa !9
  %816 = sub i32 %815, 1
  %817 = zext i32 %816 to i64
  %818 = getelementptr inbounds ptr, ptr %814, i64 %817
  %819 = load ptr, ptr %818, align 8, !tbaa !5
  %820 = load ptr, ptr %9, align 8, !tbaa !5
  %821 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %820, i32 0, i32 19
  %822 = load ptr, ptr %821, align 8, !tbaa !54
  %823 = load i32, ptr %20, align 4, !tbaa !9
  %824 = sub i32 %823, 1
  %825 = zext i32 %824 to i64
  %826 = getelementptr inbounds ptr, ptr %822, i64 %825
  %827 = load ptr, ptr %826, align 8, !tbaa !5
  %828 = load ptr, ptr %9, align 8, !tbaa !5
  %829 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %828, i32 0, i32 7
  %830 = load ptr, ptr %829, align 8, !tbaa !29
  call void @cmatrix_mul(ptr noundef %819, ptr noundef %827, ptr noundef %830)
  %831 = load ptr, ptr %9, align 8, !tbaa !5
  %832 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %831, i32 0, i32 16
  %833 = load ptr, ptr %832, align 8, !tbaa !56
  %834 = load i32, ptr %20, align 4, !tbaa !9
  %835 = sub i32 %834, 1
  %836 = zext i32 %835 to i64
  %837 = getelementptr inbounds ptr, ptr %833, i64 %836
  %838 = load ptr, ptr %837, align 8, !tbaa !5
  %839 = load ptr, ptr %9, align 8, !tbaa !5
  %840 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %839, i32 0, i32 20
  %841 = load ptr, ptr %840, align 8, !tbaa !55
  %842 = load i32, ptr %20, align 4, !tbaa !9
  %843 = sub i32 %842, 1
  %844 = zext i32 %843 to i64
  %845 = getelementptr inbounds ptr, ptr %841, i64 %844
  %846 = load ptr, ptr %845, align 8, !tbaa !5
  call void @cmatrix_copy_cmatrix(ptr noundef %838, ptr noundef %846)
  %847 = load ptr, ptr %9, align 8, !tbaa !5
  %848 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %847, i32 0, i32 21
  %849 = load ptr, ptr %848, align 8, !tbaa !57
  %850 = load i32, ptr %20, align 4, !tbaa !9
  %851 = sub i32 %850, 1
  %852 = zext i32 %851 to i64
  %853 = getelementptr inbounds ptr, ptr %849, i64 %852
  %854 = load ptr, ptr %853, align 8, !tbaa !5
  %855 = load ptr, ptr %9, align 8, !tbaa !5
  %856 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %855, i32 0, i32 14
  %857 = load ptr, ptr %856, align 8, !tbaa !31
  %858 = load i32, ptr %20, align 4, !tbaa !9
  %859 = sub i32 %858, 1
  %860 = zext i32 %859 to i64
  %861 = getelementptr inbounds ptr, ptr %857, i64 %860
  %862 = load ptr, ptr %861, align 8, !tbaa !5
  %863 = load ptr, ptr %9, align 8, !tbaa !5
  %864 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %863, i32 0, i32 12
  %865 = load ptr, ptr %864, align 8, !tbaa !49
  %866 = load i32, ptr %20, align 4, !tbaa !9
  %867 = sub i32 %866, 1
  %868 = zext i32 %867 to i64
  %869 = getelementptr inbounds ptr, ptr %865, i64 %868
  %870 = load ptr, ptr %869, align 8, !tbaa !5
  call void @cmatrix_mul(ptr noundef %854, ptr noundef %862, ptr noundef %870)
  %871 = load ptr, ptr %9, align 8, !tbaa !5
  %872 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %871, i32 0, i32 22
  %873 = load ptr, ptr %872, align 8, !tbaa !58
  %874 = load i32, ptr %20, align 4, !tbaa !9
  %875 = sub i32 %874, 1
  %876 = zext i32 %875 to i64
  %877 = getelementptr inbounds ptr, ptr %873, i64 %876
  %878 = load ptr, ptr %877, align 8, !tbaa !5
  %879 = load ptr, ptr %9, align 8, !tbaa !5
  %880 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %879, i32 0, i32 21
  %881 = load ptr, ptr %880, align 8, !tbaa !57
  %882 = load i32, ptr %20, align 4, !tbaa !9
  %883 = sub i32 %882, 1
  %884 = zext i32 %883 to i64
  %885 = getelementptr inbounds ptr, ptr %881, i64 %884
  %886 = load ptr, ptr %885, align 8, !tbaa !5
  call void @cmatrix_copy_cmatrix(ptr noundef %878, ptr noundef %886)
  store i32 0, ptr %21, align 4, !tbaa !9
  br label %887

887:                                              ; preds = %911, %771
  %888 = load i32, ptr %21, align 4, !tbaa !9
  %889 = load i32, ptr %20, align 4, !tbaa !9
  %890 = icmp ult i32 %888, %889
  br i1 %890, label %891, label %914

891:                                              ; preds = %887
  %892 = load ptr, ptr %9, align 8, !tbaa !5
  %893 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %892, i32 0, i32 22
  %894 = load ptr, ptr %893, align 8, !tbaa !58
  %895 = load i32, ptr %20, align 4, !tbaa !9
  %896 = sub i32 %895, 1
  %897 = zext i32 %896 to i64
  %898 = getelementptr inbounds ptr, ptr %894, i64 %897
  %899 = load ptr, ptr %898, align 8, !tbaa !5
  %900 = getelementptr inbounds %struct.cmatrix_obj, ptr %899, i32 0, i32 0
  %901 = load ptr, ptr %900, align 8, !tbaa !26
  %902 = load i32, ptr %21, align 4, !tbaa !9
  %903 = load i32, ptr %20, align 4, !tbaa !9
  %904 = mul i32 %902, %903
  %905 = load i32, ptr %21, align 4, !tbaa !9
  %906 = add i32 %904, %905
  %907 = zext i32 %906 to i64
  %908 = getelementptr inbounds float, ptr %901, i64 %907
  %909 = load float, ptr %908, align 4, !tbaa !24
  %910 = fsub float %909, 1.000000e+00
  store float %910, ptr %908, align 4, !tbaa !24
  br label %911

911:                                              ; preds = %891
  %912 = load i32, ptr %21, align 4, !tbaa !9
  %913 = add i32 %912, 1
  store i32 %913, ptr %21, align 4, !tbaa !9
  br label %887, !llvm.loop !59

914:                                              ; preds = %887
  %915 = load ptr, ptr %9, align 8, !tbaa !5
  %916 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %915, i32 0, i32 23
  %917 = load ptr, ptr %916, align 8, !tbaa !60
  %918 = load i32, ptr %20, align 4, !tbaa !9
  %919 = sub i32 %918, 1
  %920 = zext i32 %919 to i64
  %921 = getelementptr inbounds ptr, ptr %917, i64 %920
  %922 = load ptr, ptr %921, align 8, !tbaa !5
  %923 = load ptr, ptr %9, align 8, !tbaa !5
  %924 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %923, i32 0, i32 22
  %925 = load ptr, ptr %924, align 8, !tbaa !58
  %926 = load i32, ptr %20, align 4, !tbaa !9
  %927 = sub i32 %926, 1
  %928 = zext i32 %927 to i64
  %929 = getelementptr inbounds ptr, ptr %925, i64 %928
  %930 = load ptr, ptr %929, align 8, !tbaa !5
  call void @cmatrix_scale(ptr noundef %922, ptr noundef %930, float noundef 2.000000e+00)
  %931 = load ptr, ptr %9, align 8, !tbaa !5
  %932 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %931, i32 0, i32 24
  %933 = load ptr, ptr %932, align 8, !tbaa !61
  %934 = load i32, ptr %20, align 4, !tbaa !9
  %935 = sub i32 %934, 1
  %936 = zext i32 %935 to i64
  %937 = getelementptr inbounds ptr, ptr %933, i64 %936
  %938 = load ptr, ptr %937, align 8, !tbaa !5
  %939 = load ptr, ptr %9, align 8, !tbaa !5
  %940 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %939, i32 0, i32 23
  %941 = load ptr, ptr %940, align 8, !tbaa !60
  %942 = load i32, ptr %20, align 4, !tbaa !9
  %943 = sub i32 %942, 1
  %944 = zext i32 %943 to i64
  %945 = getelementptr inbounds ptr, ptr %941, i64 %944
  %946 = load ptr, ptr %945, align 8, !tbaa !5
  %947 = load ptr, ptr %9, align 8, !tbaa !5
  %948 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %947, i32 0, i32 13
  %949 = load ptr, ptr %948, align 8, !tbaa !50
  %950 = load i32, ptr %20, align 4, !tbaa !9
  %951 = sub i32 %950, 1
  %952 = zext i32 %951 to i64
  %953 = getelementptr inbounds ptr, ptr %949, i64 %952
  %954 = load ptr, ptr %953, align 8, !tbaa !5
  call void @cmatrix_mul(ptr noundef %938, ptr noundef %946, ptr noundef %954)
  %955 = load ptr, ptr %9, align 8, !tbaa !5
  %956 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %955, i32 0, i32 17
  %957 = load ptr, ptr %956, align 8, !tbaa !62
  %958 = load i32, ptr %20, align 4, !tbaa !9
  %959 = sub i32 %958, 1
  %960 = zext i32 %959 to i64
  %961 = getelementptr inbounds ptr, ptr %957, i64 %960
  %962 = load ptr, ptr %961, align 8, !tbaa !5
  %963 = load ptr, ptr %9, align 8, !tbaa !5
  %964 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %963, i32 0, i32 24
  %965 = load ptr, ptr %964, align 8, !tbaa !61
  %966 = load i32, ptr %20, align 4, !tbaa !9
  %967 = sub i32 %966, 1
  %968 = zext i32 %967 to i64
  %969 = getelementptr inbounds ptr, ptr %965, i64 %968
  %970 = load ptr, ptr %969, align 8, !tbaa !5
  call void @cmatrix_copy_cmatrix(ptr noundef %962, ptr noundef %970)
  store float 0.000000e+00, ptr %33, align 4, !tbaa !24
  store i32 0, ptr %19, align 4, !tbaa !9
  br label %971

971:                                              ; preds = %1004, %914
  %972 = load i32, ptr %19, align 4, !tbaa !9
  %973 = load ptr, ptr %9, align 8, !tbaa !5
  %974 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %973, i32 0, i32 1
  %975 = load i32, ptr %974, align 4, !tbaa !21
  %976 = icmp ult i32 %972, %975
  br i1 %976, label %977, label %1007

977:                                              ; preds = %971
  %978 = load ptr, ptr %9, align 8, !tbaa !5
  %979 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %978, i32 0, i32 6
  %980 = load ptr, ptr %979, align 8, !tbaa !25
  %981 = getelementptr inbounds %struct.cmatrix_obj, ptr %980, i32 0, i32 0
  %982 = load ptr, ptr %981, align 8, !tbaa !26
  %983 = load i32, ptr %19, align 4, !tbaa !9
  %984 = zext i32 %983 to i64
  %985 = getelementptr inbounds float, ptr %982, i64 %984
  %986 = load float, ptr %985, align 4, !tbaa !24
  store float %986, ptr %31, align 4, !tbaa !24
  %987 = load ptr, ptr %9, align 8, !tbaa !5
  %988 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %987, i32 0, i32 6
  %989 = load ptr, ptr %988, align 8, !tbaa !25
  %990 = getelementptr inbounds %struct.cmatrix_obj, ptr %989, i32 0, i32 1
  %991 = load ptr, ptr %990, align 8, !tbaa !28
  %992 = load i32, ptr %19, align 4, !tbaa !9
  %993 = zext i32 %992 to i64
  %994 = getelementptr inbounds float, ptr %991, i64 %993
  %995 = load float, ptr %994, align 4, !tbaa !24
  store float %995, ptr %32, align 4, !tbaa !24
  %996 = load float, ptr %31, align 4, !tbaa !24
  %997 = load float, ptr %31, align 4, !tbaa !24
  %998 = load float, ptr %32, align 4, !tbaa !24
  %999 = load float, ptr %32, align 4, !tbaa !24
  %1000 = fmul float %998, %999
  %1001 = call float @llvm.fmuladd.f32(float %996, float %997, float %1000)
  %1002 = load float, ptr %33, align 4, !tbaa !24
  %1003 = fadd float %1002, %1001
  store float %1003, ptr %33, align 4, !tbaa !24
  br label %1004

1004:                                             ; preds = %977
  %1005 = load i32, ptr %19, align 4, !tbaa !9
  %1006 = add i32 %1005, 1
  store i32 %1006, ptr %19, align 4, !tbaa !9
  br label %971, !llvm.loop !63

1007:                                             ; preds = %971
  %1008 = load float, ptr %33, align 4, !tbaa !24
  %1009 = load float, ptr %33, align 4, !tbaa !24
  %1010 = fmul float %1008, %1009
  store float %1010, ptr %34, align 4, !tbaa !24
  %1011 = load float, ptr %34, align 4, !tbaa !24
  %1012 = load ptr, ptr %9, align 8, !tbaa !5
  %1013 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1012, i32 0, i32 3
  %1014 = load float, ptr %1013, align 4, !tbaa !35
  %1015 = fadd float %1011, %1014
  %1016 = fdiv float 1.000000e+00, %1015
  store float %1016, ptr %35, align 4, !tbaa !24
  %1017 = load ptr, ptr %9, align 8, !tbaa !5
  %1018 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1017, i32 0, i32 25
  %1019 = load ptr, ptr %1018, align 8, !tbaa !64
  %1020 = load i32, ptr %20, align 4, !tbaa !9
  %1021 = sub i32 %1020, 1
  %1022 = zext i32 %1021 to i64
  %1023 = getelementptr inbounds ptr, ptr %1019, i64 %1022
  %1024 = load ptr, ptr %1023, align 8, !tbaa !5
  %1025 = load ptr, ptr %9, align 8, !tbaa !5
  %1026 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1025, i32 0, i32 16
  %1027 = load ptr, ptr %1026, align 8, !tbaa !56
  %1028 = load i32, ptr %20, align 4, !tbaa !9
  %1029 = sub i32 %1028, 1
  %1030 = zext i32 %1029 to i64
  %1031 = getelementptr inbounds ptr, ptr %1027, i64 %1030
  %1032 = load ptr, ptr %1031, align 8, !tbaa !5
  %1033 = load float, ptr %35, align 4, !tbaa !24
  call void @cmatrix_scale(ptr noundef %1024, ptr noundef %1032, float noundef %1033)
  %1034 = load ptr, ptr %9, align 8, !tbaa !5
  %1035 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1034, i32 0, i32 26
  %1036 = load ptr, ptr %1035, align 8, !tbaa !65
  %1037 = load i32, ptr %20, align 4, !tbaa !9
  %1038 = sub i32 %1037, 1
  %1039 = zext i32 %1038 to i64
  %1040 = getelementptr inbounds ptr, ptr %1036, i64 %1039
  %1041 = load ptr, ptr %1040, align 8, !tbaa !5
  %1042 = load ptr, ptr %9, align 8, !tbaa !5
  %1043 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1042, i32 0, i32 25
  %1044 = load ptr, ptr %1043, align 8, !tbaa !64
  %1045 = load i32, ptr %20, align 4, !tbaa !9
  %1046 = sub i32 %1045, 1
  %1047 = zext i32 %1046 to i64
  %1048 = getelementptr inbounds ptr, ptr %1044, i64 %1047
  %1049 = load ptr, ptr %1048, align 8, !tbaa !5
  %1050 = load ptr, ptr %9, align 8, !tbaa !5
  %1051 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1050, i32 0, i32 17
  %1052 = load ptr, ptr %1051, align 8, !tbaa !62
  %1053 = load i32, ptr %20, align 4, !tbaa !9
  %1054 = sub i32 %1053, 1
  %1055 = zext i32 %1054 to i64
  %1056 = getelementptr inbounds ptr, ptr %1052, i64 %1055
  %1057 = load ptr, ptr %1056, align 8, !tbaa !5
  call void @cmatrix_add(ptr noundef %1041, ptr noundef %1049, ptr noundef %1057)
  %1058 = load ptr, ptr %9, align 8, !tbaa !5
  %1059 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1058, i32 0, i32 27
  %1060 = load ptr, ptr %1059, align 8, !tbaa !66
  %1061 = load i32, ptr %20, align 4, !tbaa !9
  %1062 = sub i32 %1061, 1
  %1063 = zext i32 %1062 to i64
  %1064 = getelementptr inbounds ptr, ptr %1060, i64 %1063
  %1065 = load ptr, ptr %1064, align 8, !tbaa !5
  %1066 = load ptr, ptr %9, align 8, !tbaa !5
  %1067 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1066, i32 0, i32 26
  %1068 = load ptr, ptr %1067, align 8, !tbaa !65
  %1069 = load i32, ptr %20, align 4, !tbaa !9
  %1070 = sub i32 %1069, 1
  %1071 = zext i32 %1070 to i64
  %1072 = getelementptr inbounds ptr, ptr %1068, i64 %1071
  %1073 = load ptr, ptr %1072, align 8, !tbaa !5
  %1074 = load ptr, ptr %9, align 8, !tbaa !5
  %1075 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1074, i32 0, i32 4
  %1076 = load float, ptr %1075, align 8, !tbaa !67
  %1077 = fmul float 1.000000e+00, %1076
  call void @cmatrix_scale(ptr noundef %1065, ptr noundef %1073, float noundef %1077)
  %1078 = load ptr, ptr %9, align 8, !tbaa !5
  %1079 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1078, i32 0, i32 28
  %1080 = load ptr, ptr %1079, align 8, !tbaa !68
  %1081 = load i32, ptr %20, align 4, !tbaa !9
  %1082 = sub i32 %1081, 1
  %1083 = zext i32 %1082 to i64
  %1084 = getelementptr inbounds ptr, ptr %1080, i64 %1083
  %1085 = load ptr, ptr %1084, align 8, !tbaa !5
  %1086 = load ptr, ptr %9, align 8, !tbaa !5
  %1087 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1086, i32 0, i32 14
  %1088 = load ptr, ptr %1087, align 8, !tbaa !31
  %1089 = load i32, ptr %20, align 4, !tbaa !9
  %1090 = sub i32 %1089, 1
  %1091 = zext i32 %1090 to i64
  %1092 = getelementptr inbounds ptr, ptr %1088, i64 %1091
  %1093 = load ptr, ptr %1092, align 8, !tbaa !5
  %1094 = load ptr, ptr %9, align 8, !tbaa !5
  %1095 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1094, i32 0, i32 5
  %1096 = load float, ptr %1095, align 4, !tbaa !69
  %1097 = load ptr, ptr %9, align 8, !tbaa !5
  %1098 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1097, i32 0, i32 4
  %1099 = load float, ptr %1098, align 8, !tbaa !67
  %1100 = fneg float %1096
  %1101 = call float @llvm.fmuladd.f32(float %1100, float %1099, float 1.000000e+00)
  call void @cmatrix_scale(ptr noundef %1085, ptr noundef %1093, float noundef %1101)
  %1102 = load ptr, ptr %9, align 8, !tbaa !5
  %1103 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1102, i32 0, i32 29
  %1104 = load ptr, ptr %1103, align 8, !tbaa !70
  %1105 = load i32, ptr %20, align 4, !tbaa !9
  %1106 = sub i32 %1105, 1
  %1107 = zext i32 %1106 to i64
  %1108 = getelementptr inbounds ptr, ptr %1104, i64 %1107
  %1109 = load ptr, ptr %1108, align 8, !tbaa !5
  %1110 = load ptr, ptr %9, align 8, !tbaa !5
  %1111 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1110, i32 0, i32 28
  %1112 = load ptr, ptr %1111, align 8, !tbaa !68
  %1113 = load i32, ptr %20, align 4, !tbaa !9
  %1114 = sub i32 %1113, 1
  %1115 = zext i32 %1114 to i64
  %1116 = getelementptr inbounds ptr, ptr %1112, i64 %1115
  %1117 = load ptr, ptr %1116, align 8, !tbaa !5
  %1118 = load ptr, ptr %9, align 8, !tbaa !5
  %1119 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1118, i32 0, i32 27
  %1120 = load ptr, ptr %1119, align 8, !tbaa !66
  %1121 = load i32, ptr %20, align 4, !tbaa !9
  %1122 = sub i32 %1121, 1
  %1123 = zext i32 %1122 to i64
  %1124 = getelementptr inbounds ptr, ptr %1120, i64 %1123
  %1125 = load ptr, ptr %1124, align 8, !tbaa !5
  call void @cmatrix_sub(ptr noundef %1109, ptr noundef %1117, ptr noundef %1125)
  %1126 = load ptr, ptr %9, align 8, !tbaa !5
  %1127 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1126, i32 0, i32 15
  %1128 = load ptr, ptr %1127, align 8, !tbaa !71
  %1129 = load i32, ptr %20, align 4, !tbaa !9
  %1130 = sub i32 %1129, 1
  %1131 = zext i32 %1130 to i64
  %1132 = getelementptr inbounds ptr, ptr %1128, i64 %1131
  %1133 = load ptr, ptr %1132, align 8, !tbaa !5
  %1134 = load ptr, ptr %9, align 8, !tbaa !5
  %1135 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1134, i32 0, i32 29
  %1136 = load ptr, ptr %1135, align 8, !tbaa !70
  %1137 = load i32, ptr %20, align 4, !tbaa !9
  %1138 = sub i32 %1137, 1
  %1139 = zext i32 %1138 to i64
  %1140 = getelementptr inbounds ptr, ptr %1136, i64 %1139
  %1141 = load ptr, ptr %1140, align 8, !tbaa !5
  call void @cmatrix_copy_cmatrix(ptr noundef %1133, ptr noundef %1141)
  store i32 0, ptr %21, align 4, !tbaa !9
  store i32 0, ptr %17, align 4, !tbaa !9
  br label %1142

1142:                                             ; preds = %1240, %1007
  %1143 = load i32, ptr %17, align 4, !tbaa !9
  %1144 = load ptr, ptr %9, align 8, !tbaa !5
  %1145 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1144, i32 0, i32 0
  %1146 = load i32, ptr %1145, align 8, !tbaa !11
  %1147 = icmp ult i32 %1143, %1146
  br i1 %1147, label %1148, label %1243

1148:                                             ; preds = %1142
  %1149 = load ptr, ptr %11, align 8, !tbaa !5
  %1150 = getelementptr inbounds %struct.tracks_obj, ptr %1149, i32 0, i32 1
  %1151 = load ptr, ptr %1150, align 8, !tbaa !14
  %1152 = load i32, ptr %17, align 4, !tbaa !9
  %1153 = zext i32 %1152 to i64
  %1154 = getelementptr inbounds i64, ptr %1151, i64 %1153
  %1155 = load i64, ptr %1154, align 8, !tbaa !16
  %1156 = icmp ne i64 %1155, 0
  br i1 %1156, label %1157, label %1239

1157:                                             ; preds = %1148
  store i32 0, ptr %19, align 4, !tbaa !9
  br label %1158

1158:                                             ; preds = %1233, %1157
  %1159 = load i32, ptr %19, align 4, !tbaa !9
  %1160 = load ptr, ptr %9, align 8, !tbaa !5
  %1161 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1160, i32 0, i32 1
  %1162 = load i32, ptr %1161, align 4, !tbaa !21
  %1163 = icmp ult i32 %1159, %1162
  br i1 %1163, label %1164, label %1236

1164:                                             ; preds = %1158
  %1165 = load i32, ptr %18, align 4, !tbaa !9
  %1166 = load ptr, ptr %9, align 8, !tbaa !5
  %1167 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1166, i32 0, i32 1
  %1168 = load i32, ptr %1167, align 4, !tbaa !21
  %1169 = mul i32 %1165, %1168
  %1170 = load i32, ptr %19, align 4, !tbaa !9
  %1171 = add i32 %1169, %1170
  store i32 %1171, ptr %23, align 4, !tbaa !9
  %1172 = load i32, ptr %21, align 4, !tbaa !9
  %1173 = load ptr, ptr %9, align 8, !tbaa !5
  %1174 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1173, i32 0, i32 1
  %1175 = load i32, ptr %1174, align 4, !tbaa !21
  %1176 = mul i32 %1172, %1175
  %1177 = load i32, ptr %19, align 4, !tbaa !9
  %1178 = add i32 %1176, %1177
  store i32 %1178, ptr %24, align 4, !tbaa !9
  %1179 = load ptr, ptr %9, align 8, !tbaa !5
  %1180 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1179, i32 0, i32 15
  %1181 = load ptr, ptr %1180, align 8, !tbaa !71
  %1182 = load i32, ptr %20, align 4, !tbaa !9
  %1183 = sub i32 %1182, 1
  %1184 = zext i32 %1183 to i64
  %1185 = getelementptr inbounds ptr, ptr %1181, i64 %1184
  %1186 = load ptr, ptr %1185, align 8, !tbaa !5
  %1187 = getelementptr inbounds %struct.cmatrix_obj, ptr %1186, i32 0, i32 0
  %1188 = load ptr, ptr %1187, align 8, !tbaa !26
  %1189 = load i32, ptr %24, align 4, !tbaa !9
  %1190 = zext i32 %1189 to i64
  %1191 = getelementptr inbounds float, ptr %1188, i64 %1190
  %1192 = load float, ptr %1191, align 4, !tbaa !24
  store float %1192, ptr %28, align 4, !tbaa !24
  %1193 = load ptr, ptr %9, align 8, !tbaa !5
  %1194 = getelementptr inbounds %struct.steer2demixing_gss_obj, ptr %1193, i32 0, i32 15
  %1195 = load ptr, ptr %1194, align 8, !tbaa !71
  %1196 = load i32, ptr %20, align 4, !tbaa !9
  %1197 = sub i32 %1196, 1
  %1198 = zext i32 %1197 to i64
  %1199 = getelementptr inbounds ptr, ptr %1195, i64 %1198
  %1200 = load ptr, ptr %1199, align 8, !tbaa !5
  %1201 = getelementptr inbounds %struct.cmatrix_obj, ptr %1200, i32 0, i32 1
  %1202 = load ptr, ptr %1201, align 8, !tbaa !28
  %1203 = load i32, ptr %24, align 4, !tbaa !9
  %1204 = zext i32 %1203 to i64
  %1205 = getelementptr inbounds float, ptr %1202, i64 %1204
  %1206 = load float, ptr %1205, align 4, !tbaa !24
  store float %1206, ptr %29, align 4, !tbaa !24
  %1207 = load float, ptr %28, align 4, !tbaa !24
  %1208 = load ptr, ptr %16, align 8, !tbaa !5
  %1209 = getelementptr inbounds %struct.demixings_obj, ptr %1208, i32 0, i32 3
  %1210 = load ptr, ptr %1209, align 8, !tbaa !32
  %1211 = load i32, ptr %17, align 4, !tbaa !9
  %1212 = zext i32 %1211 to i64
  %1213 = getelementptr inbounds ptr, ptr %1210, i64 %1212
  %1214 = load ptr, ptr %1213, align 8, !tbaa !5
  %1215 = load i32, ptr %23, align 4, !tbaa !9
  %1216 = mul i32 %1215, 2
  %1217 = add i32 %1216, 0
  %1218 = zext i32 %1217 to i64
  %1219 = getelementptr inbounds float, ptr %1214, i64 %1218
  store float %1207, ptr %1219, align 4, !tbaa !24
  %1220 = load float, ptr %29, align 4, !tbaa !24
  %1221 = load ptr, ptr %16, align 8, !tbaa !5
  %1222 = getelementptr inbounds %struct.demixings_obj, ptr %1221, i32 0, i32 3
  %1223 = load ptr, ptr %1222, align 8, !tbaa !32
  %1224 = load i32, ptr %17, align 4, !tbaa !9
  %1225 = zext i32 %1224 to i64
  %1226 = getelementptr inbounds ptr, ptr %1223, i64 %1225
  %1227 = load ptr, ptr %1226, align 8, !tbaa !5
  %1228 = load i32, ptr %23, align 4, !tbaa !9
  %1229 = mul i32 %1228, 2
  %1230 = add i32 %1229, 1
  %1231 = zext i32 %1230 to i64
  %1232 = getelementptr inbounds float, ptr %1227, i64 %1231
  store float %1220, ptr %1232, align 4, !tbaa !24
  br label %1233

1233:                                             ; preds = %1164
  %1234 = load i32, ptr %19, align 4, !tbaa !9
  %1235 = add i32 %1234, 1
  store i32 %1235, ptr %19, align 4, !tbaa !9
  br label %1158, !llvm.loop !72

1236:                                             ; preds = %1158
  %1237 = load i32, ptr %21, align 4, !tbaa !9
  %1238 = add i32 %1237, 1
  store i32 %1238, ptr %21, align 4, !tbaa !9
  br label %1239

1239:                                             ; preds = %1236, %1148
  br label %1240

1240:                                             ; preds = %1239
  %1241 = load i32, ptr %17, align 4, !tbaa !9
  %1242 = add i32 %1241, 1
  store i32 %1242, ptr %17, align 4, !tbaa !9
  br label %1142, !llvm.loop !73

1243:                                             ; preds = %1142
  br label %1244

1244:                                             ; preds = %1243
  %1245 = load i32, ptr %18, align 4, !tbaa !9
  %1246 = add i32 %1245, 1
  store i32 %1246, ptr %18, align 4, !tbaa !9
  br label %62, !llvm.loop !74

1247:                                             ; preds = %62
  br label %1248

1248:                                             ; preds = %1247, %58
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #4
  ret void
}

declare void @cmatrix_zero(ptr noundef) #3

declare void @cmatrix_mul(ptr noundef, ptr noundef, ptr noundef) #3

declare void @cmatrix_hermitian(ptr noundef, ptr noundef) #3

declare void @cmatrix_copy_cmatrix(ptr noundef, ptr noundef) #3

declare void @cmatrix_scale(ptr noundef, ptr noundef, float noundef) #3

declare void @cmatrix_add(ptr noundef, ptr noundef, ptr noundef) #3

declare void @cmatrix_sub(ptr noundef, ptr noundef, ptr noundef) #3

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
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 = { "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 #4 = { 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 = !{!"int", !7, i64 0}
!11 = !{!12, !10, i64 0}
!12 = !{!"steer2demixing_gss_obj", !10, i64 0, !10, i64 4, !10, i64 8, !13, i64 12, !13, i64 16, !13, i64 20, !6, i64 24, !6, i64 32, !6, i64 40, !6, i64 48, !6, i64 56, !6, i64 64, !6, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !6, i64 104, !6, i64 112, !6, i64 120, !6, i64 128, !6, i64 136, !6, i64 144, !6, i64 152, !6, i64 160, !6, i64 168, !6, i64 176, !6, i64 184, !6, i64 192, !6, i64 200, !6, i64 208}
!13 = !{!"float", !7, i64 0}
!14 = !{!15, !6, i64 8}
!15 = !{!"tracks_obj", !10, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32}
!16 = !{!17, !17, i64 0}
!17 = !{!"long long", !7, i64 0}
!18 = distinct !{!18, !19}
!19 = !{!"llvm.loop.mustprogress"}
!20 = !{!12, !10, i64 8}
!21 = !{!12, !10, i64 4}
!22 = !{!23, !6, i64 8}
!23 = !{!"freqs_obj", !10, i64 0, !10, i64 4, !6, i64 8}
!24 = !{!13, !13, i64 0}
!25 = !{!12, !6, i64 24}
!26 = !{!27, !6, i64 0}
!27 = !{!"cmatrix_obj", !6, i64 0, !6, i64 8, !10, i64 16, !10, i64 20}
!28 = !{!27, !6, i64 8}
!29 = !{!12, !6, i64 32}
!30 = distinct !{!30, !19}
!31 = !{!12, !6, i64 88}
!32 = !{!33, !6, i64 16}
!33 = !{!"demixings_obj", !10, i64 0, !10, i64 4, !10, i64 8, !6, i64 16}
!34 = distinct !{!34, !19}
!35 = !{!12, !13, i64 12}
!36 = !{!37, !6, i64 8}
!37 = !{!"masks_obj", !10, i64 0, !10, i64 4, !6, i64 8}
!38 = !{!7, !7, i64 0}
!39 = !{!40, !6, i64 16}
!40 = !{!"steers_obj", !10, i64 0, !10, i64 4, !10, i64 8, !6, i64 16}
!41 = distinct !{!41, !19}
!42 = distinct !{!42, !19}
!43 = distinct !{!43, !19}
!44 = !{!12, !6, i64 40}
!45 = !{!12, !6, i64 48}
!46 = !{!12, !6, i64 56}
!47 = !{!12, !6, i64 64}
!48 = distinct !{!48, !19}
!49 = !{!12, !6, i64 72}
!50 = !{!12, !6, i64 80}
!51 = distinct !{!51, !19}
!52 = distinct !{!52, !19}
!53 = !{!12, !6, i64 120}
!54 = !{!12, !6, i64 128}
!55 = !{!12, !6, i64 136}
!56 = !{!12, !6, i64 104}
!57 = !{!12, !6, i64 144}
!58 = !{!12, !6, i64 152}
!59 = distinct !{!59, !19}
!60 = !{!12, !6, i64 160}
!61 = !{!12, !6, i64 168}
!62 = !{!12, !6, i64 112}
!63 = distinct !{!63, !19}
!64 = !{!12, !6, i64 176}
!65 = !{!12, !6, i64 184}
!66 = !{!12, !6, i64 192}
!67 = !{!12, !13, i64 16}
!68 = !{!12, !6, i64 200}
!69 = !{!12, !13, i64 20}
!70 = !{!12, !6, i64 208}
!71 = !{!12, !6, i64 96}
!72 = distinct !{!72, !19}
!73 = distinct !{!73, !19}
!74 = distinct !{!74, !19}


; 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"

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #0

; Function Attrs: nounwind uwtable
define dso_local void @steer2demixing_gss_process(ptr noundef readonly %0, ptr nocapture noundef readonly %1, ptr nocapture noundef readonly %2, ptr nocapture noundef readonly %3, ptr nocapture noundef readonly %4, ptr nocapture noundef readonly %5, ptr nocapture noundef readonly %6, ptr nocapture noundef readonly %7) local_unnamed_addr #1 {
  %9 = load i32, ptr %0, align 8, !tbaa !5
  %.not424 = icmp eq i32 %9, 0
  br i1 %.not424, label %.loopexit373, label %.lr.ph

.lr.ph:                                           ; preds = %8
  %10 = getelementptr inbounds i8, ptr %2, i64 8
  %11 = load ptr, ptr %10, align 8, !tbaa !12
  %wide.trip.count = zext i32 %9 to i64
  %min.iters.check = icmp ult i32 %9, 4
  br i1 %min.iters.check, label %scalar.ph.preheader, label %vector.ph

vector.ph:                                        ; preds = %.lr.ph
  %n.vec = and i64 %wide.trip.count, 4294967292
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.phi = phi <2 x i32> [ zeroinitializer, %vector.ph ], [ %18, %vector.body ]
  %vec.phi506 = phi <2 x i32> [ zeroinitializer, %vector.ph ], [ %19, %vector.body ]
  %12 = getelementptr inbounds i64, ptr %11, i64 %index
  %13 = getelementptr inbounds i8, ptr %12, i64 16
  %wide.load = load <2 x i64>, ptr %12, align 8, !tbaa !14
  %wide.load507 = load <2 x i64>, ptr %13, align 8, !tbaa !14
  %14 = icmp ne <2 x i64> %wide.load, zeroinitializer
  %15 = icmp ne <2 x i64> %wide.load507, zeroinitializer
  %16 = zext <2 x i1> %14 to <2 x i32>
  %17 = zext <2 x i1> %15 to <2 x i32>
  %18 = add <2 x i32> %vec.phi, %16
  %19 = add <2 x i32> %vec.phi506, %17
  %index.next = add nuw i64 %index, 4
  %20 = icmp eq i64 %index.next, %n.vec
  br i1 %20, label %middle.block, label %vector.body, !llvm.loop !16

middle.block:                                     ; preds = %vector.body
  %bin.rdx = add <2 x i32> %19, %18
  %21 = tail call i32 @llvm.vector.reduce.add.v2i32(<2 x i32> %bin.rdx)
  %cmp.n = icmp eq i64 %n.vec, %wide.trip.count
  br i1 %cmp.n, label %._crit_edge, label %scalar.ph.preheader

scalar.ph.preheader:                              ; preds = %middle.block, %.lr.ph
  %indvars.iv.ph = phi i64 [ 0, %.lr.ph ], [ %n.vec, %middle.block ]
  %.0343375.ph = phi i32 [ 0, %.lr.ph ], [ %21, %middle.block ]
  br label %scalar.ph

scalar.ph:                                        ; preds = %scalar.ph.preheader, %scalar.ph
  %indvars.iv = phi i64 [ %indvars.iv.next, %scalar.ph ], [ %indvars.iv.ph, %scalar.ph.preheader ]
  %.0343375 = phi i32 [ %spec.select, %scalar.ph ], [ %.0343375.ph, %scalar.ph.preheader ]
  %22 = getelementptr inbounds i64, ptr %11, i64 %indvars.iv
  %23 = load i64, ptr %22, align 8, !tbaa !14
  %.not366 = icmp ne i64 %23, 0
  %24 = zext i1 %.not366 to i32
  %spec.select = add i32 %.0343375, %24
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge, label %scalar.ph, !llvm.loop !20

._crit_edge:                                      ; preds = %scalar.ph, %middle.block
  %spec.select.lcssa = phi i32 [ %21, %middle.block ], [ %spec.select, %scalar.ph ]
  %.not = icmp eq i32 %spec.select.lcssa, 0
  br i1 %.not, label %.loopexit373, label %.preheader372

.preheader372:                                    ; preds = %._crit_edge
  %25 = getelementptr inbounds i8, ptr %0, i64 8
  %26 = load i32, ptr %25, align 8, !tbaa !21
  %.not425 = icmp eq i32 %26, 0
  br i1 %.not425, label %.loopexit373, label %.preheader371.lr.ph

.preheader371.lr.ph:                              ; preds = %.preheader372
  %27 = getelementptr inbounds i8, ptr %0, i64 4
  %28 = getelementptr inbounds i8, ptr %5, i64 8
  %29 = getelementptr inbounds i8, ptr %0, i64 24
  %30 = getelementptr inbounds i8, ptr %0, i64 32
  %31 = getelementptr inbounds i8, ptr %0, i64 88
  %32 = add i32 %spec.select.lcssa, -1
  %33 = zext i32 %32 to i64
  %34 = getelementptr inbounds i8, ptr %2, i64 8
  %35 = getelementptr inbounds i8, ptr %1, i64 8
  %36 = getelementptr inbounds i8, ptr %0, i64 12
  %37 = getelementptr inbounds i8, ptr %4, i64 8
  %38 = getelementptr inbounds i8, ptr %3, i64 16
  %39 = getelementptr inbounds i8, ptr %6, i64 16
  %40 = getelementptr inbounds i8, ptr %0, i64 40
  %41 = getelementptr inbounds i8, ptr %0, i64 48
  %42 = getelementptr inbounds i8, ptr %0, i64 56
  %43 = getelementptr inbounds i8, ptr %0, i64 64
  %.2349364 = add i32 %spec.select.lcssa, 1
  %44 = getelementptr inbounds i8, ptr %0, i64 72
  %45 = getelementptr inbounds i8, ptr %0, i64 80
  %46 = getelementptr inbounds i8, ptr %0, i64 120
  %47 = getelementptr inbounds i8, ptr %0, i64 128
  %48 = getelementptr inbounds i8, ptr %0, i64 136
  %49 = getelementptr inbounds i8, ptr %0, i64 104
  %50 = getelementptr inbounds i8, ptr %0, i64 144
  %51 = getelementptr inbounds i8, ptr %0, i64 152
  %52 = getelementptr inbounds i8, ptr %0, i64 160
  %53 = getelementptr inbounds i8, ptr %0, i64 168
  %54 = getelementptr inbounds i8, ptr %0, i64 112
  %55 = getelementptr inbounds i8, ptr %0, i64 176
  %56 = getelementptr inbounds i8, ptr %0, i64 184
  %57 = getelementptr inbounds i8, ptr %0, i64 192
  %58 = getelementptr inbounds i8, ptr %0, i64 16
  %59 = getelementptr inbounds i8, ptr %0, i64 200
  %60 = getelementptr inbounds i8, ptr %0, i64 20
  %61 = getelementptr inbounds i8, ptr %0, i64 208
  %62 = getelementptr inbounds i8, ptr %0, i64 96
  %63 = getelementptr inbounds i8, ptr %7, i64 16
  %wide.trip.count466 = zext i32 %spec.select.lcssa to i64
  %xtraiter588 = and i64 %wide.trip.count466, 3
  %64 = icmp ult i32 %spec.select.lcssa, 4
  %unroll_iter = and i64 %wide.trip.count466, 4294967292
  %lcmp.mod589.not = icmp eq i64 %xtraiter588, 0
  %xtraiter592 = and i64 %wide.trip.count466, 3
  %65 = icmp ult i32 %spec.select.lcssa, 4
  %unroll_iter596 = and i64 %wide.trip.count466, 4294967292
  %lcmp.mod594.not = icmp eq i64 %xtraiter592, 0
  br label %.preheader371

.preheader371:                                    ; preds = %.preheader371.lr.ph, %._crit_edge422
  %indvars.iv498 = phi i64 [ 0, %.preheader371.lr.ph ], [ %indvars.iv.next499, %._crit_edge422 ]
  %indvars.iv498.tr = trunc i64 %indvars.iv498 to i32
  %66 = shl i32 %indvars.iv498.tr, 1
  %indvars.iv498.tr581 = trunc i64 %indvars.iv498 to i32
  %67 = shl i32 %indvars.iv498.tr581, 1
  %indvars.iv498.tr582 = trunc i64 %indvars.iv498 to i32
  %68 = shl i32 %indvars.iv498.tr582, 1
  %indvars.iv498.tr583 = trunc i64 %indvars.iv498 to i32
  %69 = shl i32 %indvars.iv498.tr583, 1
  %70 = load i32, ptr %27, align 4, !tbaa !22
  %.not426 = icmp eq i32 %70, 0
  br i1 %.not426, label %._crit_edge379, label %.lr.ph378

.lr.ph378:                                        ; preds = %.preheader371
  %71 = load ptr, ptr %28, align 8, !tbaa !23
  %72 = trunc nuw i64 %indvars.iv498 to i32
  %73 = shl i32 %72, 1
  %74 = zext i32 %73 to i64
  %75 = load ptr, ptr %29, align 8, !tbaa !25
  %76 = load ptr, ptr %75, align 8, !tbaa !26
  %77 = or disjoint i32 %73, 1
  %78 = zext i32 %77 to i64
  %79 = getelementptr inbounds i8, ptr %75, i64 8
  %80 = load ptr, ptr %79, align 8, !tbaa !28
  %81 = load ptr, ptr %30, align 8, !tbaa !29
  %82 = load ptr, ptr %81, align 8, !tbaa !26
  %83 = getelementptr inbounds i8, ptr %81, i64 8
  %84 = load ptr, ptr %83, align 8, !tbaa !28
  %wide.trip.count441 = zext i32 %70 to i64
  br label %85

85:                                               ; preds = %.lr.ph378, %85
  %indvars.iv438 = phi i64 [ 0, %.lr.ph378 ], [ %indvars.iv.next439, %85 ]
  %86 = getelementptr inbounds ptr, ptr %71, i64 %indvars.iv438
  %87 = load ptr, ptr %86, align 8, !tbaa !30
  %88 = getelementptr inbounds float, ptr %87, i64 %74
  %89 = load float, ptr %88, align 4, !tbaa !31
  %90 = getelementptr inbounds float, ptr %76, i64 %indvars.iv438
  store float %89, ptr %90, align 4, !tbaa !31
  %91 = getelementptr inbounds float, ptr %87, i64 %78
  %92 = load float, ptr %91, align 4, !tbaa !31
  %93 = getelementptr inbounds float, ptr %80, i64 %indvars.iv438
  store float %92, ptr %93, align 4, !tbaa !31
  %94 = load float, ptr %88, align 4, !tbaa !31
  %95 = getelementptr inbounds float, ptr %82, i64 %indvars.iv438
  store float %94, ptr %95, align 4, !tbaa !31
  %96 = load float, ptr %91, align 4, !tbaa !31
  %97 = fneg float %96
  %98 = getelementptr inbounds float, ptr %84, i64 %indvars.iv438
  store float %97, ptr %98, align 4, !tbaa !31
  %indvars.iv.next439 = add nuw nsw i64 %indvars.iv438, 1
  %exitcond442.not = icmp eq i64 %indvars.iv.next439, %wide.trip.count441
  br i1 %exitcond442.not, label %._crit_edge379, label %85, !llvm.loop !32

._crit_edge379:                                   ; preds = %85, %.preheader371
  %99 = load ptr, ptr %31, align 8, !tbaa !33
  %100 = getelementptr inbounds ptr, ptr %99, i64 %33
  %101 = load ptr, ptr %100, align 8, !tbaa !30
  tail call void @cmatrix_zero(ptr noundef %101) #4
  %102 = load i32, ptr %0, align 8, !tbaa !5
  %.not427 = icmp eq i32 %102, 0
  br i1 %.not427, label %._crit_edge397, label %.lr.ph396

.lr.ph396:                                        ; preds = %._crit_edge379
  %103 = load ptr, ptr %34, align 8, !tbaa !12
  %wide.trip.count461 = zext i32 %102 to i64
  %104 = trunc nuw i64 %indvars.iv498 to i32
  %105 = trunc nuw i64 %indvars.iv498 to i32
  %106 = trunc nuw i64 %indvars.iv498 to i32
  br label %107

107:                                              ; preds = %.lr.ph396, %276
  %indvars.iv458 = phi i64 [ 0, %.lr.ph396 ], [ %indvars.iv.next459, %276 ]
  %.0347390 = phi i32 [ 0, %.lr.ph396 ], [ %.1348, %276 ]
  %108 = getelementptr inbounds i64, ptr %103, i64 %indvars.iv458
  %109 = load i64, ptr %108, align 8, !tbaa !14
  %.not365 = icmp eq i64 %109, 0
  br i1 %.not365, label %276, label %110

110:                                              ; preds = %107
  %111 = load ptr, ptr %35, align 8, !tbaa !12
  %112 = getelementptr inbounds i64, ptr %111, i64 %indvars.iv458
  %113 = load i64, ptr %112, align 8, !tbaa !14
  %114 = icmp eq i64 %109, %113
  %115 = load i32, ptr %27, align 4, !tbaa !22
  %.not430 = icmp eq i32 %115, 0
  br i1 %114, label %.preheader368, label %206

.preheader368:                                    ; preds = %110
  br i1 %.not430, label %.loopexit, label %.lr.ph389

.lr.ph389:                                        ; preds = %.preheader368
  %116 = mul i32 %115, %106
  %117 = mul i32 %115, %.0347390
  %118 = load ptr, ptr %39, align 8, !tbaa !34
  %119 = getelementptr inbounds ptr, ptr %118, i64 %indvars.iv458
  %120 = load ptr, ptr %119, align 8, !tbaa !30
  %121 = load ptr, ptr %31, align 8, !tbaa !33
  %122 = getelementptr inbounds ptr, ptr %121, i64 %33
  %123 = load ptr, ptr %122, align 8, !tbaa !30
  %124 = load ptr, ptr %123, align 8, !tbaa !26
  %125 = getelementptr inbounds i8, ptr %123, i64 8
  %126 = load ptr, ptr %125, align 8, !tbaa !28
  %wide.trip.count456 = zext i32 %115 to i64
  %min.iters.check571 = icmp ult i32 %115, 32
  br i1 %min.iters.check571, label %scalar.ph570.preheader, label %vector.scevcheck544

vector.scevcheck544:                              ; preds = %.lr.ph389
  %127 = add nsw i64 %wide.trip.count456, -1
  %128 = trunc i64 %127 to i32
  %129 = xor i32 %117, -1
  %130 = icmp ult i32 %129, %128
  %131 = mul i32 %67, %115
  %132 = trunc i64 %127 to i32
  %mul.result546 = shl i32 %132, 1
  %133 = xor i32 %131, -1
  %134 = icmp ugt i32 %mul.result546, %133
  %135 = icmp ugt i64 %127, 2147483647
  %136 = or i1 %134, %135
  %137 = trunc i64 %127 to i32
  %mul.result549 = shl i32 %137, 1
  %138 = xor i32 %131, -2
  %139 = icmp ult i32 %138, %mul.result549
  %140 = or i1 %130, %136
  %141 = or i1 %139, %140
  br i1 %141, label %scalar.ph570.preheader, label %vector.memcheck551

vector.memcheck551:                               ; preds = %vector.scevcheck544
  %142 = zext i32 %117 to i64
  %143 = shl nuw nsw i64 %142, 2
  %scevgep552 = getelementptr i8, ptr %124, i64 %143
  %144 = add nuw nsw i64 %wide.trip.count456, %142
  %145 = shl nuw nsw i64 %144, 2
  %scevgep553 = getelementptr i8, ptr %124, i64 %145
  %scevgep554 = getelementptr i8, ptr %126, i64 %143
  %scevgep555 = getelementptr i8, ptr %126, i64 %145
  %146 = mul i32 %66, %115
  %147 = zext i32 %146 to i64
  %148 = shl nuw nsw i64 %147, 2
  %scevgep556 = getelementptr i8, ptr %120, i64 %148
  %149 = shl nuw nsw i64 %wide.trip.count456, 3
  %150 = getelementptr i8, ptr %120, i64 %149
  %scevgep557 = getelementptr i8, ptr %150, i64 %148
  %bound0558 = icmp ult ptr %scevgep552, %scevgep555
  %bound1559 = icmp ult ptr %scevgep554, %scevgep553
  %found.conflict560 = and i1 %bound0558, %bound1559
  %bound0561 = icmp ult ptr %scevgep552, %scevgep557
  %bound1562 = icmp ult ptr %scevgep556, %scevgep553
  %found.conflict563 = and i1 %bound0561, %bound1562
  %conflict.rdx564 = or i1 %found.conflict560, %found.conflict563
  %bound0565 = icmp ult ptr %scevgep554, %scevgep557
  %bound1566 = icmp ult ptr %scevgep556, %scevgep555
  %found.conflict567 = and i1 %bound0565, %bound1566
  %conflict.rdx568 = or i1 %conflict.rdx564, %found.conflict567
  br i1 %conflict.rdx568, label %scalar.ph570.preheader, label %vector.ph572

vector.ph572:                                     ; preds = %vector.memcheck551
  %n.vec574 = and i64 %wide.trip.count456, 4294967292
  br label %vector.body576

vector.body576:                                   ; preds = %vector.body576, %vector.ph572
  %index577 = phi i64 [ 0, %vector.ph572 ], [ %index.next579, %vector.body576 ]
  %151 = trunc i64 %index577 to i32
  %152 = add i32 %116, %151
  %153 = add i32 %117, %151
  %154 = shl i32 %152, 1
  %155 = zext i32 %154 to i64
  %156 = getelementptr inbounds float, ptr %120, i64 %155
  %wide.vec = load <8 x float>, ptr %156, align 4, !tbaa !31
  %strided.vec = shufflevector <8 x float> %wide.vec, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec578 = shufflevector <8 x float> %wide.vec, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %157 = zext i32 %153 to i64
  %158 = getelementptr inbounds float, ptr %124, i64 %157
  store <4 x float> %strided.vec, ptr %158, align 4, !tbaa !31, !alias.scope !36, !noalias !39
  %159 = getelementptr inbounds float, ptr %126, i64 %157
  store <4 x float> %strided.vec578, ptr %159, align 4, !tbaa !31, !alias.scope !42, !noalias !43
  %index.next579 = add nuw i64 %index577, 4
  %160 = icmp eq i64 %index.next579, %n.vec574
  br i1 %160, label %middle.block569, label %vector.body576, !llvm.loop !44

middle.block569:                                  ; preds = %vector.body576
  %cmp.n580 = icmp eq i64 %n.vec574, %wide.trip.count456
  br i1 %cmp.n580, label %.loopexit, label %scalar.ph570.preheader

scalar.ph570.preheader:                           ; preds = %middle.block569, %vector.memcheck551, %vector.scevcheck544, %.lr.ph389
  %indvars.iv453.ph = phi i64 [ 0, %vector.memcheck551 ], [ 0, %vector.scevcheck544 ], [ 0, %.lr.ph389 ], [ %n.vec574, %middle.block569 ]
  %xtraiter = and i64 %wide.trip.count456, 1
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %scalar.ph570.prol.loopexit, label %scalar.ph570.prol

scalar.ph570.prol:                                ; preds = %scalar.ph570.preheader
  %161 = trunc nuw i64 %indvars.iv453.ph to i32
  %162 = add i32 %116, %161
  %163 = add i32 %117, %161
  %164 = shl i32 %162, 1
  %165 = zext i32 %164 to i64
  %166 = getelementptr inbounds float, ptr %120, i64 %165
  %167 = load float, ptr %166, align 4, !tbaa !31
  %168 = or disjoint i32 %164, 1
  %169 = zext i32 %168 to i64
  %170 = getelementptr inbounds float, ptr %120, i64 %169
  %171 = load float, ptr %170, align 4, !tbaa !31
  %172 = zext i32 %163 to i64
  %173 = getelementptr inbounds float, ptr %124, i64 %172
  store float %167, ptr %173, align 4, !tbaa !31
  %174 = getelementptr inbounds float, ptr %126, i64 %172
  store float %171, ptr %174, align 4, !tbaa !31
  %indvars.iv.next454.prol = or disjoint i64 %indvars.iv453.ph, 1
  br label %scalar.ph570.prol.loopexit

scalar.ph570.prol.loopexit:                       ; preds = %scalar.ph570.prol, %scalar.ph570.preheader
  %indvars.iv453.unr = phi i64 [ %indvars.iv453.ph, %scalar.ph570.preheader ], [ %indvars.iv.next454.prol, %scalar.ph570.prol ]
  %175 = add nsw i64 %wide.trip.count456, -1
  %176 = icmp eq i64 %indvars.iv453.ph, %175
  br i1 %176, label %.loopexit, label %scalar.ph570

scalar.ph570:                                     ; preds = %scalar.ph570.prol.loopexit, %scalar.ph570
  %indvars.iv453 = phi i64 [ %indvars.iv.next454.1, %scalar.ph570 ], [ %indvars.iv453.unr, %scalar.ph570.prol.loopexit ]
  %177 = trunc nuw i64 %indvars.iv453 to i32
  %178 = add i32 %116, %177
  %179 = add i32 %117, %177
  %180 = shl i32 %178, 1
  %181 = zext i32 %180 to i64
  %182 = getelementptr inbounds float, ptr %120, i64 %181
  %183 = load float, ptr %182, align 4, !tbaa !31
  %184 = or disjoint i32 %180, 1
  %185 = zext i32 %184 to i64
  %186 = getelementptr inbounds float, ptr %120, i64 %185
  %187 = load float, ptr %186, align 4, !tbaa !31
  %188 = zext i32 %179 to i64
  %189 = getelementptr inbounds float, ptr %124, i64 %188
  store float %183, ptr %189, align 4, !tbaa !31
  %190 = getelementptr inbounds float, ptr %126, i64 %188
  store float %187, ptr %190, align 4, !tbaa !31
  %191 = trunc i64 %indvars.iv453 to i32
  %192 = add i32 %191, 1
  %193 = add i32 %116, %192
  %194 = add i32 %117, %192
  %195 = shl i32 %193, 1
  %196 = zext i32 %195 to i64
  %197 = getelementptr inbounds float, ptr %120, i64 %196
  %198 = load float, ptr %197, align 4, !tbaa !31
  %199 = or disjoint i32 %195, 1
  %200 = zext i32 %199 to i64
  %201 = getelementptr inbounds float, ptr %120, i64 %200
  %202 = load float, ptr %201, align 4, !tbaa !31
  %203 = zext i32 %194 to i64
  %204 = getelementptr inbounds float, ptr %124, i64 %203
  store float %198, ptr %204, align 4, !tbaa !31
  %205 = getelementptr inbounds float, ptr %126, i64 %203
  store float %202, ptr %205, align 4, !tbaa !31
  %indvars.iv.next454.1 = add nuw nsw i64 %indvars.iv453, 2
  %exitcond457.not.1 = icmp eq i64 %indvars.iv.next454.1, %wide.trip.count456
  br i1 %exitcond457.not.1, label %.loopexit, label %scalar.ph570, !llvm.loop !45

206:                                              ; preds = %110
  br i1 %.not430, label %.loopexit, label %.lr.ph383

.lr.ph383:                                        ; preds = %206
  %207 = load float, ptr %36, align 4, !tbaa !46
  %208 = trunc nuw i64 %indvars.iv458 to i32
  %209 = mul i32 %115, %208
  %210 = load ptr, ptr %37, align 8, !tbaa !47
  %211 = mul i32 %115, %104
  %wide.trip.count446 = zext i32 %115 to i64
  br label %217

.preheader369:                                    ; preds = %240
  br i1 %.not430, label %.loopexit, label %.lr.ph387

.lr.ph387:                                        ; preds = %.preheader369
  %212 = trunc nuw i64 %indvars.iv458 to i32
  %213 = mul i32 %115, %212
  %214 = load ptr, ptr %37, align 8, !tbaa !47
  %215 = mul i32 %115, %.0347390
  %216 = mul i32 %115, %105
  %wide.trip.count451 = zext i32 %115 to i64
  br label %241

217:                                              ; preds = %.lr.ph383, %240
  %indvars.iv443 = phi i64 [ 0, %.lr.ph383 ], [ %indvars.iv.next444, %240 ]
  %.0345380 = phi float [ %207, %.lr.ph383 ], [ %.1346, %240 ]
  %218 = trunc nuw i64 %indvars.iv443 to i32
  %219 = add i32 %209, %218
  %220 = zext i32 %219 to i64
  %221 = getelementptr inbounds i8, ptr %210, i64 %220
  %222 = load i8, ptr %221, align 1, !tbaa !49
  %223 = icmp eq i8 %222, 1
  br i1 %223, label %224, label %240

224:                                              ; preds = %217
  %225 = add i32 %211, %218
  %226 = load ptr, ptr %38, align 8, !tbaa !50
  %227 = getelementptr inbounds ptr, ptr %226, i64 %indvars.iv458
  %228 = load ptr, ptr %227, align 8, !tbaa !30
  %229 = shl i32 %225, 1
  %230 = zext i32 %229 to i64
  %231 = getelementptr inbounds float, ptr %228, i64 %230
  %232 = load float, ptr %231, align 4, !tbaa !31
  %233 = or disjoint i32 %229, 1
  %234 = zext i32 %233 to i64
  %235 = getelementptr inbounds float, ptr %228, i64 %234
  %236 = load float, ptr %235, align 4, !tbaa !31
  %237 = fmul float %236, %236
  %238 = tail call float @llvm.fmuladd.f32(float %232, float %232, float %237)
  %239 = fadd float %.0345380, %238
  br label %240

240:                                              ; preds = %217, %224
  %.1346 = phi float [ %239, %224 ], [ %.0345380, %217 ]
  %indvars.iv.next444 = add nuw nsw i64 %indvars.iv443, 1
  %exitcond447.not = icmp eq i64 %indvars.iv.next444, %wide.trip.count446
  br i1 %exitcond447.not, label %.preheader369, label %217, !llvm.loop !52

241:                                              ; preds = %.lr.ph387, %274
  %indvars.iv448 = phi i64 [ 0, %.lr.ph387 ], [ %indvars.iv.next449, %274 ]
  %242 = trunc nuw i64 %indvars.iv448 to i32
  %243 = add i32 %213, %242
  %244 = zext i32 %243 to i64
  %245 = getelementptr inbounds i8, ptr %214, i64 %244
  %246 = load i8, ptr %245, align 1, !tbaa !49
  %247 = icmp eq i8 %246, 1
  br i1 %247, label %248, label %274

248:                                              ; preds = %241
  %249 = add i32 %215, %242
  %250 = add i32 %216, %242
  %251 = load ptr, ptr %38, align 8, !tbaa !50
  %252 = getelementptr inbounds ptr, ptr %251, i64 %indvars.iv458
  %253 = load ptr, ptr %252, align 8, !tbaa !30
  %254 = shl i32 %250, 1
  %255 = zext i32 %254 to i64
  %256 = getelementptr inbounds float, ptr %253, i64 %255
  %257 = load float, ptr %256, align 4, !tbaa !31
  %258 = or disjoint i32 %254, 1
  %259 = zext i32 %258 to i64
  %260 = getelementptr inbounds float, ptr %253, i64 %259
  %261 = load float, ptr %260, align 4, !tbaa !31
  %262 = fdiv float %257, %.1346
  %263 = fneg float %261
  %264 = fdiv float %263, %.1346
  %265 = load ptr, ptr %31, align 8, !tbaa !33
  %266 = getelementptr inbounds ptr, ptr %265, i64 %33
  %267 = load ptr, ptr %266, align 8, !tbaa !30
  %268 = load ptr, ptr %267, align 8, !tbaa !26
  %269 = zext i32 %249 to i64
  %270 = getelementptr inbounds float, ptr %268, i64 %269
  store float %262, ptr %270, align 4, !tbaa !31
  %271 = getelementptr inbounds i8, ptr %267, i64 8
  %272 = load ptr, ptr %271, align 8, !tbaa !28
  %273 = getelementptr inbounds float, ptr %272, i64 %269
  store float %264, ptr %273, align 4, !tbaa !31
  br label %274

274:                                              ; preds = %241, %248
  %indvars.iv.next449 = add nuw nsw i64 %indvars.iv448, 1
  %exitcond452.not = icmp eq i64 %indvars.iv.next449, %wide.trip.count451
  br i1 %exitcond452.not, label %.loopexit, label %241, !llvm.loop !53

.loopexit:                                        ; preds = %274, %scalar.ph570.prol.loopexit, %scalar.ph570, %middle.block569, %206, %.preheader369, %.preheader368
  %275 = add i32 %.0347390, 1
  br label %276

276:                                              ; preds = %107, %.loopexit
  %.1348 = phi i32 [ %275, %.loopexit ], [ %.0347390, %107 ]
  %indvars.iv.next459 = add nuw nsw i64 %indvars.iv458, 1
  %exitcond462.not = icmp eq i64 %indvars.iv.next459, %wide.trip.count461
  br i1 %exitcond462.not, label %._crit_edge397, label %107, !llvm.loop !54

._crit_edge397:                                   ; preds = %276, %._crit_edge379
  %277 = load ptr, ptr %40, align 8, !tbaa !55
  %278 = getelementptr inbounds ptr, ptr %277, i64 %33
  %279 = load ptr, ptr %278, align 8, !tbaa !30
  %280 = load ptr, ptr %31, align 8, !tbaa !33
  %281 = getelementptr inbounds ptr, ptr %280, i64 %33
  %282 = load ptr, ptr %281, align 8, !tbaa !30
  %283 = load ptr, ptr %29, align 8, !tbaa !25
  tail call void @cmatrix_mul(ptr noundef %279, ptr noundef %282, ptr noundef %283) #4
  %284 = load ptr, ptr %41, align 8, !tbaa !56
  %285 = getelementptr inbounds ptr, ptr %284, i64 %33
  %286 = load ptr, ptr %285, align 8, !tbaa !30
  %287 = load ptr, ptr %40, align 8, !tbaa !55
  %288 = getelementptr inbounds ptr, ptr %287, i64 %33
  %289 = load ptr, ptr %288, align 8, !tbaa !30
  tail call void @cmatrix_hermitian(ptr noundef %286, ptr noundef %289) #4
  %290 = load ptr, ptr %42, align 8, !tbaa !57
  %291 = getelementptr inbounds ptr, ptr %290, i64 %33
  %292 = load ptr, ptr %291, align 8, !tbaa !30
  %293 = load ptr, ptr %40, align 8, !tbaa !55
  %294 = getelementptr inbounds ptr, ptr %293, i64 %33
  %295 = load ptr, ptr %294, align 8, !tbaa !30
  %296 = load ptr, ptr %41, align 8, !tbaa !56
  %297 = getelementptr inbounds ptr, ptr %296, i64 %33
  %298 = load ptr, ptr %297, align 8, !tbaa !30
  tail call void @cmatrix_mul(ptr noundef %292, ptr noundef %295, ptr noundef %298) #4
  %299 = load ptr, ptr %43, align 8, !tbaa !58
  %300 = getelementptr inbounds ptr, ptr %299, i64 %33
  %301 = load ptr, ptr %300, align 8, !tbaa !30
  %302 = load ptr, ptr %42, align 8, !tbaa !57
  %303 = getelementptr inbounds ptr, ptr %302, i64 %33
  %304 = load ptr, ptr %303, align 8, !tbaa !30
  tail call void @cmatrix_copy_cmatrix(ptr noundef %301, ptr noundef %304) #4
  %305 = load ptr, ptr %43, align 8, !tbaa !58
  %306 = getelementptr inbounds ptr, ptr %305, i64 %33
  %307 = load ptr, ptr %306, align 8, !tbaa !30
  %308 = load ptr, ptr %307, align 8, !tbaa !26
  %309 = getelementptr inbounds i8, ptr %307, i64 8
  %310 = load ptr, ptr %309, align 8, !tbaa !28
  br i1 %64, label %.unr-lcssa, label %._crit_edge397.new

._crit_edge397.new:                               ; preds = %._crit_edge397, %._crit_edge397.new
  %indvars.iv463 = phi i64 [ %indvars.iv.next464.3, %._crit_edge397.new ], [ 0, %._crit_edge397 ]
  %niter = phi i64 [ %niter.next.3, %._crit_edge397.new ], [ 0, %._crit_edge397 ]
  %311 = trunc nuw i64 %indvars.iv463 to i32
  %312 = mul i32 %.2349364, %311
  %313 = zext i32 %312 to i64
  %314 = getelementptr inbounds float, ptr %308, i64 %313
  store float 0.000000e+00, ptr %314, align 4, !tbaa !31
  %315 = getelementptr inbounds float, ptr %310, i64 %313
  store float 0.000000e+00, ptr %315, align 4, !tbaa !31
  %316 = trunc i64 %indvars.iv463 to i32
  %317 = or disjoint i32 %316, 1
  %318 = mul i32 %.2349364, %317
  %319 = zext i32 %318 to i64
  %320 = getelementptr inbounds float, ptr %308, i64 %319
  store float 0.000000e+00, ptr %320, align 4, !tbaa !31
  %321 = getelementptr inbounds float, ptr %310, i64 %319
  store float 0.000000e+00, ptr %321, align 4, !tbaa !31
  %322 = trunc i64 %indvars.iv463 to i32
  %323 = or disjoint i32 %322, 2
  %324 = mul i32 %.2349364, %323
  %325 = zext i32 %324 to i64
  %326 = getelementptr inbounds float, ptr %308, i64 %325
  store float 0.000000e+00, ptr %326, align 4, !tbaa !31
  %327 = getelementptr inbounds float, ptr %310, i64 %325
  store float 0.000000e+00, ptr %327, align 4, !tbaa !31
  %328 = trunc i64 %indvars.iv463 to i32
  %329 = or disjoint i32 %328, 3
  %330 = mul i32 %.2349364, %329
  %331 = zext i32 %330 to i64
  %332 = getelementptr inbounds float, ptr %308, i64 %331
  store float 0.000000e+00, ptr %332, align 4, !tbaa !31
  %333 = getelementptr inbounds float, ptr %310, i64 %331
  store float 0.000000e+00, ptr %333, align 4, !tbaa !31
  %indvars.iv.next464.3 = add nuw nsw i64 %indvars.iv463, 4
  %niter.next.3 = add i64 %niter, 4
  %niter.ncmp.3 = icmp eq i64 %niter.next.3, %unroll_iter
  br i1 %niter.ncmp.3, label %.unr-lcssa, label %._crit_edge397.new, !llvm.loop !59

.unr-lcssa:                                       ; preds = %._crit_edge397.new, %._crit_edge397
  %indvars.iv463.unr = phi i64 [ 0, %._crit_edge397 ], [ %indvars.iv.next464.3, %._crit_edge397.new ]
  br i1 %lcmp.mod589.not, label %.epilog-lcssa, label %.epil.preheader

.epil.preheader:                                  ; preds = %.unr-lcssa, %.epil.preheader
  %indvars.iv463.epil = phi i64 [ %indvars.iv.next464.epil, %.epil.preheader ], [ %indvars.iv463.unr, %.unr-lcssa ]
  %epil.iter = phi i64 [ %epil.iter.next, %.epil.preheader ], [ 0, %.unr-lcssa ]
  %334 = trunc nuw i64 %indvars.iv463.epil to i32
  %335 = mul i32 %.2349364, %334
  %336 = zext i32 %335 to i64
  %337 = getelementptr inbounds float, ptr %308, i64 %336
  store float 0.000000e+00, ptr %337, align 4, !tbaa !31
  %338 = getelementptr inbounds float, ptr %310, i64 %336
  store float 0.000000e+00, ptr %338, align 4, !tbaa !31
  %indvars.iv.next464.epil = add nuw nsw i64 %indvars.iv463.epil, 1
  %epil.iter.next = add i64 %epil.iter, 1
  %epil.iter.cmp.not = icmp eq i64 %epil.iter.next, %xtraiter588
  br i1 %epil.iter.cmp.not, label %.epilog-lcssa, label %.epil.preheader, !llvm.loop !60

.epilog-lcssa:                                    ; preds = %.epil.preheader, %.unr-lcssa
  %339 = load ptr, ptr %44, align 8, !tbaa !62
  %340 = getelementptr inbounds ptr, ptr %339, i64 %33
  %341 = load ptr, ptr %340, align 8, !tbaa !30
  tail call void @cmatrix_zero(ptr noundef %341) #4
  %342 = load ptr, ptr %45, align 8, !tbaa !63
  %343 = getelementptr inbounds ptr, ptr %342, i64 %33
  %344 = load ptr, ptr %343, align 8, !tbaa !30
  tail call void @cmatrix_zero(ptr noundef %344) #4
  %345 = load i32, ptr %0, align 8, !tbaa !5
  %.not431 = icmp eq i32 %345, 0
  br i1 %.not431, label %._crit_edge407, label %.lr.ph406

.lr.ph406:                                        ; preds = %.epilog-lcssa
  %346 = load ptr, ptr %34, align 8, !tbaa !12
  %wide.trip.count476 = zext i32 %345 to i64
  %347 = trunc nuw i64 %indvars.iv498 to i32
  br label %348

348:                                              ; preds = %.lr.ph406, %401
  %indvars.iv473 = phi i64 [ 0, %.lr.ph406 ], [ %indvars.iv.next474, %401 ]
  %.3350402 = phi i32 [ 0, %.lr.ph406 ], [ %.4351, %401 ]
  %349 = getelementptr inbounds i64, ptr %346, i64 %indvars.iv473
  %350 = load i64, ptr %349, align 8, !tbaa !14
  %.not363 = icmp eq i64 %350, 0
  br i1 %.not363, label %401, label %.preheader367

.preheader367:                                    ; preds = %348
  %351 = load i32, ptr %27, align 4, !tbaa !22
  %.not432 = icmp eq i32 %351, 0
  br i1 %.not432, label %._crit_edge401, label %.lr.ph400

.lr.ph400:                                        ; preds = %.preheader367
  %352 = trunc nuw i64 %indvars.iv473 to i32
  %353 = mul i32 %351, %352
  %354 = load ptr, ptr %37, align 8, !tbaa !47
  %355 = mul i32 %351, %.3350402
  %356 = mul i32 %351, %347
  %wide.trip.count471 = zext i32 %351 to i64
  br label %357

357:                                              ; preds = %.lr.ph400, %399
  %indvars.iv468 = phi i64 [ 0, %.lr.ph400 ], [ %indvars.iv.next469, %399 ]
  %358 = trunc nuw i64 %indvars.iv468 to i32
  %359 = add i32 %353, %358
  %360 = zext i32 %359 to i64
  %361 = getelementptr inbounds i8, ptr %354, i64 %360
  %362 = load i8, ptr %361, align 1, !tbaa !49
  %363 = icmp eq i8 %362, 1
  br i1 %363, label %364, label %399

364:                                              ; preds = %357
  %365 = add i32 %355, %358
  %366 = mul i32 %spec.select.lcssa, %358
  %367 = add i32 %366, %.3350402
  %368 = add i32 %356, %358
  %369 = load ptr, ptr %38, align 8, !tbaa !50
  %370 = getelementptr inbounds ptr, ptr %369, i64 %indvars.iv473
  %371 = load ptr, ptr %370, align 8, !tbaa !30
  %372 = shl i32 %368, 1
  %373 = zext i32 %372 to i64
  %374 = getelementptr inbounds float, ptr %371, i64 %373
  %375 = load float, ptr %374, align 4, !tbaa !31
  %376 = or disjoint i32 %372, 1
  %377 = zext i32 %376 to i64
  %378 = getelementptr inbounds float, ptr %371, i64 %377
  %379 = load float, ptr %378, align 4, !tbaa !31
  %380 = load ptr, ptr %44, align 8, !tbaa !62
  %381 = getelementptr inbounds ptr, ptr %380, i64 %33
  %382 = load ptr, ptr %381, align 8, !tbaa !30
  %383 = load ptr, ptr %382, align 8, !tbaa !26
  %384 = zext i32 %367 to i64
  %385 = getelementptr inbounds float, ptr %383, i64 %384
  store float %375, ptr %385, align 4, !tbaa !31
  %386 = getelementptr inbounds i8, ptr %382, i64 8
  %387 = load ptr, ptr %386, align 8, !tbaa !28
  %388 = getelementptr inbounds float, ptr %387, i64 %384
  store float %379, ptr %388, align 4, !tbaa !31
  %389 = load ptr, ptr %45, align 8, !tbaa !63
  %390 = getelementptr inbounds ptr, ptr %389, i64 %33
  %391 = load ptr, ptr %390, align 8, !tbaa !30
  %392 = load ptr, ptr %391, align 8, !tbaa !26
  %393 = zext i32 %365 to i64
  %394 = getelementptr inbounds float, ptr %392, i64 %393
  store float %375, ptr %394, align 4, !tbaa !31
  %395 = fneg float %379
  %396 = getelementptr inbounds i8, ptr %391, i64 8
  %397 = load ptr, ptr %396, align 8, !tbaa !28
  %398 = getelementptr inbounds float, ptr %397, i64 %393
  store float %395, ptr %398, align 4, !tbaa !31
  br label %399

399:                                              ; preds = %357, %364
  %indvars.iv.next469 = add nuw nsw i64 %indvars.iv468, 1
  %exitcond472.not = icmp eq i64 %indvars.iv.next469, %wide.trip.count471
  br i1 %exitcond472.not, label %._crit_edge401, label %357, !llvm.loop !64

._crit_edge401:                                   ; preds = %399, %.preheader367
  %400 = add i32 %.3350402, 1
  br label %401

401:                                              ; preds = %348, %._crit_edge401
  %.4351 = phi i32 [ %400, %._crit_edge401 ], [ %.3350402, %348 ]
  %indvars.iv.next474 = add nuw nsw i64 %indvars.iv473, 1
  %exitcond477.not = icmp eq i64 %indvars.iv.next474, %wide.trip.count476
  br i1 %exitcond477.not, label %._crit_edge407, label %348, !llvm.loop !65

._crit_edge407:                                   ; preds = %401, %.epilog-lcssa
  %402 = load ptr, ptr %46, align 8, !tbaa !66
  %403 = getelementptr inbounds ptr, ptr %402, i64 %33
  %404 = load ptr, ptr %403, align 8, !tbaa !30
  %405 = load ptr, ptr %43, align 8, !tbaa !58
  %406 = getelementptr inbounds ptr, ptr %405, i64 %33
  %407 = load ptr, ptr %406, align 8, !tbaa !30
  %408 = load ptr, ptr %40, align 8, !tbaa !55
  %409 = getelementptr inbounds ptr, ptr %408, i64 %33
  %410 = load ptr, ptr %409, align 8, !tbaa !30
  tail call void @cmatrix_mul(ptr noundef %404, ptr noundef %407, ptr noundef %410) #4
  %411 = load ptr, ptr %47, align 8, !tbaa !67
  %412 = getelementptr inbounds ptr, ptr %411, i64 %33
  %413 = load ptr, ptr %412, align 8, !tbaa !30
  %414 = load ptr, ptr %46, align 8, !tbaa !66
  %415 = getelementptr inbounds ptr, ptr %414, i64 %33
  %416 = load ptr, ptr %415, align 8, !tbaa !30
  tail call void @cmatrix_scale(ptr noundef %413, ptr noundef %416, float noundef 4.000000e+00) #4
  %417 = load ptr, ptr %48, align 8, !tbaa !68
  %418 = getelementptr inbounds ptr, ptr %417, i64 %33
  %419 = load ptr, ptr %418, align 8, !tbaa !30
  %420 = load ptr, ptr %47, align 8, !tbaa !67
  %421 = getelementptr inbounds ptr, ptr %420, i64 %33
  %422 = load ptr, ptr %421, align 8, !tbaa !30
  %423 = load ptr, ptr %30, align 8, !tbaa !29
  tail call void @cmatrix_mul(ptr noundef %419, ptr noundef %422, ptr noundef %423) #4
  %424 = load ptr, ptr %49, align 8, !tbaa !69
  %425 = getelementptr inbounds ptr, ptr %424, i64 %33
  %426 = load ptr, ptr %425, align 8, !tbaa !30
  %427 = load ptr, ptr %48, align 8, !tbaa !68
  %428 = getelementptr inbounds ptr, ptr %427, i64 %33
  %429 = load ptr, ptr %428, align 8, !tbaa !30
  tail call void @cmatrix_copy_cmatrix(ptr noundef %426, ptr noundef %429) #4
  %430 = load ptr, ptr %50, align 8, !tbaa !70
  %431 = getelementptr inbounds ptr, ptr %430, i64 %33
  %432 = load ptr, ptr %431, align 8, !tbaa !30
  %433 = load ptr, ptr %31, align 8, !tbaa !33
  %434 = getelementptr inbounds ptr, ptr %433, i64 %33
  %435 = load ptr, ptr %434, align 8, !tbaa !30
  %436 = load ptr, ptr %44, align 8, !tbaa !62
  %437 = getelementptr inbounds ptr, ptr %436, i64 %33
  %438 = load ptr, ptr %437, align 8, !tbaa !30
  tail call void @cmatrix_mul(ptr noundef %432, ptr noundef %435, ptr noundef %438) #4
  %439 = load ptr, ptr %51, align 8, !tbaa !71
  %440 = getelementptr inbounds ptr, ptr %439, i64 %33
  %441 = load ptr, ptr %440, align 8, !tbaa !30
  %442 = load ptr, ptr %50, align 8, !tbaa !70
  %443 = getelementptr inbounds ptr, ptr %442, i64 %33
  %444 = load ptr, ptr %443, align 8, !tbaa !30
  tail call void @cmatrix_copy_cmatrix(ptr noundef %441, ptr noundef %444) #4
  %445 = load ptr, ptr %51, align 8, !tbaa !71
  %446 = getelementptr inbounds ptr, ptr %445, i64 %33
  %447 = load ptr, ptr %446, align 8, !tbaa !30
  %448 = load ptr, ptr %447, align 8, !tbaa !26
  br i1 %65, label %.unr-lcssa590, label %._crit_edge407.new

._crit_edge407.new:                               ; preds = %._crit_edge407, %._crit_edge407.new
  %indvars.iv478 = phi i64 [ %indvars.iv.next479.3, %._crit_edge407.new ], [ 0, %._crit_edge407 ]
  %niter597 = phi i64 [ %niter597.next.3, %._crit_edge407.new ], [ 0, %._crit_edge407 ]
  %449 = trunc nuw i64 %indvars.iv478 to i32
  %450 = mul i32 %.2349364, %449
  %451 = zext i32 %450 to i64
  %452 = getelementptr inbounds float, ptr %448, i64 %451
  %453 = load float, ptr %452, align 4, !tbaa !31
  %454 = fadd float %453, -1.000000e+00
  store float %454, ptr %452, align 4, !tbaa !31
  %455 = trunc i64 %indvars.iv478 to i32
  %456 = or disjoint i32 %455, 1
  %457 = mul i32 %.2349364, %456
  %458 = zext i32 %457 to i64
  %459 = getelementptr inbounds float, ptr %448, i64 %458
  %460 = load float, ptr %459, align 4, !tbaa !31
  %461 = fadd float %460, -1.000000e+00
  store float %461, ptr %459, align 4, !tbaa !31
  %462 = trunc i64 %indvars.iv478 to i32
  %463 = or disjoint i32 %462, 2
  %464 = mul i32 %.2349364, %463
  %465 = zext i32 %464 to i64
  %466 = getelementptr inbounds float, ptr %448, i64 %465
  %467 = load float, ptr %466, align 4, !tbaa !31
  %468 = fadd float %467, -1.000000e+00
  store float %468, ptr %466, align 4, !tbaa !31
  %469 = trunc i64 %indvars.iv478 to i32
  %470 = or disjoint i32 %469, 3
  %471 = mul i32 %.2349364, %470
  %472 = zext i32 %471 to i64
  %473 = getelementptr inbounds float, ptr %448, i64 %472
  %474 = load float, ptr %473, align 4, !tbaa !31
  %475 = fadd float %474, -1.000000e+00
  store float %475, ptr %473, align 4, !tbaa !31
  %indvars.iv.next479.3 = add nuw nsw i64 %indvars.iv478, 4
  %niter597.next.3 = add i64 %niter597, 4
  %niter597.ncmp.3 = icmp eq i64 %niter597.next.3, %unroll_iter596
  br i1 %niter597.ncmp.3, label %.unr-lcssa590, label %._crit_edge407.new, !llvm.loop !72

.unr-lcssa590:                                    ; preds = %._crit_edge407.new, %._crit_edge407
  %indvars.iv478.unr = phi i64 [ 0, %._crit_edge407 ], [ %indvars.iv.next479.3, %._crit_edge407.new ]
  br i1 %lcmp.mod594.not, label %.epilog-lcssa595, label %.epil.preheader591

.epil.preheader591:                               ; preds = %.unr-lcssa590, %.epil.preheader591
  %indvars.iv478.epil = phi i64 [ %indvars.iv.next479.epil, %.epil.preheader591 ], [ %indvars.iv478.unr, %.unr-lcssa590 ]
  %epil.iter593 = phi i64 [ %epil.iter593.next, %.epil.preheader591 ], [ 0, %.unr-lcssa590 ]
  %476 = trunc nuw i64 %indvars.iv478.epil to i32
  %477 = mul i32 %.2349364, %476
  %478 = zext i32 %477 to i64
  %479 = getelementptr inbounds float, ptr %448, i64 %478
  %480 = load float, ptr %479, align 4, !tbaa !31
  %481 = fadd float %480, -1.000000e+00
  store float %481, ptr %479, align 4, !tbaa !31
  %indvars.iv.next479.epil = add nuw nsw i64 %indvars.iv478.epil, 1
  %epil.iter593.next = add i64 %epil.iter593, 1
  %epil.iter593.cmp.not = icmp eq i64 %epil.iter593.next, %xtraiter592
  br i1 %epil.iter593.cmp.not, label %.epilog-lcssa595, label %.epil.preheader591, !llvm.loop !73

.epilog-lcssa595:                                 ; preds = %.epil.preheader591, %.unr-lcssa590
  %482 = load ptr, ptr %52, align 8, !tbaa !74
  %483 = getelementptr inbounds ptr, ptr %482, i64 %33
  %484 = load ptr, ptr %483, align 8, !tbaa !30
  tail call void @cmatrix_scale(ptr noundef %484, ptr noundef nonnull %447, float noundef 2.000000e+00) #4
  %485 = load ptr, ptr %53, align 8, !tbaa !75
  %486 = getelementptr inbounds ptr, ptr %485, i64 %33
  %487 = load ptr, ptr %486, align 8, !tbaa !30
  %488 = load ptr, ptr %52, align 8, !tbaa !74
  %489 = getelementptr inbounds ptr, ptr %488, i64 %33
  %490 = load ptr, ptr %489, align 8, !tbaa !30
  %491 = load ptr, ptr %45, align 8, !tbaa !63
  %492 = getelementptr inbounds ptr, ptr %491, i64 %33
  %493 = load ptr, ptr %492, align 8, !tbaa !30
  tail call void @cmatrix_mul(ptr noundef %487, ptr noundef %490, ptr noundef %493) #4
  %494 = load ptr, ptr %54, align 8, !tbaa !76
  %495 = getelementptr inbounds ptr, ptr %494, i64 %33
  %496 = load ptr, ptr %495, align 8, !tbaa !30
  %497 = load ptr, ptr %53, align 8, !tbaa !75
  %498 = getelementptr inbounds ptr, ptr %497, i64 %33
  %499 = load ptr, ptr %498, align 8, !tbaa !30
  tail call void @cmatrix_copy_cmatrix(ptr noundef %496, ptr noundef %499) #4
  %500 = load i32, ptr %27, align 4, !tbaa !22
  %.not433 = icmp eq i32 %500, 0
  br i1 %.not433, label %._crit_edge413, label %.lr.ph412

.lr.ph412:                                        ; preds = %.epilog-lcssa595
  %501 = load ptr, ptr %29, align 8, !tbaa !25
  %502 = load ptr, ptr %501, align 8, !tbaa !26
  %503 = getelementptr inbounds i8, ptr %501, i64 8
  %504 = load ptr, ptr %503, align 8, !tbaa !28
  %wide.trip.count486 = zext i32 %500 to i64
  %xtraiter599 = and i64 %wide.trip.count486, 1
  %505 = icmp eq i32 %500, 1
  br i1 %505, label %._crit_edge413.loopexit.unr-lcssa, label %.lr.ph412.new

.lr.ph412.new:                                    ; preds = %.lr.ph412
  %unroll_iter603 = and i64 %wide.trip.count486, 4294967294
  br label %506

506:                                              ; preds = %506, %.lr.ph412.new
  %indvars.iv483 = phi i64 [ 0, %.lr.ph412.new ], [ %indvars.iv.next484.1, %506 ]
  %.0338410 = phi float [ 0.000000e+00, %.lr.ph412.new ], [ %520, %506 ]
  %niter604 = phi i64 [ 0, %.lr.ph412.new ], [ %niter604.next.1, %506 ]
  %507 = getelementptr inbounds float, ptr %502, i64 %indvars.iv483
  %508 = load float, ptr %507, align 4, !tbaa !31
  %509 = getelementptr inbounds float, ptr %504, i64 %indvars.iv483
  %510 = load float, ptr %509, align 4, !tbaa !31
  %511 = fmul float %510, %510
  %512 = tail call float @llvm.fmuladd.f32(float %508, float %508, float %511)
  %513 = fadd float %.0338410, %512
  %indvars.iv.next484 = or disjoint i64 %indvars.iv483, 1
  %514 = getelementptr inbounds float, ptr %502, i64 %indvars.iv.next484
  %515 = load float, ptr %514, align 4, !tbaa !31
  %516 = getelementptr inbounds float, ptr %504, i64 %indvars.iv.next484
  %517 = load float, ptr %516, align 4, !tbaa !31
  %518 = fmul float %517, %517
  %519 = tail call float @llvm.fmuladd.f32(float %515, float %515, float %518)
  %520 = fadd float %513, %519
  %indvars.iv.next484.1 = add nuw nsw i64 %indvars.iv483, 2
  %niter604.next.1 = add i64 %niter604, 2
  %niter604.ncmp.1 = icmp eq i64 %niter604.next.1, %unroll_iter603
  br i1 %niter604.ncmp.1, label %._crit_edge413.loopexit.unr-lcssa, label %506, !llvm.loop !77

._crit_edge413.loopexit.unr-lcssa:                ; preds = %506, %.lr.ph412
  %.lcssa.ph = phi float [ poison, %.lr.ph412 ], [ %520, %506 ]
  %indvars.iv483.unr = phi i64 [ 0, %.lr.ph412 ], [ %indvars.iv.next484.1, %506 ]
  %.0338410.unr = phi float [ 0.000000e+00, %.lr.ph412 ], [ %520, %506 ]
  %lcmp.mod601.not = icmp eq i64 %xtraiter599, 0
  br i1 %lcmp.mod601.not, label %._crit_edge413, label %._crit_edge413.loopexit.epilog-lcssa

._crit_edge413.loopexit.epilog-lcssa:             ; preds = %._crit_edge413.loopexit.unr-lcssa
  %521 = getelementptr inbounds float, ptr %502, i64 %indvars.iv483.unr
  %522 = load float, ptr %521, align 4, !tbaa !31
  %523 = getelementptr inbounds float, ptr %504, i64 %indvars.iv483.unr
  %524 = load float, ptr %523, align 4, !tbaa !31
  %525 = fmul float %524, %524
  %526 = tail call float @llvm.fmuladd.f32(float %522, float %522, float %525)
  %527 = fadd float %.0338410.unr, %526
  br label %._crit_edge413

._crit_edge413:                                   ; preds = %._crit_edge413.loopexit.epilog-lcssa, %._crit_edge413.loopexit.unr-lcssa, %.epilog-lcssa595
  %.0338.lcssa = phi float [ 0.000000e+00, %.epilog-lcssa595 ], [ %.lcssa.ph, %._crit_edge413.loopexit.unr-lcssa ], [ %527, %._crit_edge413.loopexit.epilog-lcssa ]
  %528 = fmul float %.0338.lcssa, %.0338.lcssa
  %529 = load float, ptr %36, align 4, !tbaa !46
  %530 = fadd float %528, %529
  %531 = fdiv float 1.000000e+00, %530
  %532 = load ptr, ptr %55, align 8, !tbaa !78
  %533 = getelementptr inbounds ptr, ptr %532, i64 %33
  %534 = load ptr, ptr %533, align 8, !tbaa !30
  %535 = load ptr, ptr %49, align 8, !tbaa !69
  %536 = getelementptr inbounds ptr, ptr %535, i64 %33
  %537 = load ptr, ptr %536, align 8, !tbaa !30
  tail call void @cmatrix_scale(ptr noundef %534, ptr noundef %537, float noundef %531) #4
  %538 = load ptr, ptr %56, align 8, !tbaa !79
  %539 = getelementptr inbounds ptr, ptr %538, i64 %33
  %540 = load ptr, ptr %539, align 8, !tbaa !30
  %541 = load ptr, ptr %55, align 8, !tbaa !78
  %542 = getelementptr inbounds ptr, ptr %541, i64 %33
  %543 = load ptr, ptr %542, align 8, !tbaa !30
  %544 = load ptr, ptr %54, align 8, !tbaa !76
  %545 = getelementptr inbounds ptr, ptr %544, i64 %33
  %546 = load ptr, ptr %545, align 8, !tbaa !30
  tail call void @cmatrix_add(ptr noundef %540, ptr noundef %543, ptr noundef %546) #4
  %547 = load ptr, ptr %57, align 8, !tbaa !80
  %548 = getelementptr inbounds ptr, ptr %547, i64 %33
  %549 = load ptr, ptr %548, align 8, !tbaa !30
  %550 = load ptr, ptr %56, align 8, !tbaa !79
  %551 = getelementptr inbounds ptr, ptr %550, i64 %33
  %552 = load ptr, ptr %551, align 8, !tbaa !30
  %553 = load float, ptr %58, align 8, !tbaa !81
  tail call void @cmatrix_scale(ptr noundef %549, ptr noundef %552, float noundef %553) #4
  %554 = load ptr, ptr %59, align 8, !tbaa !82
  %555 = getelementptr inbounds ptr, ptr %554, i64 %33
  %556 = load ptr, ptr %555, align 8, !tbaa !30
  %557 = load ptr, ptr %31, align 8, !tbaa !33
  %558 = getelementptr inbounds ptr, ptr %557, i64 %33
  %559 = load ptr, ptr %558, align 8, !tbaa !30
  %560 = load float, ptr %60, align 4, !tbaa !83
  %561 = load float, ptr %58, align 8, !tbaa !81
  %562 = fneg float %560
  %563 = tail call float @llvm.fmuladd.f32(float %562, float %561, float 1.000000e+00)
  tail call void @cmatrix_scale(ptr noundef %556, ptr noundef %559, float noundef %563) #4
  %564 = load ptr, ptr %61, align 8, !tbaa !84
  %565 = getelementptr inbounds ptr, ptr %564, i64 %33
  %566 = load ptr, ptr %565, align 8, !tbaa !30
  %567 = load ptr, ptr %59, align 8, !tbaa !82
  %568 = getelementptr inbounds ptr, ptr %567, i64 %33
  %569 = load ptr, ptr %568, align 8, !tbaa !30
  %570 = load ptr, ptr %57, align 8, !tbaa !80
  %571 = getelementptr inbounds ptr, ptr %570, i64 %33
  %572 = load ptr, ptr %571, align 8, !tbaa !30
  tail call void @cmatrix_sub(ptr noundef %566, ptr noundef %569, ptr noundef %572) #4
  %573 = load ptr, ptr %62, align 8, !tbaa !85
  %574 = getelementptr inbounds ptr, ptr %573, i64 %33
  %575 = load ptr, ptr %574, align 8, !tbaa !30
  %576 = load ptr, ptr %61, align 8, !tbaa !84
  %577 = getelementptr inbounds ptr, ptr %576, i64 %33
  %578 = load ptr, ptr %577, align 8, !tbaa !30
  tail call void @cmatrix_copy_cmatrix(ptr noundef %575, ptr noundef %578) #4
  %579 = load i32, ptr %0, align 8, !tbaa !5
  %.not434 = icmp eq i32 %579, 0
  br i1 %.not434, label %._crit_edge422, label %.lr.ph421

.lr.ph421:                                        ; preds = %._crit_edge413
  %580 = load ptr, ptr %34, align 8, !tbaa !12
  %wide.trip.count496 = zext i32 %579 to i64
  %581 = trunc nuw i64 %indvars.iv498 to i32
  br label %582

582:                                              ; preds = %.lr.ph421, %692
  %indvars.iv493 = phi i64 [ 0, %.lr.ph421 ], [ %indvars.iv.next494, %692 ]
  %.6353418 = phi i32 [ 0, %.lr.ph421 ], [ %.7, %692 ]
  %583 = getelementptr inbounds i64, ptr %580, i64 %indvars.iv493
  %584 = load i64, ptr %583, align 8, !tbaa !14
  %.not361 = icmp eq i64 %584, 0
  br i1 %.not361, label %692, label %.preheader

.preheader:                                       ; preds = %582
  %585 = load i32, ptr %27, align 4, !tbaa !22
  %.not435 = icmp eq i32 %585, 0
  br i1 %.not435, label %._crit_edge417, label %.lr.ph416

.lr.ph416:                                        ; preds = %.preheader
  %586 = mul i32 %585, %581
  %587 = mul i32 %585, %.6353418
  %588 = load ptr, ptr %62, align 8, !tbaa !85
  %589 = getelementptr inbounds ptr, ptr %588, i64 %33
  %590 = load ptr, ptr %589, align 8, !tbaa !30
  %591 = load ptr, ptr %590, align 8, !tbaa !26
  %592 = getelementptr inbounds i8, ptr %590, i64 8
  %593 = load ptr, ptr %592, align 8, !tbaa !28
  %594 = load ptr, ptr %63, align 8, !tbaa !34
  %595 = getelementptr inbounds ptr, ptr %594, i64 %indvars.iv493
  %596 = load ptr, ptr %595, align 8, !tbaa !30
  %wide.trip.count491 = zext i32 %585 to i64
  %min.iters.check530 = icmp ult i32 %585, 44
  br i1 %min.iters.check530, label %scalar.ph529.preheader, label %vector.scevcheck

vector.scevcheck:                                 ; preds = %.lr.ph416
  %597 = add nsw i64 %wide.trip.count491, -1
  %598 = mul i32 %69, %585
  %599 = trunc i64 %597 to i32
  %mul.result = shl i32 %599, 1
  %600 = xor i32 %598, -1
  %601 = icmp ugt i32 %mul.result, %600
  %602 = trunc i64 %597 to i32
  %mul.result509 = shl i32 %602, 1
  %603 = xor i32 %598, -2
  %604 = icmp ult i32 %603, %mul.result509
  %605 = icmp ugt i64 %597, 2147483647
  %606 = or i1 %604, %605
  %607 = trunc i64 %597 to i32
  %608 = xor i32 %587, -1
  %609 = icmp ult i32 %608, %607
  %610 = zext i32 %598 to i64
  %611 = shl nuw nsw i64 %610, 2
  %scevgep = getelementptr i8, ptr %596, i64 %611
  %mul.result512 = shl nsw i64 %597, 3
  %612 = getelementptr i8, ptr %scevgep, i64 %mul.result512
  %613 = icmp ult ptr %612, %scevgep
  %scevgep514 = getelementptr i8, ptr %596, i64 4
  %scevgep515 = getelementptr i8, ptr %scevgep514, i64 %611
  %mul.result517 = shl nsw i64 %597, 3
  %614 = getelementptr i8, ptr %scevgep515, i64 %mul.result517
  %615 = icmp ult ptr %614, %scevgep515
  %616 = or i1 %601, %606
  %617 = or i1 %609, %616
  %618 = or i1 %613, %617
  %619 = or i1 %615, %618
  br i1 %619, label %scalar.ph529.preheader, label %vector.memcheck

vector.memcheck:                                  ; preds = %vector.scevcheck
  %620 = mul i32 %68, %585
  %621 = zext i32 %620 to i64
  %622 = shl nuw nsw i64 %621, 2
  %scevgep519 = getelementptr i8, ptr %596, i64 %622
  %623 = shl nuw nsw i64 %wide.trip.count491, 3
  %624 = getelementptr i8, ptr %596, i64 %623
  %scevgep520 = getelementptr i8, ptr %624, i64 %622
  %625 = zext i32 %587 to i64
  %626 = shl nuw nsw i64 %625, 2
  %scevgep521 = getelementptr i8, ptr %591, i64 %626
  %627 = add nuw nsw i64 %wide.trip.count491, %625
  %628 = shl nuw nsw i64 %627, 2
  %scevgep522 = getelementptr i8, ptr %591, i64 %628
  %scevgep523 = getelementptr i8, ptr %593, i64 %626
  %scevgep524 = getelementptr i8, ptr %593, i64 %628
  %bound0 = icmp ult ptr %scevgep519, %scevgep522
  %bound1 = icmp ult ptr %scevgep521, %scevgep520
  %found.conflict = and i1 %bound0, %bound1
  %bound0525 = icmp ult ptr %scevgep519, %scevgep524
  %bound1526 = icmp ult ptr %scevgep523, %scevgep520
  %found.conflict527 = and i1 %bound0525, %bound1526
  %conflict.rdx = or i1 %found.conflict, %found.conflict527
  br i1 %conflict.rdx, label %scalar.ph529.preheader, label %vector.ph531

vector.ph531:                                     ; preds = %vector.memcheck
  %n.vec533 = and i64 %wide.trip.count491, 4294967292
  %invariant.gep = getelementptr i8, ptr %596, i64 -4
  %invariant.gep611 = getelementptr i8, ptr %596, i64 -4
  br label %vector.body535

vector.body535:                                   ; preds = %vector.body535, %vector.ph531
  %index536 = phi i64 [ 0, %vector.ph531 ], [ %index.next542, %vector.body535 ]
  %629 = trunc i64 %index536 to i32
  %630 = or disjoint i32 %629, 2
  %631 = add i32 %586, %629
  %632 = add i32 %586, %630
  %633 = add i32 %587, %629
  %634 = zext i32 %633 to i64
  %635 = getelementptr inbounds float, ptr %591, i64 %634
  %636 = getelementptr inbounds i8, ptr %635, i64 8
  %wide.load537 = load <2 x float>, ptr %635, align 4, !tbaa !31, !alias.scope !86
  %wide.load538 = load <2 x float>, ptr %636, align 4, !tbaa !31, !alias.scope !86
  %637 = getelementptr inbounds float, ptr %593, i64 %634
  %638 = getelementptr inbounds i8, ptr %637, i64 8
  %wide.load539 = load <2 x float>, ptr %637, align 4, !tbaa !31, !alias.scope !89
  %wide.load540 = load <2 x float>, ptr %638, align 4, !tbaa !31, !alias.scope !89
  %639 = shl i32 %631, 1
  %640 = shl i32 %632, 1
  %641 = or disjoint i32 %639, 1
  %642 = or disjoint i32 %640, 1
  %643 = zext i32 %641 to i64
  %644 = zext i32 %642 to i64
  %gep = getelementptr float, ptr %invariant.gep, i64 %643
  %gep612 = getelementptr float, ptr %invariant.gep611, i64 %644
  %interleaved.vec = shufflevector <2 x float> %wide.load537, <2 x float> %wide.load539, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
  store <4 x float> %interleaved.vec, ptr %gep, align 4, !tbaa !31
  %interleaved.vec541 = shufflevector <2 x float> %wide.load538, <2 x float> %wide.load540, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
  store <4 x float> %interleaved.vec541, ptr %gep612, align 4, !tbaa !31
  %index.next542 = add nuw i64 %index536, 4
  %645 = icmp eq i64 %index.next542, %n.vec533
  br i1 %645, label %middle.block528, label %vector.body535, !llvm.loop !91

middle.block528:                                  ; preds = %vector.body535
  %cmp.n543 = icmp eq i64 %n.vec533, %wide.trip.count491
  br i1 %cmp.n543, label %._crit_edge417, label %scalar.ph529.preheader

scalar.ph529.preheader:                           ; preds = %middle.block528, %vector.memcheck, %vector.scevcheck, %.lr.ph416
  %indvars.iv488.ph = phi i64 [ 0, %vector.memcheck ], [ 0, %vector.scevcheck ], [ 0, %.lr.ph416 ], [ %n.vec533, %middle.block528 ]
  %xtraiter605 = and i64 %wide.trip.count491, 1
  %lcmp.mod606.not = icmp eq i64 %xtraiter605, 0
  br i1 %lcmp.mod606.not, label %scalar.ph529.prol.loopexit, label %scalar.ph529.prol

scalar.ph529.prol:                                ; preds = %scalar.ph529.preheader
  %646 = trunc nuw i64 %indvars.iv488.ph to i32
  %647 = add i32 %586, %646
  %648 = add i32 %587, %646
  %649 = zext i32 %648 to i64
  %650 = getelementptr inbounds float, ptr %591, i64 %649
  %651 = load float, ptr %650, align 4, !tbaa !31
  %652 = getelementptr inbounds float, ptr %593, i64 %649
  %653 = load float, ptr %652, align 4, !tbaa !31
  %654 = shl i32 %647, 1
  %655 = zext i32 %654 to i64
  %656 = getelementptr inbounds float, ptr %596, i64 %655
  store float %651, ptr %656, align 4, !tbaa !31
  %657 = or disjoint i32 %654, 1
  %658 = zext i32 %657 to i64
  %659 = getelementptr inbounds float, ptr %596, i64 %658
  store float %653, ptr %659, align 4, !tbaa !31
  %indvars.iv.next489.prol = or disjoint i64 %indvars.iv488.ph, 1
  br label %scalar.ph529.prol.loopexit

scalar.ph529.prol.loopexit:                       ; preds = %scalar.ph529.prol, %scalar.ph529.preheader
  %indvars.iv488.unr = phi i64 [ %indvars.iv488.ph, %scalar.ph529.preheader ], [ %indvars.iv.next489.prol, %scalar.ph529.prol ]
  %660 = add nsw i64 %wide.trip.count491, -1
  %661 = icmp eq i64 %indvars.iv488.ph, %660
  br i1 %661, label %._crit_edge417, label %scalar.ph529

scalar.ph529:                                     ; preds = %scalar.ph529.prol.loopexit, %scalar.ph529
  %indvars.iv488 = phi i64 [ %indvars.iv.next489.1, %scalar.ph529 ], [ %indvars.iv488.unr, %scalar.ph529.prol.loopexit ]
  %662 = trunc nuw i64 %indvars.iv488 to i32
  %663 = add i32 %586, %662
  %664 = add i32 %587, %662
  %665 = zext i32 %664 to i64
  %666 = getelementptr inbounds float, ptr %591, i64 %665
  %667 = load float, ptr %666, align 4, !tbaa !31
  %668 = getelementptr inbounds float, ptr %593, i64 %665
  %669 = load float, ptr %668, align 4, !tbaa !31
  %670 = shl i32 %663, 1
  %671 = zext i32 %670 to i64
  %672 = getelementptr inbounds float, ptr %596, i64 %671
  store float %667, ptr %672, align 4, !tbaa !31
  %673 = or disjoint i32 %670, 1
  %674 = zext i32 %673 to i64
  %675 = getelementptr inbounds float, ptr %596, i64 %674
  store float %669, ptr %675, align 4, !tbaa !31
  %676 = trunc i64 %indvars.iv488 to i32
  %677 = add i32 %676, 1
  %678 = add i32 %586, %677
  %679 = add i32 %587, %677
  %680 = zext i32 %679 to i64
  %681 = getelementptr inbounds float, ptr %591, i64 %680
  %682 = load float, ptr %681, align 4, !tbaa !31
  %683 = getelementptr inbounds float, ptr %593, i64 %680
  %684 = load float, ptr %683, align 4, !tbaa !31
  %685 = shl i32 %678, 1
  %686 = zext i32 %685 to i64
  %687 = getelementptr inbounds float, ptr %596, i64 %686
  store float %682, ptr %687, align 4, !tbaa !31
  %688 = or disjoint i32 %685, 1
  %689 = zext i32 %688 to i64
  %690 = getelementptr inbounds float, ptr %596, i64 %689
  store float %684, ptr %690, align 4, !tbaa !31
  %indvars.iv.next489.1 = add nuw nsw i64 %indvars.iv488, 2
  %exitcond492.not.1 = icmp eq i64 %indvars.iv.next489.1, %wide.trip.count491
  br i1 %exitcond492.not.1, label %._crit_edge417, label %scalar.ph529, !llvm.loop !92

._crit_edge417:                                   ; preds = %scalar.ph529.prol.loopexit, %scalar.ph529, %middle.block528, %.preheader
  %691 = add i32 %.6353418, 1
  br label %692

692:                                              ; preds = %582, %._crit_edge417
  %.7 = phi i32 [ %691, %._crit_edge417 ], [ %.6353418, %582 ]
  %indvars.iv.next494 = add nuw nsw i64 %indvars.iv493, 1
  %exitcond497.not = icmp eq i64 %indvars.iv.next494, %wide.trip.count496
  br i1 %exitcond497.not, label %._crit_edge422, label %582, !llvm.loop !93

._crit_edge422:                                   ; preds = %692, %._crit_edge413
  %indvars.iv.next499 = add nuw nsw i64 %indvars.iv498, 1
  %693 = load i32, ptr %25, align 8, !tbaa !21
  %694 = zext i32 %693 to i64
  %695 = icmp ult i64 %indvars.iv.next499, %694
  br i1 %695, label %.preheader371, label %.loopexit373, !llvm.loop !94

.loopexit373:                                     ; preds = %._crit_edge422, %8, %.preheader372, %._crit_edge
  ret void
}

declare void @cmatrix_zero(ptr noundef) local_unnamed_addr #2

declare void @cmatrix_mul(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @cmatrix_hermitian(ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @cmatrix_copy_cmatrix(ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @cmatrix_scale(ptr noundef, ptr noundef, float noundef) local_unnamed_addr #2

declare void @cmatrix_add(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @cmatrix_sub(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.vector.reduce.add.v2i32(<2 x i32>) #3

attributes #0 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
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 = { "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 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { 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 = !{!"steer2demixing_gss_obj", !7, i64 0, !7, i64 4, !7, i64 8, !10, i64 12, !10, i64 16, !10, i64 20, !11, i64 24, !11, i64 32, !11, i64 40, !11, i64 48, !11, i64 56, !11, i64 64, !11, i64 72, !11, i64 80, !11, i64 88, !11, i64 96, !11, i64 104, !11, i64 112, !11, i64 120, !11, i64 128, !11, i64 136, !11, i64 144, !11, i64 152, !11, i64 160, !11, i64 168, !11, i64 176, !11, i64 184, !11, i64 192, !11, i64 200, !11, i64 208}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"float", !8, i64 0}
!11 = !{!"any pointer", !8, i64 0}
!12 = !{!13, !11, i64 8}
!13 = !{!"tracks_obj", !7, i64 0, !11, i64 8, !11, i64 16, !11, i64 24, !11, i64 32}
!14 = !{!15, !15, i64 0}
!15 = !{!"long long", !8, i64 0}
!16 = distinct !{!16, !17, !18, !19}
!17 = !{!"llvm.loop.mustprogress"}
!18 = !{!"llvm.loop.isvectorized", i32 1}
!19 = !{!"llvm.loop.unroll.runtime.disable"}
!20 = distinct !{!20, !17, !19, !18}
!21 = !{!6, !7, i64 8}
!22 = !{!6, !7, i64 4}
!23 = !{!24, !11, i64 8}
!24 = !{!"freqs_obj", !7, i64 0, !7, i64 4, !11, i64 8}
!25 = !{!6, !11, i64 24}
!26 = !{!27, !11, i64 0}
!27 = !{!"cmatrix_obj", !11, i64 0, !11, i64 8, !7, i64 16, !7, i64 20}
!28 = !{!27, !11, i64 8}
!29 = !{!6, !11, i64 32}
!30 = !{!11, !11, i64 0}
!31 = !{!10, !10, i64 0}
!32 = distinct !{!32, !17}
!33 = !{!6, !11, i64 88}
!34 = !{!35, !11, i64 16}
!35 = !{!"demixings_obj", !7, i64 0, !7, i64 4, !7, i64 8, !11, i64 16}
!36 = !{!37}
!37 = distinct !{!37, !38}
!38 = distinct !{!38, !"LVerDomain"}
!39 = !{!40, !41}
!40 = distinct !{!40, !38}
!41 = distinct !{!41, !38}
!42 = !{!40}
!43 = !{!41}
!44 = distinct !{!44, !17, !18, !19}
!45 = distinct !{!45, !17, !18}
!46 = !{!6, !10, i64 12}
!47 = !{!48, !11, i64 8}
!48 = !{!"masks_obj", !7, i64 0, !7, i64 4, !11, i64 8}
!49 = !{!8, !8, i64 0}
!50 = !{!51, !11, i64 16}
!51 = !{!"steers_obj", !7, i64 0, !7, i64 4, !7, i64 8, !11, i64 16}
!52 = distinct !{!52, !17}
!53 = distinct !{!53, !17}
!54 = distinct !{!54, !17}
!55 = !{!6, !11, i64 40}
!56 = !{!6, !11, i64 48}
!57 = !{!6, !11, i64 56}
!58 = !{!6, !11, i64 64}
!59 = distinct !{!59, !17}
!60 = distinct !{!60, !61}
!61 = !{!"llvm.loop.unroll.disable"}
!62 = !{!6, !11, i64 72}
!63 = !{!6, !11, i64 80}
!64 = distinct !{!64, !17}
!65 = distinct !{!65, !17}
!66 = !{!6, !11, i64 120}
!67 = !{!6, !11, i64 128}
!68 = !{!6, !11, i64 136}
!69 = !{!6, !11, i64 104}
!70 = !{!6, !11, i64 144}
!71 = !{!6, !11, i64 152}
!72 = distinct !{!72, !17}
!73 = distinct !{!73, !61}
!74 = !{!6, !11, i64 160}
!75 = !{!6, !11, i64 168}
!76 = !{!6, !11, i64 112}
!77 = distinct !{!77, !17}
!78 = !{!6, !11, i64 176}
!79 = !{!6, !11, i64 184}
!80 = !{!6, !11, i64 192}
!81 = !{!6, !10, i64 16}
!82 = !{!6, !11, i64 200}
!83 = !{!6, !10, i64 20}
!84 = !{!6, !11, i64 208}
!85 = !{!6, !11, i64 96}
!86 = !{!87}
!87 = distinct !{!87, !88}
!88 = distinct !{!88, !"LVerDomain"}
!89 = !{!90}
!90 = distinct !{!90, !88}
!91 = distinct !{!91, !17, !18, !19}
!92 = distinct !{!92, !17, !18}
!93 = distinct !{!93, !17}
!94 = distinct !{!94, !17}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalDCEPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopInstSimplifyPass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,PostOrderFunctionAttrsPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass