; LLVM IR from ggml-org/ggml :: src (ggml-quants)

; 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.block_q5_K = type { %union.anon.8, [12 x i8], [32 x i8], [128 x i8] }
%union.anon.8 = type { i32 }
%struct.anon.9 = type { i16, i16 }

@.str.1 = external hidden unnamed_addr constant [65 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [14 x i8], align 1
@__PRETTY_FUNCTION__.dequantize_row_q5_K = external hidden unnamed_addr constant [79 x i8], align 1

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #0

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden float @ggml_lookup_fp16_to_fp32(i16 noundef zeroext) #2

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @get_scale_min_k4(i32 noundef, ptr noalias noundef, ptr noalias noundef, ptr noalias noundef) #2

; Function Attrs: nounwind uwtable
define dso_local void @dequantize_row_q5_K(ptr noalias noundef %0, ptr noalias noundef %1, i64 noundef %2) #4 {
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca i64, align 8
  %7 = alloca i64, align 8
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca float, align 4
  %13 = alloca float, align 4
  %14 = alloca i32, align 4
  %15 = alloca i8, align 1
  %16 = alloca i8, align 1
  %17 = alloca i8, align 1
  %18 = alloca i8, align 1
  %19 = alloca i32, align 4
  %20 = alloca float, align 4
  %21 = alloca float, align 4
  %22 = alloca float, align 4
  %23 = alloca float, align 4
  %24 = alloca i32, align 4
  %25 = alloca i32, align 4
  store ptr %0, ptr %4, align 8, !tbaa !5
  store ptr %1, ptr %5, align 8, !tbaa !5
  store i64 %2, ptr %6, align 8, !tbaa !9
  %26 = load i64, ptr %6, align 8, !tbaa !9
  %27 = srem i64 %26, 256
  %28 = icmp eq i64 %27, 0
  br i1 %28, label %29, label %30

29:                                               ; preds = %3
  br label %31

30:                                               ; preds = %3
  call void @__assert_fail(ptr noundef @.str.4, ptr noundef @.str.1, i32 noundef 1483, ptr noundef @__PRETTY_FUNCTION__.dequantize_row_q5_K) #5
  unreachable

31:                                               ; preds = %29
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #6
  %32 = load i64, ptr %6, align 8, !tbaa !9
  %33 = sdiv i64 %32, 256
  store i64 %33, ptr %7, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #6
  store i32 0, ptr %8, align 4, !tbaa !11
  br label %34

34:                                               ; preds = %198, %31
  %35 = load i32, ptr %8, align 4, !tbaa !11
  %36 = sext i32 %35 to i64
  %37 = load i64, ptr %7, align 8, !tbaa !9
  %38 = icmp slt i64 %36, %37
  br i1 %38, label %40, label %39

39:                                               ; preds = %34
  store i32 2, ptr %9, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #6
  br label %201

40:                                               ; preds = %34
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #6
  %41 = load ptr, ptr %4, align 8, !tbaa !5
  %42 = load i32, ptr %8, align 4, !tbaa !11
  %43 = sext i32 %42 to i64
  %44 = getelementptr inbounds %struct.block_q5_K, ptr %41, i64 %43
  %45 = getelementptr inbounds %struct.block_q5_K, ptr %44, i32 0, i32 3
  %46 = getelementptr inbounds [128 x i8], ptr %45, i64 0, i64 0
  store ptr %46, ptr %10, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #6
  %47 = load ptr, ptr %4, align 8, !tbaa !5
  %48 = load i32, ptr %8, align 4, !tbaa !11
  %49 = sext i32 %48 to i64
  %50 = getelementptr inbounds %struct.block_q5_K, ptr %47, i64 %49
  %51 = getelementptr inbounds %struct.block_q5_K, ptr %50, i32 0, i32 2
  %52 = getelementptr inbounds [32 x i8], ptr %51, i64 0, i64 0
  store ptr %52, ptr %11, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #6
  %53 = load ptr, ptr %4, align 8, !tbaa !5
  %54 = load i32, ptr %8, align 4, !tbaa !11
  %55 = sext i32 %54 to i64
  %56 = getelementptr inbounds %struct.block_q5_K, ptr %53, i64 %55
  %57 = getelementptr inbounds %struct.block_q5_K, ptr %56, i32 0, i32 0
  %58 = getelementptr inbounds %struct.anon.9, ptr %57, i32 0, i32 0
  %59 = load i16, ptr %58, align 4, !tbaa !13
  %60 = call float @ggml_lookup_fp16_to_fp32(i16 noundef zeroext %59)
  store float %60, ptr %12, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #6
  %61 = load ptr, ptr %4, align 8, !tbaa !5
  %62 = load i32, ptr %8, align 4, !tbaa !11
  %63 = sext i32 %62 to i64
  %64 = getelementptr inbounds %struct.block_q5_K, ptr %61, i64 %63
  %65 = getelementptr inbounds %struct.block_q5_K, ptr %64, i32 0, i32 0
  %66 = getelementptr inbounds %struct.anon.9, ptr %65, i32 0, i32 1
  %67 = load i16, ptr %66, align 2, !tbaa !13
  %68 = call float @ggml_lookup_fp16_to_fp32(i16 noundef zeroext %67)
  store float %68, ptr %13, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #6
  store i32 0, ptr %14, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 1, ptr %15) #6
  call void @llvm.lifetime.start.p0(i64 1, ptr %16) #6
  call void @llvm.lifetime.start.p0(i64 1, ptr %17) #6
  store i8 1, ptr %17, align 1, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 1, ptr %18) #6
  store i8 2, ptr %18, align 1, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #6
  store i32 0, ptr %19, align 4, !tbaa !11
  br label %69

69:                                               ; preds = %194, %40
  %70 = load i32, ptr %19, align 4, !tbaa !11
  %71 = icmp slt i32 %70, 256
  br i1 %71, label %73, label %72

72:                                               ; preds = %69
  store i32 5, ptr %9, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #6
  br label %197

73:                                               ; preds = %69
  %74 = load i32, ptr %14, align 4, !tbaa !11
  %75 = add nsw i32 %74, 0
  %76 = load ptr, ptr %4, align 8, !tbaa !5
  %77 = load i32, ptr %8, align 4, !tbaa !11
  %78 = sext i32 %77 to i64
  %79 = getelementptr inbounds %struct.block_q5_K, ptr %76, i64 %78
  %80 = getelementptr inbounds %struct.block_q5_K, ptr %79, i32 0, i32 1
  %81 = getelementptr inbounds [12 x i8], ptr %80, i64 0, i64 0
  call void @get_scale_min_k4(i32 noundef %75, ptr noundef %81, ptr noundef %15, ptr noundef %16)
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #6
  %82 = load float, ptr %12, align 4, !tbaa !14
  %83 = load i8, ptr %15, align 1, !tbaa !13
  %84 = zext i8 %83 to i32
  %85 = sitofp i32 %84 to float
  %86 = fmul float %82, %85
  store float %86, ptr %20, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #6
  %87 = load float, ptr %13, align 4, !tbaa !14
  %88 = load i8, ptr %16, align 1, !tbaa !13
  %89 = zext i8 %88 to i32
  %90 = sitofp i32 %89 to float
  %91 = fmul float %87, %90
  store float %91, ptr %21, align 4, !tbaa !14
  %92 = load i32, ptr %14, align 4, !tbaa !11
  %93 = add nsw i32 %92, 1
  %94 = load ptr, ptr %4, align 8, !tbaa !5
  %95 = load i32, ptr %8, align 4, !tbaa !11
  %96 = sext i32 %95 to i64
  %97 = getelementptr inbounds %struct.block_q5_K, ptr %94, i64 %96
  %98 = getelementptr inbounds %struct.block_q5_K, ptr %97, i32 0, i32 1
  %99 = getelementptr inbounds [12 x i8], ptr %98, i64 0, i64 0
  call void @get_scale_min_k4(i32 noundef %93, ptr noundef %99, ptr noundef %15, ptr noundef %16)
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #6
  %100 = load float, ptr %12, align 4, !tbaa !14
  %101 = load i8, ptr %15, align 1, !tbaa !13
  %102 = zext i8 %101 to i32
  %103 = sitofp i32 %102 to float
  %104 = fmul float %100, %103
  store float %104, ptr %22, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #6
  %105 = load float, ptr %13, align 4, !tbaa !14
  %106 = load i8, ptr %16, align 1, !tbaa !13
  %107 = zext i8 %106 to i32
  %108 = sitofp i32 %107 to float
  %109 = fmul float %105, %108
  store float %109, ptr %23, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #6
  store i32 0, ptr %24, align 4, !tbaa !11
  br label %110

110:                                              ; preds = %142, %73
  %111 = load i32, ptr %24, align 4, !tbaa !11
  %112 = icmp slt i32 %111, 32
  br i1 %112, label %114, label %113

113:                                              ; preds = %110
  store i32 8, ptr %9, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #6
  br label %145

114:                                              ; preds = %110
  %115 = load float, ptr %20, align 4, !tbaa !14
  %116 = load ptr, ptr %10, align 8, !tbaa !5
  %117 = load i32, ptr %24, align 4, !tbaa !11
  %118 = sext i32 %117 to i64
  %119 = getelementptr inbounds i8, ptr %116, i64 %118
  %120 = load i8, ptr %119, align 1, !tbaa !13
  %121 = zext i8 %120 to i32
  %122 = and i32 %121, 15
  %123 = load ptr, ptr %11, align 8, !tbaa !5
  %124 = load i32, ptr %24, align 4, !tbaa !11
  %125 = sext i32 %124 to i64
  %126 = getelementptr inbounds i8, ptr %123, i64 %125
  %127 = load i8, ptr %126, align 1, !tbaa !13
  %128 = zext i8 %127 to i32
  %129 = load i8, ptr %17, align 1, !tbaa !13
  %130 = zext i8 %129 to i32
  %131 = and i32 %128, %130
  %132 = icmp ne i32 %131, 0
  %133 = zext i1 %132 to i64
  %134 = select i1 %132, i32 16, i32 0
  %135 = add nsw i32 %122, %134
  %136 = sitofp i32 %135 to float
  %137 = load float, ptr %21, align 4, !tbaa !14
  %138 = fneg float %137
  %139 = call float @llvm.fmuladd.f32(float %115, float %136, float %138)
  %140 = load ptr, ptr %5, align 8, !tbaa !5
  %141 = getelementptr inbounds float, ptr %140, i32 1
  store ptr %141, ptr %5, align 8, !tbaa !5
  store float %139, ptr %140, align 4, !tbaa !14
  br label %142

142:                                              ; preds = %114
  %143 = load i32, ptr %24, align 4, !tbaa !11
  %144 = add nsw i32 %143, 1
  store i32 %144, ptr %24, align 4, !tbaa !11
  br label %110, !llvm.loop !16

145:                                              ; preds = %113
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #6
  store i32 0, ptr %25, align 4, !tbaa !11
  br label %146

146:                                              ; preds = %178, %145
  %147 = load i32, ptr %25, align 4, !tbaa !11
  %148 = icmp slt i32 %147, 32
  br i1 %148, label %150, label %149

149:                                              ; preds = %146
  store i32 11, ptr %9, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #6
  br label %181

150:                                              ; preds = %146
  %151 = load float, ptr %22, align 4, !tbaa !14
  %152 = load ptr, ptr %10, align 8, !tbaa !5
  %153 = load i32, ptr %25, align 4, !tbaa !11
  %154 = sext i32 %153 to i64
  %155 = getelementptr inbounds i8, ptr %152, i64 %154
  %156 = load i8, ptr %155, align 1, !tbaa !13
  %157 = zext i8 %156 to i32
  %158 = ashr i32 %157, 4
  %159 = load ptr, ptr %11, align 8, !tbaa !5
  %160 = load i32, ptr %25, align 4, !tbaa !11
  %161 = sext i32 %160 to i64
  %162 = getelementptr inbounds i8, ptr %159, i64 %161
  %163 = load i8, ptr %162, align 1, !tbaa !13
  %164 = zext i8 %163 to i32
  %165 = load i8, ptr %18, align 1, !tbaa !13
  %166 = zext i8 %165 to i32
  %167 = and i32 %164, %166
  %168 = icmp ne i32 %167, 0
  %169 = zext i1 %168 to i64
  %170 = select i1 %168, i32 16, i32 0
  %171 = add nsw i32 %158, %170
  %172 = sitofp i32 %171 to float
  %173 = load float, ptr %23, align 4, !tbaa !14
  %174 = fneg float %173
  %175 = call float @llvm.fmuladd.f32(float %151, float %172, float %174)
  %176 = load ptr, ptr %5, align 8, !tbaa !5
  %177 = getelementptr inbounds float, ptr %176, i32 1
  store ptr %177, ptr %5, align 8, !tbaa !5
  store float %175, ptr %176, align 4, !tbaa !14
  br label %178

178:                                              ; preds = %150
  %179 = load i32, ptr %25, align 4, !tbaa !11
  %180 = add nsw i32 %179, 1
  store i32 %180, ptr %25, align 4, !tbaa !11
  br label %146, !llvm.loop !18

181:                                              ; preds = %149
  %182 = load ptr, ptr %10, align 8, !tbaa !5
  %183 = getelementptr inbounds i8, ptr %182, i64 32
  store ptr %183, ptr %10, align 8, !tbaa !5
  %184 = load i32, ptr %14, align 4, !tbaa !11
  %185 = add nsw i32 %184, 2
  store i32 %185, ptr %14, align 4, !tbaa !11
  %186 = load i8, ptr %17, align 1, !tbaa !13
  %187 = zext i8 %186 to i32
  %188 = shl i32 %187, 2
  %189 = trunc i32 %188 to i8
  store i8 %189, ptr %17, align 1, !tbaa !13
  %190 = load i8, ptr %18, align 1, !tbaa !13
  %191 = zext i8 %190 to i32
  %192 = shl i32 %191, 2
  %193 = trunc i32 %192 to i8
  store i8 %193, ptr %18, align 1, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #6
  br label %194

194:                                              ; preds = %181
  %195 = load i32, ptr %19, align 4, !tbaa !11
  %196 = add nsw i32 %195, 64
  store i32 %196, ptr %19, align 4, !tbaa !11
  br label %69, !llvm.loop !19

197:                                              ; preds = %72
  call void @llvm.lifetime.end.p0(i64 1, ptr %18) #6
  call void @llvm.lifetime.end.p0(i64 1, ptr %17) #6
  call void @llvm.lifetime.end.p0(i64 1, ptr %16) #6
  call void @llvm.lifetime.end.p0(i64 1, ptr %15) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #6
  br label %198

198:                                              ; preds = %197
  %199 = load i32, ptr %8, align 4, !tbaa !11
  %200 = add nsw i32 %199, 1
  store i32 %200, ptr %8, align 4, !tbaa !11
  br label %34, !llvm.loop !20

201:                                              ; preds = %39
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #6
  ret void
}

attributes #0 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { inlinehint 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 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { 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 #5 = { noreturn nounwind }
attributes #6 = { 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 = !{!"long", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"int", !7, i64 0}
!13 = !{!7, !7, i64 0}
!14 = !{!15, !15, i64 0}
!15 = !{!"float", !7, i64 0}
!16 = distinct !{!16, !17}
!17 = !{!"llvm.loop.mustprogress"}
!18 = distinct !{!18, !17}
!19 = distinct !{!19, !17}
!20 = distinct !{!20, !17}


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

%struct.block_q5_K = type { %union.anon.8, [12 x i8], [32 x i8], [128 x i8] }
%union.anon.8 = type { i32 }

@.str.1 = external hidden unnamed_addr constant [65 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [14 x i8], align 1
@__PRETTY_FUNCTION__.dequantize_row_q5_K = external hidden unnamed_addr constant [79 x i8], align 1

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) local_unnamed_addr #0

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden float @ggml_lookup_fp16_to_fp32(i16 noundef zeroext) local_unnamed_addr #2

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @get_scale_min_k4(i32 noundef, ptr noalias noundef, ptr noalias noundef, ptr noalias noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
define dso_local void @dequantize_row_q5_K(ptr noalias noundef %0, ptr noalias nocapture noundef writeonly %1, i64 noundef %2) local_unnamed_addr #4 {
  %4 = alloca i8, align 1
  %5 = alloca i8, align 1
  %6 = and i64 %2, 255
  %7 = icmp eq i64 %6, 0
  br i1 %7, label %9, label %8

8:                                                ; preds = %3
  tail call void @__assert_fail(ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.1, i32 noundef 1483, ptr noundef nonnull @__PRETTY_FUNCTION__.dequantize_row_q5_K) #6
  unreachable

9:                                                ; preds = %3
  %10 = ashr exact i64 %2, 8
  %11 = icmp sgt i64 %10, 0
  br i1 %11, label %.lr.ph.preheader, label %._crit_edge

.lr.ph.preheader:                                 ; preds = %9
  %scevgep94 = getelementptr i8, ptr %0, i64 16
  %12 = mul nuw nsw i64 %10, 176
  %scevgep95 = getelementptr i8, ptr %0, i64 %12
  %13 = mul nuw nsw i64 %10, 176
  %scevgep111 = getelementptr i8, ptr %0, i64 %13
  %14 = mul nuw nsw i64 %10, 176
  %15 = getelementptr i8, ptr %0, i64 %14
  %scevgep142 = getelementptr i8, ptr %15, i64 -32
  %scevgep172 = getelementptr i8, ptr %0, i64 16
  %16 = mul nuw nsw i64 %10, 176
  %17 = getelementptr i8, ptr %0, i64 %16
  %scevgep173 = getelementptr i8, ptr %17, i64 -32
  %18 = mul nuw nsw i64 %10, 176
  %19 = getelementptr i8, ptr %0, i64 %18
  %scevgep202 = getelementptr i8, ptr %19, i64 -64
  %scevgep230 = getelementptr i8, ptr %0, i64 16
  %20 = mul nuw nsw i64 %10, 176
  %21 = getelementptr i8, ptr %0, i64 %20
  %scevgep231 = getelementptr i8, ptr %21, i64 -64
  %22 = mul nuw nsw i64 %10, 176
  %23 = getelementptr i8, ptr %0, i64 %22
  %scevgep258 = getelementptr i8, ptr %23, i64 -96
  %scevgep284 = getelementptr i8, ptr %0, i64 16
  %24 = mul nuw nsw i64 %10, 176
  %25 = getelementptr i8, ptr %0, i64 %24
  %scevgep285 = getelementptr i8, ptr %25, i64 -96
  br label %.lr.ph

._crit_edge:                                      ; preds = %middle.block, %9
  ret void

.lr.ph:                                           ; preds = %.lr.ph.preheader, %middle.block
  %indvars.iv76 = phi i64 [ %indvars.iv.next77, %middle.block ], [ 0, %.lr.ph.preheader ]
  %.04969 = phi ptr [ %.lcssa93, %middle.block ], [ %1, %.lr.ph.preheader ]
  %26 = getelementptr inbounds %struct.block_q5_K, ptr %0, i64 %indvars.iv76
  %27 = getelementptr inbounds i8, ptr %26, i64 48
  %28 = getelementptr inbounds i8, ptr %26, i64 16
  %29 = load i16, ptr %26, align 4, !tbaa !5
  %30 = call float @ggml_lookup_fp16_to_fp32(i16 noundef zeroext %29)
  %31 = getelementptr inbounds i8, ptr %26, i64 2
  %32 = load i16, ptr %31, align 2, !tbaa !5
  %33 = call float @ggml_lookup_fp16_to_fp32(i16 noundef zeroext %32)
  call void @llvm.lifetime.start.p0(i64 1, ptr nonnull %4) #7
  call void @llvm.lifetime.start.p0(i64 1, ptr nonnull %5) #7
  %34 = getelementptr inbounds i8, ptr %26, i64 4
  %35 = fneg float %33
  call void @get_scale_min_k4(i32 noundef 0, ptr noundef nonnull %34, ptr noundef nonnull %4, ptr noundef nonnull %5)
  %36 = load i8, ptr %4, align 1, !tbaa !5
  %37 = uitofp i8 %36 to float
  %38 = fmul float %30, %37
  %39 = load i8, ptr %5, align 1, !tbaa !5
  %40 = uitofp i8 %39 to float
  call void @get_scale_min_k4(i32 noundef 1, ptr noundef nonnull %34, ptr noundef nonnull %4, ptr noundef nonnull %5)
  %41 = load i8, ptr %4, align 1, !tbaa !5
  %42 = load i8, ptr %5, align 1, !tbaa !5
  %43 = fmul float %35, %40
  %scevgep283 = getelementptr i8, ptr %.04969, i64 128
  %bound0286 = icmp ult ptr %.04969, %scevgep285
  %bound1287 = icmp ult ptr %scevgep284, %scevgep283
  %found.conflict288 = and i1 %bound0286, %bound1287
  br i1 %found.conflict288, label %scalar.ph290, label %vector.body295

vector.body295:                                   ; preds = %.lr.ph
  %broadcast.splatinsert306 = insertelement <4 x float> poison, float %43, i64 0
  %broadcast.splat307 = shufflevector <4 x float> %broadcast.splatinsert306, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert304 = insertelement <4 x float> poison, float %38, i64 0
  %broadcast.splat305 = shufflevector <4 x float> %broadcast.splatinsert304, <4 x float> poison, <4 x i32> zeroinitializer
  %ind.end293 = getelementptr i8, ptr %.04969, i64 128
  %44 = getelementptr inbounds i8, ptr %26, i64 52
  %wide.load300 = load <4 x i8>, ptr %27, align 1, !tbaa !5, !alias.scope !8
  %wide.load301 = load <4 x i8>, ptr %44, align 1, !tbaa !5, !alias.scope !8
  %45 = and <4 x i8> %wide.load300, <i8 15, i8 15, i8 15, i8 15>
  %46 = and <4 x i8> %wide.load301, <i8 15, i8 15, i8 15, i8 15>
  %47 = getelementptr inbounds i8, ptr %26, i64 20
  %wide.load302 = load <4 x i8>, ptr %28, align 1, !tbaa !5, !alias.scope !8
  %wide.load303 = load <4 x i8>, ptr %47, align 1, !tbaa !5, !alias.scope !8
  %48 = shl <4 x i8> %wide.load302, <i8 4, i8 4, i8 4, i8 4>
  %49 = shl <4 x i8> %wide.load303, <i8 4, i8 4, i8 4, i8 4>
  %50 = and <4 x i8> %48, <i8 16, i8 16, i8 16, i8 16>
  %51 = and <4 x i8> %49, <i8 16, i8 16, i8 16, i8 16>
  %52 = or disjoint <4 x i8> %50, %45
  %53 = or disjoint <4 x i8> %51, %46
  %54 = uitofp nneg <4 x i8> %52 to <4 x float>
  %55 = uitofp nneg <4 x i8> %53 to <4 x float>
  %56 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat305, <4 x float> %54, <4 x float> %broadcast.splat307)
  %57 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat305, <4 x float> %55, <4 x float> %broadcast.splat307)
  %58 = getelementptr i8, ptr %.04969, i64 16
  store <4 x float> %56, ptr %.04969, align 4, !tbaa !11, !alias.scope !13, !noalias !8
  store <4 x float> %57, ptr %58, align 4, !tbaa !11, !alias.scope !13, !noalias !8
  %next.gep298.1 = getelementptr i8, ptr %.04969, i64 32
  %59 = getelementptr inbounds i8, ptr %26, i64 56
  %60 = getelementptr inbounds i8, ptr %26, i64 60
  %wide.load300.1 = load <4 x i8>, ptr %59, align 1, !tbaa !5, !alias.scope !8
  %wide.load301.1 = load <4 x i8>, ptr %60, align 1, !tbaa !5, !alias.scope !8
  %61 = and <4 x i8> %wide.load300.1, <i8 15, i8 15, i8 15, i8 15>
  %62 = and <4 x i8> %wide.load301.1, <i8 15, i8 15, i8 15, i8 15>
  %63 = getelementptr inbounds i8, ptr %26, i64 24
  %64 = getelementptr inbounds i8, ptr %26, i64 28
  %wide.load302.1 = load <4 x i8>, ptr %63, align 1, !tbaa !5, !alias.scope !8
  %wide.load303.1 = load <4 x i8>, ptr %64, align 1, !tbaa !5, !alias.scope !8
  %65 = shl <4 x i8> %wide.load302.1, <i8 4, i8 4, i8 4, i8 4>
  %66 = shl <4 x i8> %wide.load303.1, <i8 4, i8 4, i8 4, i8 4>
  %67 = and <4 x i8> %65, <i8 16, i8 16, i8 16, i8 16>
  %68 = and <4 x i8> %66, <i8 16, i8 16, i8 16, i8 16>
  %69 = or disjoint <4 x i8> %67, %61
  %70 = or disjoint <4 x i8> %68, %62
  %71 = uitofp nneg <4 x i8> %69 to <4 x float>
  %72 = uitofp nneg <4 x i8> %70 to <4 x float>
  %73 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat305, <4 x float> %71, <4 x float> %broadcast.splat307)
  %74 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat305, <4 x float> %72, <4 x float> %broadcast.splat307)
  %75 = getelementptr i8, ptr %.04969, i64 48
  store <4 x float> %73, ptr %next.gep298.1, align 4, !tbaa !11, !alias.scope !13, !noalias !8
  store <4 x float> %74, ptr %75, align 4, !tbaa !11, !alias.scope !13, !noalias !8
  %next.gep298.2 = getelementptr i8, ptr %.04969, i64 64
  %76 = getelementptr inbounds i8, ptr %26, i64 64
  %77 = getelementptr inbounds i8, ptr %26, i64 68
  %wide.load300.2 = load <4 x i8>, ptr %76, align 1, !tbaa !5, !alias.scope !8
  %wide.load301.2 = load <4 x i8>, ptr %77, align 1, !tbaa !5, !alias.scope !8
  %78 = and <4 x i8> %wide.load300.2, <i8 15, i8 15, i8 15, i8 15>
  %79 = and <4 x i8> %wide.load301.2, <i8 15, i8 15, i8 15, i8 15>
  %80 = getelementptr inbounds i8, ptr %26, i64 32
  %81 = getelementptr inbounds i8, ptr %26, i64 36
  %wide.load302.2 = load <4 x i8>, ptr %80, align 1, !tbaa !5, !alias.scope !8
  %wide.load303.2 = load <4 x i8>, ptr %81, align 1, !tbaa !5, !alias.scope !8
  %82 = shl <4 x i8> %wide.load302.2, <i8 4, i8 4, i8 4, i8 4>
  %83 = shl <4 x i8> %wide.load303.2, <i8 4, i8 4, i8 4, i8 4>
  %84 = and <4 x i8> %82, <i8 16, i8 16, i8 16, i8 16>
  %85 = and <4 x i8> %83, <i8 16, i8 16, i8 16, i8 16>
  %86 = or disjoint <4 x i8> %84, %78
  %87 = or disjoint <4 x i8> %85, %79
  %88 = uitofp nneg <4 x i8> %86 to <4 x float>
  %89 = uitofp nneg <4 x i8> %87 to <4 x float>
  %90 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat305, <4 x float> %88, <4 x float> %broadcast.splat307)
  %91 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat305, <4 x float> %89, <4 x float> %broadcast.splat307)
  %92 = getelementptr i8, ptr %.04969, i64 80
  store <4 x float> %90, ptr %next.gep298.2, align 4, !tbaa !11, !alias.scope !13, !noalias !8
  store <4 x float> %91, ptr %92, align 4, !tbaa !11, !alias.scope !13, !noalias !8
  %next.gep298.3 = getelementptr i8, ptr %.04969, i64 96
  %93 = getelementptr inbounds i8, ptr %26, i64 72
  %94 = getelementptr inbounds i8, ptr %26, i64 76
  %wide.load300.3 = load <4 x i8>, ptr %93, align 1, !tbaa !5, !alias.scope !8
  %wide.load301.3 = load <4 x i8>, ptr %94, align 1, !tbaa !5, !alias.scope !8
  %95 = and <4 x i8> %wide.load300.3, <i8 15, i8 15, i8 15, i8 15>
  %96 = and <4 x i8> %wide.load301.3, <i8 15, i8 15, i8 15, i8 15>
  %97 = getelementptr inbounds i8, ptr %26, i64 40
  %98 = getelementptr inbounds i8, ptr %26, i64 44
  %wide.load302.3 = load <4 x i8>, ptr %97, align 1, !tbaa !5, !alias.scope !8
  %wide.load303.3 = load <4 x i8>, ptr %98, align 1, !tbaa !5, !alias.scope !8
  %99 = shl <4 x i8> %wide.load302.3, <i8 4, i8 4, i8 4, i8 4>
  %100 = shl <4 x i8> %wide.load303.3, <i8 4, i8 4, i8 4, i8 4>
  %101 = and <4 x i8> %99, <i8 16, i8 16, i8 16, i8 16>
  %102 = and <4 x i8> %100, <i8 16, i8 16, i8 16, i8 16>
  %103 = or disjoint <4 x i8> %101, %95
  %104 = or disjoint <4 x i8> %102, %96
  %105 = uitofp nneg <4 x i8> %103 to <4 x float>
  %106 = uitofp nneg <4 x i8> %104 to <4 x float>
  %107 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat305, <4 x float> %105, <4 x float> %broadcast.splat307)
  %108 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat305, <4 x float> %106, <4 x float> %broadcast.splat307)
  %109 = getelementptr i8, ptr %.04969, i64 112
  store <4 x float> %107, ptr %next.gep298.3, align 4, !tbaa !11, !alias.scope !13, !noalias !8
  store <4 x float> %108, ptr %109, align 4, !tbaa !11, !alias.scope !13, !noalias !8
  br label %.preheader

.preheader:                                       ; preds = %scalar.ph290, %vector.body295
  %indvars.iv.lcssa = phi i64 [ 31, %vector.body295 ], [ %indvars.iv.next, %scalar.ph290 ]
  %.lcssa = phi ptr [ %ind.end293, %vector.body295 ], [ %203, %scalar.ph290 ]
  %110 = uitofp i8 %41 to float
  %111 = fmul float %30, %110
  %112 = uitofp i8 %42 to float
  %113 = fmul float %35, %112
  %114 = shl nuw nsw i64 %indvars.iv.lcssa, 2
  %115 = add nuw i64 %114, 132
  %scevgep257 = getelementptr i8, ptr %.04969, i64 %115
  %bound0259 = icmp ult ptr %.lcssa, %scevgep258
  %bound1260 = icmp ult ptr %scevgep230, %scevgep257
  %found.conflict261 = and i1 %bound0259, %bound1260
  br i1 %found.conflict261, label %scalar.ph263, label %vector.body268

vector.body268:                                   ; preds = %.preheader
  %broadcast.splatinsert279 = insertelement <4 x float> poison, float %113, i64 0
  %broadcast.splat280 = shufflevector <4 x float> %broadcast.splatinsert279, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert277 = insertelement <4 x float> poison, float %111, i64 0
  %broadcast.splat278 = shufflevector <4 x float> %broadcast.splatinsert277, <4 x float> poison, <4 x i32> zeroinitializer
  %ind.end266 = getelementptr i8, ptr %.lcssa, i64 128
  %116 = getelementptr inbounds i8, ptr %26, i64 52
  %wide.load273 = load <4 x i8>, ptr %27, align 1, !tbaa !5, !alias.scope !15
  %wide.load274 = load <4 x i8>, ptr %116, align 1, !tbaa !5, !alias.scope !15
  %117 = lshr <4 x i8> %wide.load273, <i8 4, i8 4, i8 4, i8 4>
  %118 = lshr <4 x i8> %wide.load274, <i8 4, i8 4, i8 4, i8 4>
  %119 = getelementptr inbounds i8, ptr %26, i64 20
  %wide.load275 = load <4 x i8>, ptr %28, align 1, !tbaa !5, !alias.scope !15
  %wide.load276 = load <4 x i8>, ptr %119, align 1, !tbaa !5, !alias.scope !15
  %120 = shl <4 x i8> %wide.load275, <i8 3, i8 3, i8 3, i8 3>
  %121 = shl <4 x i8> %wide.load276, <i8 3, i8 3, i8 3, i8 3>
  %122 = and <4 x i8> %120, <i8 16, i8 16, i8 16, i8 16>
  %123 = and <4 x i8> %121, <i8 16, i8 16, i8 16, i8 16>
  %124 = or disjoint <4 x i8> %122, %117
  %125 = or disjoint <4 x i8> %123, %118
  %126 = uitofp nneg <4 x i8> %124 to <4 x float>
  %127 = uitofp nneg <4 x i8> %125 to <4 x float>
  %128 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat278, <4 x float> %126, <4 x float> %broadcast.splat280)
  %129 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat278, <4 x float> %127, <4 x float> %broadcast.splat280)
  %130 = getelementptr i8, ptr %.lcssa, i64 16
  store <4 x float> %128, ptr %.lcssa, align 4, !tbaa !11, !alias.scope !18, !noalias !15
  store <4 x float> %129, ptr %130, align 4, !tbaa !11, !alias.scope !18, !noalias !15
  %next.gep271.1 = getelementptr i8, ptr %.lcssa, i64 32
  %131 = getelementptr inbounds i8, ptr %26, i64 56
  %132 = getelementptr inbounds i8, ptr %26, i64 60
  %wide.load273.1 = load <4 x i8>, ptr %131, align 1, !tbaa !5, !alias.scope !15
  %wide.load274.1 = load <4 x i8>, ptr %132, align 1, !tbaa !5, !alias.scope !15
  %133 = lshr <4 x i8> %wide.load273.1, <i8 4, i8 4, i8 4, i8 4>
  %134 = lshr <4 x i8> %wide.load274.1, <i8 4, i8 4, i8 4, i8 4>
  %135 = getelementptr inbounds i8, ptr %26, i64 24
  %136 = getelementptr inbounds i8, ptr %26, i64 28
  %wide.load275.1 = load <4 x i8>, ptr %135, align 1, !tbaa !5, !alias.scope !15
  %wide.load276.1 = load <4 x i8>, ptr %136, align 1, !tbaa !5, !alias.scope !15
  %137 = shl <4 x i8> %wide.load275.1, <i8 3, i8 3, i8 3, i8 3>
  %138 = shl <4 x i8> %wide.load276.1, <i8 3, i8 3, i8 3, i8 3>
  %139 = and <4 x i8> %137, <i8 16, i8 16, i8 16, i8 16>
  %140 = and <4 x i8> %138, <i8 16, i8 16, i8 16, i8 16>
  %141 = or disjoint <4 x i8> %139, %133
  %142 = or disjoint <4 x i8> %140, %134
  %143 = uitofp nneg <4 x i8> %141 to <4 x float>
  %144 = uitofp nneg <4 x i8> %142 to <4 x float>
  %145 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat278, <4 x float> %143, <4 x float> %broadcast.splat280)
  %146 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat278, <4 x float> %144, <4 x float> %broadcast.splat280)
  %147 = getelementptr i8, ptr %.lcssa, i64 48
  store <4 x float> %145, ptr %next.gep271.1, align 4, !tbaa !11, !alias.scope !18, !noalias !15
  store <4 x float> %146, ptr %147, align 4, !tbaa !11, !alias.scope !18, !noalias !15
  %next.gep271.2 = getelementptr i8, ptr %.lcssa, i64 64
  %148 = getelementptr inbounds i8, ptr %26, i64 64
  %149 = getelementptr inbounds i8, ptr %26, i64 68
  %wide.load273.2 = load <4 x i8>, ptr %148, align 1, !tbaa !5, !alias.scope !15
  %wide.load274.2 = load <4 x i8>, ptr %149, align 1, !tbaa !5, !alias.scope !15
  %150 = lshr <4 x i8> %wide.load273.2, <i8 4, i8 4, i8 4, i8 4>
  %151 = lshr <4 x i8> %wide.load274.2, <i8 4, i8 4, i8 4, i8 4>
  %152 = getelementptr inbounds i8, ptr %26, i64 32
  %153 = getelementptr inbounds i8, ptr %26, i64 36
  %wide.load275.2 = load <4 x i8>, ptr %152, align 1, !tbaa !5, !alias.scope !15
  %wide.load276.2 = load <4 x i8>, ptr %153, align 1, !tbaa !5, !alias.scope !15
  %154 = shl <4 x i8> %wide.load275.2, <i8 3, i8 3, i8 3, i8 3>
  %155 = shl <4 x i8> %wide.load276.2, <i8 3, i8 3, i8 3, i8 3>
  %156 = and <4 x i8> %154, <i8 16, i8 16, i8 16, i8 16>
  %157 = and <4 x i8> %155, <i8 16, i8 16, i8 16, i8 16>
  %158 = or disjoint <4 x i8> %156, %150
  %159 = or disjoint <4 x i8> %157, %151
  %160 = uitofp nneg <4 x i8> %158 to <4 x float>
  %161 = uitofp nneg <4 x i8> %159 to <4 x float>
  %162 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat278, <4 x float> %160, <4 x float> %broadcast.splat280)
  %163 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat278, <4 x float> %161, <4 x float> %broadcast.splat280)
  %164 = getelementptr i8, ptr %.lcssa, i64 80
  store <4 x float> %162, ptr %next.gep271.2, align 4, !tbaa !11, !alias.scope !18, !noalias !15
  store <4 x float> %163, ptr %164, align 4, !tbaa !11, !alias.scope !18, !noalias !15
  %next.gep271.3 = getelementptr i8, ptr %.lcssa, i64 96
  %165 = getelementptr inbounds i8, ptr %26, i64 72
  %166 = getelementptr inbounds i8, ptr %26, i64 76
  %wide.load273.3 = load <4 x i8>, ptr %165, align 1, !tbaa !5, !alias.scope !15
  %wide.load274.3 = load <4 x i8>, ptr %166, align 1, !tbaa !5, !alias.scope !15
  %167 = lshr <4 x i8> %wide.load273.3, <i8 4, i8 4, i8 4, i8 4>
  %168 = lshr <4 x i8> %wide.load274.3, <i8 4, i8 4, i8 4, i8 4>
  %169 = getelementptr inbounds i8, ptr %26, i64 40
  %170 = getelementptr inbounds i8, ptr %26, i64 44
  %wide.load275.3 = load <4 x i8>, ptr %169, align 1, !tbaa !5, !alias.scope !15
  %wide.load276.3 = load <4 x i8>, ptr %170, align 1, !tbaa !5, !alias.scope !15
  %171 = shl <4 x i8> %wide.load275.3, <i8 3, i8 3, i8 3, i8 3>
  %172 = shl <4 x i8> %wide.load276.3, <i8 3, i8 3, i8 3, i8 3>
  %173 = and <4 x i8> %171, <i8 16, i8 16, i8 16, i8 16>
  %174 = and <4 x i8> %172, <i8 16, i8 16, i8 16, i8 16>
  %175 = or disjoint <4 x i8> %173, %167
  %176 = or disjoint <4 x i8> %174, %168
  %177 = uitofp nneg <4 x i8> %175 to <4 x float>
  %178 = uitofp nneg <4 x i8> %176 to <4 x float>
  %179 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat278, <4 x float> %177, <4 x float> %broadcast.splat280)
  %180 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat278, <4 x float> %178, <4 x float> %broadcast.splat280)
  %181 = getelementptr i8, ptr %.lcssa, i64 112
  store <4 x float> %179, ptr %next.gep271.3, align 4, !tbaa !11, !alias.scope !18, !noalias !15
  store <4 x float> %180, ptr %181, align 4, !tbaa !11, !alias.scope !18, !noalias !15
  br label %middle.block262

scalar.ph290:                                     ; preds = %.lr.ph, %scalar.ph290
  %indvars.iv = phi i64 [ %indvars.iv.next.1337, %scalar.ph290 ], [ 0, %.lr.ph ]
  %.258 = phi ptr [ %203, %scalar.ph290 ], [ %.04969, %.lr.ph ]
  %182 = getelementptr inbounds i8, ptr %27, i64 %indvars.iv
  %183 = load i8, ptr %182, align 1, !tbaa !5
  %184 = and i8 %183, 15
  %185 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv
  %186 = load i8, ptr %185, align 1, !tbaa !5
  %187 = shl i8 %186, 4
  %188 = and i8 %187, 16
  %189 = or disjoint i8 %188, %184
  %190 = uitofp nneg i8 %189 to float
  %191 = call float @llvm.fmuladd.f32(float %38, float %190, float %43)
  %192 = getelementptr i8, ptr %.258, i64 4
  store float %191, ptr %.258, align 4, !tbaa !11
  %indvars.iv.next = or disjoint i64 %indvars.iv, 1
  %193 = getelementptr inbounds i8, ptr %27, i64 %indvars.iv.next
  %194 = load i8, ptr %193, align 1, !tbaa !5
  %195 = and i8 %194, 15
  %196 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv.next
  %197 = load i8, ptr %196, align 1, !tbaa !5
  %198 = shl i8 %197, 4
  %199 = and i8 %198, 16
  %200 = or disjoint i8 %199, %195
  %201 = uitofp nneg i8 %200 to float
  %202 = call float @llvm.fmuladd.f32(float %38, float %201, float %43)
  %203 = getelementptr i8, ptr %.258, i64 8
  store float %202, ptr %192, align 4, !tbaa !11
  %indvars.iv.next.1337 = add nuw nsw i64 %indvars.iv, 2
  %exitcond.not.1 = icmp eq i64 %indvars.iv.next.1337, 32
  br i1 %exitcond.not.1, label %.preheader, label %scalar.ph290, !llvm.loop !20

middle.block262:                                  ; preds = %scalar.ph263, %vector.body268
  %indvars.iv72.lcssa = phi i64 [ 31, %vector.body268 ], [ %indvars.iv.next73, %scalar.ph263 ]
  %.lcssa87 = phi ptr [ %ind.end266, %vector.body268 ], [ %815, %scalar.ph263 ]
  %204 = getelementptr inbounds i8, ptr %26, i64 80
  call void @get_scale_min_k4(i32 noundef 2, ptr noundef nonnull %34, ptr noundef nonnull %4, ptr noundef nonnull %5)
  %205 = load i8, ptr %4, align 1, !tbaa !5
  %206 = uitofp i8 %205 to float
  %207 = fmul float %30, %206
  %208 = load i8, ptr %5, align 1, !tbaa !5
  %209 = uitofp i8 %208 to float
  call void @get_scale_min_k4(i32 noundef 3, ptr noundef nonnull %34, ptr noundef nonnull %4, ptr noundef nonnull %5)
  %210 = load i8, ptr %4, align 1, !tbaa !5
  %211 = load i8, ptr %5, align 1, !tbaa !5
  %212 = fmul float %35, %209
  %213 = add nuw i64 %indvars.iv.lcssa, %indvars.iv72.lcssa
  %214 = shl i64 %213, 2
  %215 = add i64 %214, 136
  %scevgep229 = getelementptr i8, ptr %.04969, i64 %215
  %bound0232 = icmp ult ptr %.lcssa87, %scevgep231
  %bound1233 = icmp ult ptr %scevgep230, %scevgep229
  %found.conflict234 = and i1 %bound0232, %bound1233
  br i1 %found.conflict234, label %scalar.ph236, label %vector.body241

vector.body241:                                   ; preds = %middle.block262
  %broadcast.splatinsert252 = insertelement <4 x float> poison, float %212, i64 0
  %broadcast.splat253 = shufflevector <4 x float> %broadcast.splatinsert252, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert250 = insertelement <4 x float> poison, float %207, i64 0
  %broadcast.splat251 = shufflevector <4 x float> %broadcast.splatinsert250, <4 x float> poison, <4 x i32> zeroinitializer
  %ind.end239 = getelementptr i8, ptr %.lcssa87, i64 128
  %216 = getelementptr inbounds i8, ptr %26, i64 84
  %wide.load246 = load <4 x i8>, ptr %204, align 1, !tbaa !5, !alias.scope !23
  %wide.load247 = load <4 x i8>, ptr %216, align 1, !tbaa !5, !alias.scope !23
  %217 = and <4 x i8> %wide.load246, <i8 15, i8 15, i8 15, i8 15>
  %218 = and <4 x i8> %wide.load247, <i8 15, i8 15, i8 15, i8 15>
  %219 = getelementptr inbounds i8, ptr %26, i64 20
  %wide.load248 = load <4 x i8>, ptr %28, align 1, !tbaa !5, !alias.scope !23
  %wide.load249 = load <4 x i8>, ptr %219, align 1, !tbaa !5, !alias.scope !23
  %220 = shl <4 x i8> %wide.load248, <i8 2, i8 2, i8 2, i8 2>
  %221 = shl <4 x i8> %wide.load249, <i8 2, i8 2, i8 2, i8 2>
  %222 = and <4 x i8> %220, <i8 16, i8 16, i8 16, i8 16>
  %223 = and <4 x i8> %221, <i8 16, i8 16, i8 16, i8 16>
  %224 = or disjoint <4 x i8> %222, %217
  %225 = or disjoint <4 x i8> %223, %218
  %226 = uitofp nneg <4 x i8> %224 to <4 x float>
  %227 = uitofp nneg <4 x i8> %225 to <4 x float>
  %228 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat251, <4 x float> %226, <4 x float> %broadcast.splat253)
  %229 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat251, <4 x float> %227, <4 x float> %broadcast.splat253)
  %230 = getelementptr i8, ptr %.lcssa87, i64 16
  store <4 x float> %228, ptr %.lcssa87, align 4, !tbaa !11, !alias.scope !26, !noalias !23
  store <4 x float> %229, ptr %230, align 4, !tbaa !11, !alias.scope !26, !noalias !23
  %next.gep244.1 = getelementptr i8, ptr %.lcssa87, i64 32
  %231 = getelementptr inbounds i8, ptr %26, i64 88
  %232 = getelementptr inbounds i8, ptr %26, i64 92
  %wide.load246.1 = load <4 x i8>, ptr %231, align 1, !tbaa !5, !alias.scope !23
  %wide.load247.1 = load <4 x i8>, ptr %232, align 1, !tbaa !5, !alias.scope !23
  %233 = and <4 x i8> %wide.load246.1, <i8 15, i8 15, i8 15, i8 15>
  %234 = and <4 x i8> %wide.load247.1, <i8 15, i8 15, i8 15, i8 15>
  %235 = getelementptr inbounds i8, ptr %26, i64 24
  %236 = getelementptr inbounds i8, ptr %26, i64 28
  %wide.load248.1 = load <4 x i8>, ptr %235, align 1, !tbaa !5, !alias.scope !23
  %wide.load249.1 = load <4 x i8>, ptr %236, align 1, !tbaa !5, !alias.scope !23
  %237 = shl <4 x i8> %wide.load248.1, <i8 2, i8 2, i8 2, i8 2>
  %238 = shl <4 x i8> %wide.load249.1, <i8 2, i8 2, i8 2, i8 2>
  %239 = and <4 x i8> %237, <i8 16, i8 16, i8 16, i8 16>
  %240 = and <4 x i8> %238, <i8 16, i8 16, i8 16, i8 16>
  %241 = or disjoint <4 x i8> %239, %233
  %242 = or disjoint <4 x i8> %240, %234
  %243 = uitofp nneg <4 x i8> %241 to <4 x float>
  %244 = uitofp nneg <4 x i8> %242 to <4 x float>
  %245 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat251, <4 x float> %243, <4 x float> %broadcast.splat253)
  %246 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat251, <4 x float> %244, <4 x float> %broadcast.splat253)
  %247 = getelementptr i8, ptr %.lcssa87, i64 48
  store <4 x float> %245, ptr %next.gep244.1, align 4, !tbaa !11, !alias.scope !26, !noalias !23
  store <4 x float> %246, ptr %247, align 4, !tbaa !11, !alias.scope !26, !noalias !23
  %next.gep244.2 = getelementptr i8, ptr %.lcssa87, i64 64
  %248 = getelementptr inbounds i8, ptr %26, i64 96
  %249 = getelementptr inbounds i8, ptr %26, i64 100
  %wide.load246.2 = load <4 x i8>, ptr %248, align 1, !tbaa !5, !alias.scope !23
  %wide.load247.2 = load <4 x i8>, ptr %249, align 1, !tbaa !5, !alias.scope !23
  %250 = and <4 x i8> %wide.load246.2, <i8 15, i8 15, i8 15, i8 15>
  %251 = and <4 x i8> %wide.load247.2, <i8 15, i8 15, i8 15, i8 15>
  %252 = getelementptr inbounds i8, ptr %26, i64 32
  %253 = getelementptr inbounds i8, ptr %26, i64 36
  %wide.load248.2 = load <4 x i8>, ptr %252, align 1, !tbaa !5, !alias.scope !23
  %wide.load249.2 = load <4 x i8>, ptr %253, align 1, !tbaa !5, !alias.scope !23
  %254 = shl <4 x i8> %wide.load248.2, <i8 2, i8 2, i8 2, i8 2>
  %255 = shl <4 x i8> %wide.load249.2, <i8 2, i8 2, i8 2, i8 2>
  %256 = and <4 x i8> %254, <i8 16, i8 16, i8 16, i8 16>
  %257 = and <4 x i8> %255, <i8 16, i8 16, i8 16, i8 16>
  %258 = or disjoint <4 x i8> %256, %250
  %259 = or disjoint <4 x i8> %257, %251
  %260 = uitofp nneg <4 x i8> %258 to <4 x float>
  %261 = uitofp nneg <4 x i8> %259 to <4 x float>
  %262 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat251, <4 x float> %260, <4 x float> %broadcast.splat253)
  %263 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat251, <4 x float> %261, <4 x float> %broadcast.splat253)
  %264 = getelementptr i8, ptr %.lcssa87, i64 80
  store <4 x float> %262, ptr %next.gep244.2, align 4, !tbaa !11, !alias.scope !26, !noalias !23
  store <4 x float> %263, ptr %264, align 4, !tbaa !11, !alias.scope !26, !noalias !23
  %next.gep244.3 = getelementptr i8, ptr %.lcssa87, i64 96
  %265 = getelementptr inbounds i8, ptr %26, i64 104
  %266 = getelementptr inbounds i8, ptr %26, i64 108
  %wide.load246.3 = load <4 x i8>, ptr %265, align 1, !tbaa !5, !alias.scope !23
  %wide.load247.3 = load <4 x i8>, ptr %266, align 1, !tbaa !5, !alias.scope !23
  %267 = and <4 x i8> %wide.load246.3, <i8 15, i8 15, i8 15, i8 15>
  %268 = and <4 x i8> %wide.load247.3, <i8 15, i8 15, i8 15, i8 15>
  %269 = getelementptr inbounds i8, ptr %26, i64 40
  %270 = getelementptr inbounds i8, ptr %26, i64 44
  %wide.load248.3 = load <4 x i8>, ptr %269, align 1, !tbaa !5, !alias.scope !23
  %wide.load249.3 = load <4 x i8>, ptr %270, align 1, !tbaa !5, !alias.scope !23
  %271 = shl <4 x i8> %wide.load248.3, <i8 2, i8 2, i8 2, i8 2>
  %272 = shl <4 x i8> %wide.load249.3, <i8 2, i8 2, i8 2, i8 2>
  %273 = and <4 x i8> %271, <i8 16, i8 16, i8 16, i8 16>
  %274 = and <4 x i8> %272, <i8 16, i8 16, i8 16, i8 16>
  %275 = or disjoint <4 x i8> %273, %267
  %276 = or disjoint <4 x i8> %274, %268
  %277 = uitofp nneg <4 x i8> %275 to <4 x float>
  %278 = uitofp nneg <4 x i8> %276 to <4 x float>
  %279 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat251, <4 x float> %277, <4 x float> %broadcast.splat253)
  %280 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat251, <4 x float> %278, <4 x float> %broadcast.splat253)
  %281 = getelementptr i8, ptr %.lcssa87, i64 112
  store <4 x float> %279, ptr %next.gep244.3, align 4, !tbaa !11, !alias.scope !26, !noalias !23
  store <4 x float> %280, ptr %281, align 4, !tbaa !11, !alias.scope !26, !noalias !23
  br label %.preheader.1

scalar.ph236:                                     ; preds = %middle.block262, %scalar.ph236
  %indvars.iv.1 = phi i64 [ %indvars.iv.next.1.1, %scalar.ph236 ], [ 0, %middle.block262 ]
  %.258.1 = phi ptr [ %303, %scalar.ph236 ], [ %.lcssa87, %middle.block262 ]
  %282 = getelementptr inbounds i8, ptr %204, i64 %indvars.iv.1
  %283 = load i8, ptr %282, align 1, !tbaa !5
  %284 = and i8 %283, 15
  %285 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv.1
  %286 = load i8, ptr %285, align 1, !tbaa !5
  %287 = shl i8 %286, 2
  %288 = and i8 %287, 16
  %289 = or disjoint i8 %288, %284
  %290 = uitofp nneg i8 %289 to float
  %291 = call float @llvm.fmuladd.f32(float %207, float %290, float %212)
  %292 = getelementptr i8, ptr %.258.1, i64 4
  store float %291, ptr %.258.1, align 4, !tbaa !11
  %indvars.iv.next.1 = or disjoint i64 %indvars.iv.1, 1
  %293 = getelementptr inbounds i8, ptr %204, i64 %indvars.iv.next.1
  %294 = load i8, ptr %293, align 1, !tbaa !5
  %295 = and i8 %294, 15
  %296 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv.next.1
  %297 = load i8, ptr %296, align 1, !tbaa !5
  %298 = shl i8 %297, 2
  %299 = and i8 %298, 16
  %300 = or disjoint i8 %299, %295
  %301 = uitofp nneg i8 %300 to float
  %302 = call float @llvm.fmuladd.f32(float %207, float %301, float %212)
  %303 = getelementptr i8, ptr %.258.1, i64 8
  store float %302, ptr %292, align 4, !tbaa !11
  %indvars.iv.next.1.1 = add nuw nsw i64 %indvars.iv.1, 2
  %exitcond.1.not.1 = icmp eq i64 %indvars.iv.next.1.1, 32
  br i1 %exitcond.1.not.1, label %.preheader.1, label %scalar.ph236, !llvm.loop !28

.preheader.1:                                     ; preds = %scalar.ph236, %vector.body241
  %indvars.iv.1.lcssa = phi i64 [ 31, %vector.body241 ], [ %indvars.iv.next.1, %scalar.ph236 ]
  %.lcssa88 = phi ptr [ %ind.end239, %vector.body241 ], [ %303, %scalar.ph236 ]
  %304 = uitofp i8 %210 to float
  %305 = fmul float %30, %304
  %306 = uitofp i8 %211 to float
  %307 = fmul float %35, %306
  %308 = add nuw i64 %indvars.iv.lcssa, %indvars.iv72.lcssa
  %309 = add i64 %308, %indvars.iv.1.lcssa
  %310 = shl i64 %309, 2
  %311 = add i64 %310, 140
  %scevgep201 = getelementptr i8, ptr %.04969, i64 %311
  %bound0203 = icmp ult ptr %.lcssa88, %scevgep202
  %bound1204 = icmp ult ptr %scevgep172, %scevgep201
  %found.conflict205 = and i1 %bound0203, %bound1204
  br i1 %found.conflict205, label %scalar.ph207, label %vector.body212

vector.body212:                                   ; preds = %.preheader.1
  %broadcast.splatinsert223 = insertelement <4 x float> poison, float %307, i64 0
  %broadcast.splat224 = shufflevector <4 x float> %broadcast.splatinsert223, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert221 = insertelement <4 x float> poison, float %305, i64 0
  %broadcast.splat222 = shufflevector <4 x float> %broadcast.splatinsert221, <4 x float> poison, <4 x i32> zeroinitializer
  %ind.end210 = getelementptr i8, ptr %.lcssa88, i64 128
  %312 = getelementptr inbounds i8, ptr %26, i64 84
  %wide.load217 = load <4 x i8>, ptr %204, align 1, !tbaa !5, !alias.scope !29
  %wide.load218 = load <4 x i8>, ptr %312, align 1, !tbaa !5, !alias.scope !29
  %313 = lshr <4 x i8> %wide.load217, <i8 4, i8 4, i8 4, i8 4>
  %314 = lshr <4 x i8> %wide.load218, <i8 4, i8 4, i8 4, i8 4>
  %315 = getelementptr inbounds i8, ptr %26, i64 20
  %wide.load219 = load <4 x i8>, ptr %28, align 1, !tbaa !5, !alias.scope !29
  %wide.load220 = load <4 x i8>, ptr %315, align 1, !tbaa !5, !alias.scope !29
  %316 = shl <4 x i8> %wide.load219, <i8 1, i8 1, i8 1, i8 1>
  %317 = shl <4 x i8> %wide.load220, <i8 1, i8 1, i8 1, i8 1>
  %318 = and <4 x i8> %316, <i8 16, i8 16, i8 16, i8 16>
  %319 = and <4 x i8> %317, <i8 16, i8 16, i8 16, i8 16>
  %320 = or disjoint <4 x i8> %318, %313
  %321 = or disjoint <4 x i8> %319, %314
  %322 = uitofp nneg <4 x i8> %320 to <4 x float>
  %323 = uitofp nneg <4 x i8> %321 to <4 x float>
  %324 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat222, <4 x float> %322, <4 x float> %broadcast.splat224)
  %325 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat222, <4 x float> %323, <4 x float> %broadcast.splat224)
  %326 = getelementptr i8, ptr %.lcssa88, i64 16
  store <4 x float> %324, ptr %.lcssa88, align 4, !tbaa !11, !alias.scope !32, !noalias !29
  store <4 x float> %325, ptr %326, align 4, !tbaa !11, !alias.scope !32, !noalias !29
  %next.gep215.1 = getelementptr i8, ptr %.lcssa88, i64 32
  %327 = getelementptr inbounds i8, ptr %26, i64 88
  %328 = getelementptr inbounds i8, ptr %26, i64 92
  %wide.load217.1 = load <4 x i8>, ptr %327, align 1, !tbaa !5, !alias.scope !29
  %wide.load218.1 = load <4 x i8>, ptr %328, align 1, !tbaa !5, !alias.scope !29
  %329 = lshr <4 x i8> %wide.load217.1, <i8 4, i8 4, i8 4, i8 4>
  %330 = lshr <4 x i8> %wide.load218.1, <i8 4, i8 4, i8 4, i8 4>
  %331 = getelementptr inbounds i8, ptr %26, i64 24
  %332 = getelementptr inbounds i8, ptr %26, i64 28
  %wide.load219.1 = load <4 x i8>, ptr %331, align 1, !tbaa !5, !alias.scope !29
  %wide.load220.1 = load <4 x i8>, ptr %332, align 1, !tbaa !5, !alias.scope !29
  %333 = shl <4 x i8> %wide.load219.1, <i8 1, i8 1, i8 1, i8 1>
  %334 = shl <4 x i8> %wide.load220.1, <i8 1, i8 1, i8 1, i8 1>
  %335 = and <4 x i8> %333, <i8 16, i8 16, i8 16, i8 16>
  %336 = and <4 x i8> %334, <i8 16, i8 16, i8 16, i8 16>
  %337 = or disjoint <4 x i8> %335, %329
  %338 = or disjoint <4 x i8> %336, %330
  %339 = uitofp nneg <4 x i8> %337 to <4 x float>
  %340 = uitofp nneg <4 x i8> %338 to <4 x float>
  %341 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat222, <4 x float> %339, <4 x float> %broadcast.splat224)
  %342 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat222, <4 x float> %340, <4 x float> %broadcast.splat224)
  %343 = getelementptr i8, ptr %.lcssa88, i64 48
  store <4 x float> %341, ptr %next.gep215.1, align 4, !tbaa !11, !alias.scope !32, !noalias !29
  store <4 x float> %342, ptr %343, align 4, !tbaa !11, !alias.scope !32, !noalias !29
  %next.gep215.2 = getelementptr i8, ptr %.lcssa88, i64 64
  %344 = getelementptr inbounds i8, ptr %26, i64 96
  %345 = getelementptr inbounds i8, ptr %26, i64 100
  %wide.load217.2 = load <4 x i8>, ptr %344, align 1, !tbaa !5, !alias.scope !29
  %wide.load218.2 = load <4 x i8>, ptr %345, align 1, !tbaa !5, !alias.scope !29
  %346 = lshr <4 x i8> %wide.load217.2, <i8 4, i8 4, i8 4, i8 4>
  %347 = lshr <4 x i8> %wide.load218.2, <i8 4, i8 4, i8 4, i8 4>
  %348 = getelementptr inbounds i8, ptr %26, i64 32
  %349 = getelementptr inbounds i8, ptr %26, i64 36
  %wide.load219.2 = load <4 x i8>, ptr %348, align 1, !tbaa !5, !alias.scope !29
  %wide.load220.2 = load <4 x i8>, ptr %349, align 1, !tbaa !5, !alias.scope !29
  %350 = shl <4 x i8> %wide.load219.2, <i8 1, i8 1, i8 1, i8 1>
  %351 = shl <4 x i8> %wide.load220.2, <i8 1, i8 1, i8 1, i8 1>
  %352 = and <4 x i8> %350, <i8 16, i8 16, i8 16, i8 16>
  %353 = and <4 x i8> %351, <i8 16, i8 16, i8 16, i8 16>
  %354 = or disjoint <4 x i8> %352, %346
  %355 = or disjoint <4 x i8> %353, %347
  %356 = uitofp nneg <4 x i8> %354 to <4 x float>
  %357 = uitofp nneg <4 x i8> %355 to <4 x float>
  %358 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat222, <4 x float> %356, <4 x float> %broadcast.splat224)
  %359 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat222, <4 x float> %357, <4 x float> %broadcast.splat224)
  %360 = getelementptr i8, ptr %.lcssa88, i64 80
  store <4 x float> %358, ptr %next.gep215.2, align 4, !tbaa !11, !alias.scope !32, !noalias !29
  store <4 x float> %359, ptr %360, align 4, !tbaa !11, !alias.scope !32, !noalias !29
  %next.gep215.3 = getelementptr i8, ptr %.lcssa88, i64 96
  %361 = getelementptr inbounds i8, ptr %26, i64 104
  %362 = getelementptr inbounds i8, ptr %26, i64 108
  %wide.load217.3 = load <4 x i8>, ptr %361, align 1, !tbaa !5, !alias.scope !29
  %wide.load218.3 = load <4 x i8>, ptr %362, align 1, !tbaa !5, !alias.scope !29
  %363 = lshr <4 x i8> %wide.load217.3, <i8 4, i8 4, i8 4, i8 4>
  %364 = lshr <4 x i8> %wide.load218.3, <i8 4, i8 4, i8 4, i8 4>
  %365 = getelementptr inbounds i8, ptr %26, i64 40
  %366 = getelementptr inbounds i8, ptr %26, i64 44
  %wide.load219.3 = load <4 x i8>, ptr %365, align 1, !tbaa !5, !alias.scope !29
  %wide.load220.3 = load <4 x i8>, ptr %366, align 1, !tbaa !5, !alias.scope !29
  %367 = shl <4 x i8> %wide.load219.3, <i8 1, i8 1, i8 1, i8 1>
  %368 = shl <4 x i8> %wide.load220.3, <i8 1, i8 1, i8 1, i8 1>
  %369 = and <4 x i8> %367, <i8 16, i8 16, i8 16, i8 16>
  %370 = and <4 x i8> %368, <i8 16, i8 16, i8 16, i8 16>
  %371 = or disjoint <4 x i8> %369, %363
  %372 = or disjoint <4 x i8> %370, %364
  %373 = uitofp nneg <4 x i8> %371 to <4 x float>
  %374 = uitofp nneg <4 x i8> %372 to <4 x float>
  %375 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat222, <4 x float> %373, <4 x float> %broadcast.splat224)
  %376 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat222, <4 x float> %374, <4 x float> %broadcast.splat224)
  %377 = getelementptr i8, ptr %.lcssa88, i64 112
  store <4 x float> %375, ptr %next.gep215.3, align 4, !tbaa !11, !alias.scope !32, !noalias !29
  store <4 x float> %376, ptr %377, align 4, !tbaa !11, !alias.scope !32, !noalias !29
  br label %middle.block206

scalar.ph207:                                     ; preds = %.preheader.1, %scalar.ph207
  %indvars.iv72.1 = phi i64 [ %indvars.iv.next73.1.1, %scalar.ph207 ], [ 0, %.preheader.1 ]
  %.360.1 = phi ptr [ %399, %scalar.ph207 ], [ %.lcssa88, %.preheader.1 ]
  %378 = getelementptr inbounds i8, ptr %204, i64 %indvars.iv72.1
  %379 = load i8, ptr %378, align 1, !tbaa !5
  %380 = lshr i8 %379, 4
  %381 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv72.1
  %382 = load i8, ptr %381, align 1, !tbaa !5
  %383 = shl i8 %382, 1
  %384 = and i8 %383, 16
  %385 = or disjoint i8 %384, %380
  %386 = uitofp nneg i8 %385 to float
  %387 = call float @llvm.fmuladd.f32(float %305, float %386, float %307)
  %388 = getelementptr i8, ptr %.360.1, i64 4
  store float %387, ptr %.360.1, align 4, !tbaa !11
  %indvars.iv.next73.1 = or disjoint i64 %indvars.iv72.1, 1
  %389 = getelementptr inbounds i8, ptr %204, i64 %indvars.iv.next73.1
  %390 = load i8, ptr %389, align 1, !tbaa !5
  %391 = lshr i8 %390, 4
  %392 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv.next73.1
  %393 = load i8, ptr %392, align 1, !tbaa !5
  %394 = shl i8 %393, 1
  %395 = and i8 %394, 16
  %396 = or disjoint i8 %395, %391
  %397 = uitofp nneg i8 %396 to float
  %398 = call float @llvm.fmuladd.f32(float %305, float %397, float %307)
  %399 = getelementptr i8, ptr %.360.1, i64 8
  store float %398, ptr %388, align 4, !tbaa !11
  %indvars.iv.next73.1.1 = add nuw nsw i64 %indvars.iv72.1, 2
  %exitcond75.1.not.1 = icmp eq i64 %indvars.iv.next73.1.1, 32
  br i1 %exitcond75.1.not.1, label %middle.block206, label %scalar.ph207, !llvm.loop !34

middle.block206:                                  ; preds = %scalar.ph207, %vector.body212
  %indvars.iv72.1.lcssa = phi i64 [ 31, %vector.body212 ], [ %indvars.iv.next73.1, %scalar.ph207 ]
  %.lcssa89 = phi ptr [ %ind.end210, %vector.body212 ], [ %399, %scalar.ph207 ]
  %400 = getelementptr inbounds i8, ptr %26, i64 112
  call void @get_scale_min_k4(i32 noundef 4, ptr noundef nonnull %34, ptr noundef nonnull %4, ptr noundef nonnull %5)
  %401 = load i8, ptr %4, align 1, !tbaa !5
  %402 = uitofp i8 %401 to float
  %403 = fmul float %30, %402
  %404 = load i8, ptr %5, align 1, !tbaa !5
  %405 = uitofp i8 %404 to float
  call void @get_scale_min_k4(i32 noundef 5, ptr noundef nonnull %34, ptr noundef nonnull %4, ptr noundef nonnull %5)
  %406 = load i8, ptr %4, align 1, !tbaa !5
  %407 = load i8, ptr %5, align 1, !tbaa !5
  %408 = fmul float %35, %405
  %409 = add nuw i64 %indvars.iv.lcssa, %indvars.iv72.lcssa
  %410 = add i64 %409, %indvars.iv.1.lcssa
  %411 = add i64 %410, %indvars.iv72.1.lcssa
  %412 = shl i64 %411, 2
  %413 = add i64 %412, 144
  %scevgep171 = getelementptr i8, ptr %.04969, i64 %413
  %bound0174 = icmp ult ptr %.lcssa89, %scevgep173
  %bound1175 = icmp ult ptr %scevgep172, %scevgep171
  %found.conflict176 = and i1 %bound0174, %bound1175
  br i1 %found.conflict176, label %scalar.ph178, label %vector.body183

vector.body183:                                   ; preds = %middle.block206
  %broadcast.splatinsert194 = insertelement <4 x float> poison, float %408, i64 0
  %broadcast.splat195 = shufflevector <4 x float> %broadcast.splatinsert194, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert192 = insertelement <4 x float> poison, float %403, i64 0
  %broadcast.splat193 = shufflevector <4 x float> %broadcast.splatinsert192, <4 x float> poison, <4 x i32> zeroinitializer
  %ind.end181 = getelementptr i8, ptr %.lcssa89, i64 128
  %414 = getelementptr inbounds i8, ptr %26, i64 116
  %wide.load188 = load <4 x i8>, ptr %400, align 1, !tbaa !5, !alias.scope !35
  %wide.load189 = load <4 x i8>, ptr %414, align 1, !tbaa !5, !alias.scope !35
  %415 = and <4 x i8> %wide.load188, <i8 15, i8 15, i8 15, i8 15>
  %416 = and <4 x i8> %wide.load189, <i8 15, i8 15, i8 15, i8 15>
  %417 = getelementptr inbounds i8, ptr %26, i64 20
  %wide.load190 = load <4 x i8>, ptr %28, align 1, !tbaa !5, !alias.scope !35
  %wide.load191 = load <4 x i8>, ptr %417, align 1, !tbaa !5, !alias.scope !35
  %418 = and <4 x i8> %wide.load190, <i8 16, i8 16, i8 16, i8 16>
  %419 = and <4 x i8> %wide.load191, <i8 16, i8 16, i8 16, i8 16>
  %420 = or disjoint <4 x i8> %418, %415
  %421 = or disjoint <4 x i8> %419, %416
  %422 = uitofp nneg <4 x i8> %420 to <4 x float>
  %423 = uitofp nneg <4 x i8> %421 to <4 x float>
  %424 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat193, <4 x float> %422, <4 x float> %broadcast.splat195)
  %425 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat193, <4 x float> %423, <4 x float> %broadcast.splat195)
  %426 = getelementptr i8, ptr %.lcssa89, i64 16
  store <4 x float> %424, ptr %.lcssa89, align 4, !tbaa !11, !alias.scope !38, !noalias !35
  store <4 x float> %425, ptr %426, align 4, !tbaa !11, !alias.scope !38, !noalias !35
  %next.gep186.1 = getelementptr i8, ptr %.lcssa89, i64 32
  %427 = getelementptr inbounds i8, ptr %26, i64 120
  %428 = getelementptr inbounds i8, ptr %26, i64 124
  %wide.load188.1 = load <4 x i8>, ptr %427, align 1, !tbaa !5, !alias.scope !35
  %wide.load189.1 = load <4 x i8>, ptr %428, align 1, !tbaa !5, !alias.scope !35
  %429 = and <4 x i8> %wide.load188.1, <i8 15, i8 15, i8 15, i8 15>
  %430 = and <4 x i8> %wide.load189.1, <i8 15, i8 15, i8 15, i8 15>
  %431 = getelementptr inbounds i8, ptr %26, i64 24
  %432 = getelementptr inbounds i8, ptr %26, i64 28
  %wide.load190.1 = load <4 x i8>, ptr %431, align 1, !tbaa !5, !alias.scope !35
  %wide.load191.1 = load <4 x i8>, ptr %432, align 1, !tbaa !5, !alias.scope !35
  %433 = and <4 x i8> %wide.load190.1, <i8 16, i8 16, i8 16, i8 16>
  %434 = and <4 x i8> %wide.load191.1, <i8 16, i8 16, i8 16, i8 16>
  %435 = or disjoint <4 x i8> %433, %429
  %436 = or disjoint <4 x i8> %434, %430
  %437 = uitofp nneg <4 x i8> %435 to <4 x float>
  %438 = uitofp nneg <4 x i8> %436 to <4 x float>
  %439 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat193, <4 x float> %437, <4 x float> %broadcast.splat195)
  %440 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat193, <4 x float> %438, <4 x float> %broadcast.splat195)
  %441 = getelementptr i8, ptr %.lcssa89, i64 48
  store <4 x float> %439, ptr %next.gep186.1, align 4, !tbaa !11, !alias.scope !38, !noalias !35
  store <4 x float> %440, ptr %441, align 4, !tbaa !11, !alias.scope !38, !noalias !35
  %next.gep186.2 = getelementptr i8, ptr %.lcssa89, i64 64
  %442 = getelementptr inbounds i8, ptr %26, i64 128
  %443 = getelementptr inbounds i8, ptr %26, i64 132
  %wide.load188.2 = load <4 x i8>, ptr %442, align 1, !tbaa !5, !alias.scope !35
  %wide.load189.2 = load <4 x i8>, ptr %443, align 1, !tbaa !5, !alias.scope !35
  %444 = and <4 x i8> %wide.load188.2, <i8 15, i8 15, i8 15, i8 15>
  %445 = and <4 x i8> %wide.load189.2, <i8 15, i8 15, i8 15, i8 15>
  %446 = getelementptr inbounds i8, ptr %26, i64 32
  %447 = getelementptr inbounds i8, ptr %26, i64 36
  %wide.load190.2 = load <4 x i8>, ptr %446, align 1, !tbaa !5, !alias.scope !35
  %wide.load191.2 = load <4 x i8>, ptr %447, align 1, !tbaa !5, !alias.scope !35
  %448 = and <4 x i8> %wide.load190.2, <i8 16, i8 16, i8 16, i8 16>
  %449 = and <4 x i8> %wide.load191.2, <i8 16, i8 16, i8 16, i8 16>
  %450 = or disjoint <4 x i8> %448, %444
  %451 = or disjoint <4 x i8> %449, %445
  %452 = uitofp nneg <4 x i8> %450 to <4 x float>
  %453 = uitofp nneg <4 x i8> %451 to <4 x float>
  %454 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat193, <4 x float> %452, <4 x float> %broadcast.splat195)
  %455 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat193, <4 x float> %453, <4 x float> %broadcast.splat195)
  %456 = getelementptr i8, ptr %.lcssa89, i64 80
  store <4 x float> %454, ptr %next.gep186.2, align 4, !tbaa !11, !alias.scope !38, !noalias !35
  store <4 x float> %455, ptr %456, align 4, !tbaa !11, !alias.scope !38, !noalias !35
  %next.gep186.3 = getelementptr i8, ptr %.lcssa89, i64 96
  %457 = getelementptr inbounds i8, ptr %26, i64 136
  %458 = getelementptr inbounds i8, ptr %26, i64 140
  %wide.load188.3 = load <4 x i8>, ptr %457, align 1, !tbaa !5, !alias.scope !35
  %wide.load189.3 = load <4 x i8>, ptr %458, align 1, !tbaa !5, !alias.scope !35
  %459 = and <4 x i8> %wide.load188.3, <i8 15, i8 15, i8 15, i8 15>
  %460 = and <4 x i8> %wide.load189.3, <i8 15, i8 15, i8 15, i8 15>
  %461 = getelementptr inbounds i8, ptr %26, i64 40
  %462 = getelementptr inbounds i8, ptr %26, i64 44
  %wide.load190.3 = load <4 x i8>, ptr %461, align 1, !tbaa !5, !alias.scope !35
  %wide.load191.3 = load <4 x i8>, ptr %462, align 1, !tbaa !5, !alias.scope !35
  %463 = and <4 x i8> %wide.load190.3, <i8 16, i8 16, i8 16, i8 16>
  %464 = and <4 x i8> %wide.load191.3, <i8 16, i8 16, i8 16, i8 16>
  %465 = or disjoint <4 x i8> %463, %459
  %466 = or disjoint <4 x i8> %464, %460
  %467 = uitofp nneg <4 x i8> %465 to <4 x float>
  %468 = uitofp nneg <4 x i8> %466 to <4 x float>
  %469 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat193, <4 x float> %467, <4 x float> %broadcast.splat195)
  %470 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat193, <4 x float> %468, <4 x float> %broadcast.splat195)
  %471 = getelementptr i8, ptr %.lcssa89, i64 112
  store <4 x float> %469, ptr %next.gep186.3, align 4, !tbaa !11, !alias.scope !38, !noalias !35
  store <4 x float> %470, ptr %471, align 4, !tbaa !11, !alias.scope !38, !noalias !35
  br label %.preheader.2

scalar.ph178:                                     ; preds = %middle.block206, %scalar.ph178
  %indvars.iv.2 = phi i64 [ %indvars.iv.next.2.1, %scalar.ph178 ], [ 0, %middle.block206 ]
  %.258.2 = phi ptr [ %491, %scalar.ph178 ], [ %.lcssa89, %middle.block206 ]
  %472 = getelementptr inbounds i8, ptr %400, i64 %indvars.iv.2
  %473 = load i8, ptr %472, align 1, !tbaa !5
  %474 = and i8 %473, 15
  %475 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv.2
  %476 = load i8, ptr %475, align 1, !tbaa !5
  %477 = and i8 %476, 16
  %478 = or disjoint i8 %477, %474
  %479 = uitofp nneg i8 %478 to float
  %480 = call float @llvm.fmuladd.f32(float %403, float %479, float %408)
  %481 = getelementptr i8, ptr %.258.2, i64 4
  store float %480, ptr %.258.2, align 4, !tbaa !11
  %indvars.iv.next.2 = or disjoint i64 %indvars.iv.2, 1
  %482 = getelementptr inbounds i8, ptr %400, i64 %indvars.iv.next.2
  %483 = load i8, ptr %482, align 1, !tbaa !5
  %484 = and i8 %483, 15
  %485 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv.next.2
  %486 = load i8, ptr %485, align 1, !tbaa !5
  %487 = and i8 %486, 16
  %488 = or disjoint i8 %487, %484
  %489 = uitofp nneg i8 %488 to float
  %490 = call float @llvm.fmuladd.f32(float %403, float %489, float %408)
  %491 = getelementptr i8, ptr %.258.2, i64 8
  store float %490, ptr %481, align 4, !tbaa !11
  %indvars.iv.next.2.1 = add nuw nsw i64 %indvars.iv.2, 2
  %exitcond.2.not.1 = icmp eq i64 %indvars.iv.next.2.1, 32
  br i1 %exitcond.2.not.1, label %.preheader.2, label %scalar.ph178, !llvm.loop !40

.preheader.2:                                     ; preds = %scalar.ph178, %vector.body183
  %indvars.iv.2.lcssa = phi i64 [ 31, %vector.body183 ], [ %indvars.iv.next.2, %scalar.ph178 ]
  %.lcssa90 = phi ptr [ %ind.end181, %vector.body183 ], [ %491, %scalar.ph178 ]
  %492 = uitofp i8 %406 to float
  %493 = fmul float %30, %492
  %494 = uitofp i8 %407 to float
  %495 = fmul float %35, %494
  %496 = add nuw i64 %indvars.iv.lcssa, %indvars.iv72.lcssa
  %497 = add i64 %496, %indvars.iv.1.lcssa
  %498 = add i64 %497, %indvars.iv72.1.lcssa
  %499 = add i64 %498, %indvars.iv.2.lcssa
  %500 = shl i64 %499, 2
  %501 = add i64 %500, 148
  %scevgep141 = getelementptr i8, ptr %.04969, i64 %501
  %bound0143 = icmp ult ptr %.lcssa90, %scevgep142
  %bound1144 = icmp ult ptr %scevgep94, %scevgep141
  %found.conflict145 = and i1 %bound0143, %bound1144
  br i1 %found.conflict145, label %scalar.ph147, label %vector.body152

vector.body152:                                   ; preds = %.preheader.2
  %broadcast.splatinsert163 = insertelement <4 x float> poison, float %495, i64 0
  %broadcast.splat164 = shufflevector <4 x float> %broadcast.splatinsert163, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert161 = insertelement <4 x float> poison, float %493, i64 0
  %broadcast.splat162 = shufflevector <4 x float> %broadcast.splatinsert161, <4 x float> poison, <4 x i32> zeroinitializer
  %ind.end150 = getelementptr i8, ptr %.lcssa90, i64 128
  %502 = getelementptr inbounds i8, ptr %26, i64 116
  %wide.load157 = load <4 x i8>, ptr %400, align 1, !tbaa !5, !alias.scope !41
  %wide.load158 = load <4 x i8>, ptr %502, align 1, !tbaa !5, !alias.scope !41
  %503 = lshr <4 x i8> %wide.load157, <i8 4, i8 4, i8 4, i8 4>
  %504 = lshr <4 x i8> %wide.load158, <i8 4, i8 4, i8 4, i8 4>
  %505 = getelementptr inbounds i8, ptr %26, i64 20
  %wide.load159 = load <4 x i8>, ptr %28, align 1, !tbaa !5, !alias.scope !41
  %wide.load160 = load <4 x i8>, ptr %505, align 1, !tbaa !5, !alias.scope !41
  %506 = lshr <4 x i8> %wide.load159, <i8 1, i8 1, i8 1, i8 1>
  %507 = lshr <4 x i8> %wide.load160, <i8 1, i8 1, i8 1, i8 1>
  %508 = and <4 x i8> %506, <i8 16, i8 16, i8 16, i8 16>
  %509 = and <4 x i8> %507, <i8 16, i8 16, i8 16, i8 16>
  %510 = or disjoint <4 x i8> %508, %503
  %511 = or disjoint <4 x i8> %509, %504
  %512 = uitofp nneg <4 x i8> %510 to <4 x float>
  %513 = uitofp nneg <4 x i8> %511 to <4 x float>
  %514 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat162, <4 x float> %512, <4 x float> %broadcast.splat164)
  %515 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat162, <4 x float> %513, <4 x float> %broadcast.splat164)
  %516 = getelementptr i8, ptr %.lcssa90, i64 16
  store <4 x float> %514, ptr %.lcssa90, align 4, !tbaa !11, !alias.scope !44, !noalias !41
  store <4 x float> %515, ptr %516, align 4, !tbaa !11, !alias.scope !44, !noalias !41
  %next.gep155.1 = getelementptr i8, ptr %.lcssa90, i64 32
  %517 = getelementptr inbounds i8, ptr %26, i64 120
  %518 = getelementptr inbounds i8, ptr %26, i64 124
  %wide.load157.1 = load <4 x i8>, ptr %517, align 1, !tbaa !5, !alias.scope !41
  %wide.load158.1 = load <4 x i8>, ptr %518, align 1, !tbaa !5, !alias.scope !41
  %519 = lshr <4 x i8> %wide.load157.1, <i8 4, i8 4, i8 4, i8 4>
  %520 = lshr <4 x i8> %wide.load158.1, <i8 4, i8 4, i8 4, i8 4>
  %521 = getelementptr inbounds i8, ptr %26, i64 24
  %522 = getelementptr inbounds i8, ptr %26, i64 28
  %wide.load159.1 = load <4 x i8>, ptr %521, align 1, !tbaa !5, !alias.scope !41
  %wide.load160.1 = load <4 x i8>, ptr %522, align 1, !tbaa !5, !alias.scope !41
  %523 = lshr <4 x i8> %wide.load159.1, <i8 1, i8 1, i8 1, i8 1>
  %524 = lshr <4 x i8> %wide.load160.1, <i8 1, i8 1, i8 1, i8 1>
  %525 = and <4 x i8> %523, <i8 16, i8 16, i8 16, i8 16>
  %526 = and <4 x i8> %524, <i8 16, i8 16, i8 16, i8 16>
  %527 = or disjoint <4 x i8> %525, %519
  %528 = or disjoint <4 x i8> %526, %520
  %529 = uitofp nneg <4 x i8> %527 to <4 x float>
  %530 = uitofp nneg <4 x i8> %528 to <4 x float>
  %531 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat162, <4 x float> %529, <4 x float> %broadcast.splat164)
  %532 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat162, <4 x float> %530, <4 x float> %broadcast.splat164)
  %533 = getelementptr i8, ptr %.lcssa90, i64 48
  store <4 x float> %531, ptr %next.gep155.1, align 4, !tbaa !11, !alias.scope !44, !noalias !41
  store <4 x float> %532, ptr %533, align 4, !tbaa !11, !alias.scope !44, !noalias !41
  %next.gep155.2 = getelementptr i8, ptr %.lcssa90, i64 64
  %534 = getelementptr inbounds i8, ptr %26, i64 128
  %535 = getelementptr inbounds i8, ptr %26, i64 132
  %wide.load157.2 = load <4 x i8>, ptr %534, align 1, !tbaa !5, !alias.scope !41
  %wide.load158.2 = load <4 x i8>, ptr %535, align 1, !tbaa !5, !alias.scope !41
  %536 = lshr <4 x i8> %wide.load157.2, <i8 4, i8 4, i8 4, i8 4>
  %537 = lshr <4 x i8> %wide.load158.2, <i8 4, i8 4, i8 4, i8 4>
  %538 = getelementptr inbounds i8, ptr %26, i64 32
  %539 = getelementptr inbounds i8, ptr %26, i64 36
  %wide.load159.2 = load <4 x i8>, ptr %538, align 1, !tbaa !5, !alias.scope !41
  %wide.load160.2 = load <4 x i8>, ptr %539, align 1, !tbaa !5, !alias.scope !41
  %540 = lshr <4 x i8> %wide.load159.2, <i8 1, i8 1, i8 1, i8 1>
  %541 = lshr <4 x i8> %wide.load160.2, <i8 1, i8 1, i8 1, i8 1>
  %542 = and <4 x i8> %540, <i8 16, i8 16, i8 16, i8 16>
  %543 = and <4 x i8> %541, <i8 16, i8 16, i8 16, i8 16>
  %544 = or disjoint <4 x i8> %542, %536
  %545 = or disjoint <4 x i8> %543, %537
  %546 = uitofp nneg <4 x i8> %544 to <4 x float>
  %547 = uitofp nneg <4 x i8> %545 to <4 x float>
  %548 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat162, <4 x float> %546, <4 x float> %broadcast.splat164)
  %549 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat162, <4 x float> %547, <4 x float> %broadcast.splat164)
  %550 = getelementptr i8, ptr %.lcssa90, i64 80
  store <4 x float> %548, ptr %next.gep155.2, align 4, !tbaa !11, !alias.scope !44, !noalias !41
  store <4 x float> %549, ptr %550, align 4, !tbaa !11, !alias.scope !44, !noalias !41
  %next.gep155.3 = getelementptr i8, ptr %.lcssa90, i64 96
  %551 = getelementptr inbounds i8, ptr %26, i64 136
  %552 = getelementptr inbounds i8, ptr %26, i64 140
  %wide.load157.3 = load <4 x i8>, ptr %551, align 1, !tbaa !5, !alias.scope !41
  %wide.load158.3 = load <4 x i8>, ptr %552, align 1, !tbaa !5, !alias.scope !41
  %553 = lshr <4 x i8> %wide.load157.3, <i8 4, i8 4, i8 4, i8 4>
  %554 = lshr <4 x i8> %wide.load158.3, <i8 4, i8 4, i8 4, i8 4>
  %555 = getelementptr inbounds i8, ptr %26, i64 40
  %556 = getelementptr inbounds i8, ptr %26, i64 44
  %wide.load159.3 = load <4 x i8>, ptr %555, align 1, !tbaa !5, !alias.scope !41
  %wide.load160.3 = load <4 x i8>, ptr %556, align 1, !tbaa !5, !alias.scope !41
  %557 = lshr <4 x i8> %wide.load159.3, <i8 1, i8 1, i8 1, i8 1>
  %558 = lshr <4 x i8> %wide.load160.3, <i8 1, i8 1, i8 1, i8 1>
  %559 = and <4 x i8> %557, <i8 16, i8 16, i8 16, i8 16>
  %560 = and <4 x i8> %558, <i8 16, i8 16, i8 16, i8 16>
  %561 = or disjoint <4 x i8> %559, %553
  %562 = or disjoint <4 x i8> %560, %554
  %563 = uitofp nneg <4 x i8> %561 to <4 x float>
  %564 = uitofp nneg <4 x i8> %562 to <4 x float>
  %565 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat162, <4 x float> %563, <4 x float> %broadcast.splat164)
  %566 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat162, <4 x float> %564, <4 x float> %broadcast.splat164)
  %567 = getelementptr i8, ptr %.lcssa90, i64 112
  store <4 x float> %565, ptr %next.gep155.3, align 4, !tbaa !11, !alias.scope !44, !noalias !41
  store <4 x float> %566, ptr %567, align 4, !tbaa !11, !alias.scope !44, !noalias !41
  br label %middle.block146

scalar.ph147:                                     ; preds = %.preheader.2, %scalar.ph147
  %indvars.iv72.2 = phi i64 [ %indvars.iv.next73.2.1, %scalar.ph147 ], [ 0, %.preheader.2 ]
  %.360.2 = phi ptr [ %589, %scalar.ph147 ], [ %.lcssa90, %.preheader.2 ]
  %568 = getelementptr inbounds i8, ptr %400, i64 %indvars.iv72.2
  %569 = load i8, ptr %568, align 1, !tbaa !5
  %570 = lshr i8 %569, 4
  %571 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv72.2
  %572 = load i8, ptr %571, align 1, !tbaa !5
  %573 = lshr i8 %572, 1
  %574 = and i8 %573, 16
  %575 = or disjoint i8 %574, %570
  %576 = uitofp nneg i8 %575 to float
  %577 = call float @llvm.fmuladd.f32(float %493, float %576, float %495)
  %578 = getelementptr i8, ptr %.360.2, i64 4
  store float %577, ptr %.360.2, align 4, !tbaa !11
  %indvars.iv.next73.2 = or disjoint i64 %indvars.iv72.2, 1
  %579 = getelementptr inbounds i8, ptr %400, i64 %indvars.iv.next73.2
  %580 = load i8, ptr %579, align 1, !tbaa !5
  %581 = lshr i8 %580, 4
  %582 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv.next73.2
  %583 = load i8, ptr %582, align 1, !tbaa !5
  %584 = lshr i8 %583, 1
  %585 = and i8 %584, 16
  %586 = or disjoint i8 %585, %581
  %587 = uitofp nneg i8 %586 to float
  %588 = call float @llvm.fmuladd.f32(float %493, float %587, float %495)
  %589 = getelementptr i8, ptr %.360.2, i64 8
  store float %588, ptr %578, align 4, !tbaa !11
  %indvars.iv.next73.2.1 = add nuw nsw i64 %indvars.iv72.2, 2
  %exitcond75.2.not.1 = icmp eq i64 %indvars.iv.next73.2.1, 32
  br i1 %exitcond75.2.not.1, label %middle.block146, label %scalar.ph147, !llvm.loop !46

middle.block146:                                  ; preds = %scalar.ph147, %vector.body152
  %indvars.iv72.2.lcssa = phi i64 [ 31, %vector.body152 ], [ %indvars.iv.next73.2, %scalar.ph147 ]
  %.lcssa91 = phi ptr [ %ind.end150, %vector.body152 ], [ %589, %scalar.ph147 ]
  %590 = getelementptr inbounds i8, ptr %26, i64 144
  call void @get_scale_min_k4(i32 noundef 6, ptr noundef nonnull %34, ptr noundef nonnull %4, ptr noundef nonnull %5)
  %591 = load i8, ptr %4, align 1, !tbaa !5
  %592 = uitofp i8 %591 to float
  %593 = fmul float %30, %592
  %594 = load i8, ptr %5, align 1, !tbaa !5
  %595 = uitofp i8 %594 to float
  call void @get_scale_min_k4(i32 noundef 7, ptr noundef nonnull %34, ptr noundef nonnull %4, ptr noundef nonnull %5)
  %596 = load i8, ptr %4, align 1, !tbaa !5
  %597 = load i8, ptr %5, align 1, !tbaa !5
  %598 = fmul float %35, %595
  %599 = add nuw i64 %indvars.iv.lcssa, %indvars.iv72.lcssa
  %600 = add i64 %599, %indvars.iv.1.lcssa
  %601 = add i64 %600, %indvars.iv72.1.lcssa
  %602 = add i64 %601, %indvars.iv.2.lcssa
  %603 = add i64 %602, %indvars.iv72.2.lcssa
  %604 = shl i64 %603, 2
  %605 = add i64 %604, 152
  %scevgep110 = getelementptr i8, ptr %.04969, i64 %605
  %bound0112 = icmp ult ptr %.lcssa91, %scevgep111
  %bound1113 = icmp ult ptr %scevgep94, %scevgep110
  %found.conflict114 = and i1 %bound0112, %bound1113
  br i1 %found.conflict114, label %scalar.ph116, label %vector.body121

vector.body121:                                   ; preds = %middle.block146
  %broadcast.splatinsert132 = insertelement <4 x float> poison, float %598, i64 0
  %broadcast.splat133 = shufflevector <4 x float> %broadcast.splatinsert132, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert130 = insertelement <4 x float> poison, float %593, i64 0
  %broadcast.splat131 = shufflevector <4 x float> %broadcast.splatinsert130, <4 x float> poison, <4 x i32> zeroinitializer
  %ind.end119 = getelementptr i8, ptr %.lcssa91, i64 128
  %606 = getelementptr inbounds i8, ptr %26, i64 148
  %wide.load126 = load <4 x i8>, ptr %590, align 1, !tbaa !5, !alias.scope !47
  %wide.load127 = load <4 x i8>, ptr %606, align 1, !tbaa !5, !alias.scope !47
  %607 = and <4 x i8> %wide.load126, <i8 15, i8 15, i8 15, i8 15>
  %608 = and <4 x i8> %wide.load127, <i8 15, i8 15, i8 15, i8 15>
  %609 = getelementptr inbounds i8, ptr %26, i64 20
  %wide.load128 = load <4 x i8>, ptr %28, align 1, !tbaa !5, !alias.scope !47
  %wide.load129 = load <4 x i8>, ptr %609, align 1, !tbaa !5, !alias.scope !47
  %610 = lshr <4 x i8> %wide.load128, <i8 2, i8 2, i8 2, i8 2>
  %611 = lshr <4 x i8> %wide.load129, <i8 2, i8 2, i8 2, i8 2>
  %612 = and <4 x i8> %610, <i8 16, i8 16, i8 16, i8 16>
  %613 = and <4 x i8> %611, <i8 16, i8 16, i8 16, i8 16>
  %614 = or disjoint <4 x i8> %612, %607
  %615 = or disjoint <4 x i8> %613, %608
  %616 = uitofp nneg <4 x i8> %614 to <4 x float>
  %617 = uitofp nneg <4 x i8> %615 to <4 x float>
  %618 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat131, <4 x float> %616, <4 x float> %broadcast.splat133)
  %619 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat131, <4 x float> %617, <4 x float> %broadcast.splat133)
  %620 = getelementptr i8, ptr %.lcssa91, i64 16
  store <4 x float> %618, ptr %.lcssa91, align 4, !tbaa !11, !alias.scope !50, !noalias !47
  store <4 x float> %619, ptr %620, align 4, !tbaa !11, !alias.scope !50, !noalias !47
  %next.gep124.1 = getelementptr i8, ptr %.lcssa91, i64 32
  %621 = getelementptr inbounds i8, ptr %26, i64 152
  %622 = getelementptr inbounds i8, ptr %26, i64 156
  %wide.load126.1 = load <4 x i8>, ptr %621, align 1, !tbaa !5, !alias.scope !47
  %wide.load127.1 = load <4 x i8>, ptr %622, align 1, !tbaa !5, !alias.scope !47
  %623 = and <4 x i8> %wide.load126.1, <i8 15, i8 15, i8 15, i8 15>
  %624 = and <4 x i8> %wide.load127.1, <i8 15, i8 15, i8 15, i8 15>
  %625 = getelementptr inbounds i8, ptr %26, i64 24
  %626 = getelementptr inbounds i8, ptr %26, i64 28
  %wide.load128.1 = load <4 x i8>, ptr %625, align 1, !tbaa !5, !alias.scope !47
  %wide.load129.1 = load <4 x i8>, ptr %626, align 1, !tbaa !5, !alias.scope !47
  %627 = lshr <4 x i8> %wide.load128.1, <i8 2, i8 2, i8 2, i8 2>
  %628 = lshr <4 x i8> %wide.load129.1, <i8 2, i8 2, i8 2, i8 2>
  %629 = and <4 x i8> %627, <i8 16, i8 16, i8 16, i8 16>
  %630 = and <4 x i8> %628, <i8 16, i8 16, i8 16, i8 16>
  %631 = or disjoint <4 x i8> %629, %623
  %632 = or disjoint <4 x i8> %630, %624
  %633 = uitofp nneg <4 x i8> %631 to <4 x float>
  %634 = uitofp nneg <4 x i8> %632 to <4 x float>
  %635 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat131, <4 x float> %633, <4 x float> %broadcast.splat133)
  %636 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat131, <4 x float> %634, <4 x float> %broadcast.splat133)
  %637 = getelementptr i8, ptr %.lcssa91, i64 48
  store <4 x float> %635, ptr %next.gep124.1, align 4, !tbaa !11, !alias.scope !50, !noalias !47
  store <4 x float> %636, ptr %637, align 4, !tbaa !11, !alias.scope !50, !noalias !47
  %next.gep124.2 = getelementptr i8, ptr %.lcssa91, i64 64
  %638 = getelementptr inbounds i8, ptr %26, i64 160
  %639 = getelementptr inbounds i8, ptr %26, i64 164
  %wide.load126.2 = load <4 x i8>, ptr %638, align 1, !tbaa !5, !alias.scope !47
  %wide.load127.2 = load <4 x i8>, ptr %639, align 1, !tbaa !5, !alias.scope !47
  %640 = and <4 x i8> %wide.load126.2, <i8 15, i8 15, i8 15, i8 15>
  %641 = and <4 x i8> %wide.load127.2, <i8 15, i8 15, i8 15, i8 15>
  %642 = getelementptr inbounds i8, ptr %26, i64 32
  %643 = getelementptr inbounds i8, ptr %26, i64 36
  %wide.load128.2 = load <4 x i8>, ptr %642, align 1, !tbaa !5, !alias.scope !47
  %wide.load129.2 = load <4 x i8>, ptr %643, align 1, !tbaa !5, !alias.scope !47
  %644 = lshr <4 x i8> %wide.load128.2, <i8 2, i8 2, i8 2, i8 2>
  %645 = lshr <4 x i8> %wide.load129.2, <i8 2, i8 2, i8 2, i8 2>
  %646 = and <4 x i8> %644, <i8 16, i8 16, i8 16, i8 16>
  %647 = and <4 x i8> %645, <i8 16, i8 16, i8 16, i8 16>
  %648 = or disjoint <4 x i8> %646, %640
  %649 = or disjoint <4 x i8> %647, %641
  %650 = uitofp nneg <4 x i8> %648 to <4 x float>
  %651 = uitofp nneg <4 x i8> %649 to <4 x float>
  %652 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat131, <4 x float> %650, <4 x float> %broadcast.splat133)
  %653 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat131, <4 x float> %651, <4 x float> %broadcast.splat133)
  %654 = getelementptr i8, ptr %.lcssa91, i64 80
  store <4 x float> %652, ptr %next.gep124.2, align 4, !tbaa !11, !alias.scope !50, !noalias !47
  store <4 x float> %653, ptr %654, align 4, !tbaa !11, !alias.scope !50, !noalias !47
  %next.gep124.3 = getelementptr i8, ptr %.lcssa91, i64 96
  %655 = getelementptr inbounds i8, ptr %26, i64 168
  %656 = getelementptr inbounds i8, ptr %26, i64 172
  %wide.load126.3 = load <4 x i8>, ptr %655, align 1, !tbaa !5, !alias.scope !47
  %wide.load127.3 = load <4 x i8>, ptr %656, align 1, !tbaa !5, !alias.scope !47
  %657 = and <4 x i8> %wide.load126.3, <i8 15, i8 15, i8 15, i8 15>
  %658 = and <4 x i8> %wide.load127.3, <i8 15, i8 15, i8 15, i8 15>
  %659 = getelementptr inbounds i8, ptr %26, i64 40
  %660 = getelementptr inbounds i8, ptr %26, i64 44
  %wide.load128.3 = load <4 x i8>, ptr %659, align 1, !tbaa !5, !alias.scope !47
  %wide.load129.3 = load <4 x i8>, ptr %660, align 1, !tbaa !5, !alias.scope !47
  %661 = lshr <4 x i8> %wide.load128.3, <i8 2, i8 2, i8 2, i8 2>
  %662 = lshr <4 x i8> %wide.load129.3, <i8 2, i8 2, i8 2, i8 2>
  %663 = and <4 x i8> %661, <i8 16, i8 16, i8 16, i8 16>
  %664 = and <4 x i8> %662, <i8 16, i8 16, i8 16, i8 16>
  %665 = or disjoint <4 x i8> %663, %657
  %666 = or disjoint <4 x i8> %664, %658
  %667 = uitofp nneg <4 x i8> %665 to <4 x float>
  %668 = uitofp nneg <4 x i8> %666 to <4 x float>
  %669 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat131, <4 x float> %667, <4 x float> %broadcast.splat133)
  %670 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat131, <4 x float> %668, <4 x float> %broadcast.splat133)
  %671 = getelementptr i8, ptr %.lcssa91, i64 112
  store <4 x float> %669, ptr %next.gep124.3, align 4, !tbaa !11, !alias.scope !50, !noalias !47
  store <4 x float> %670, ptr %671, align 4, !tbaa !11, !alias.scope !50, !noalias !47
  br label %.preheader.3

scalar.ph116:                                     ; preds = %middle.block146, %scalar.ph116
  %indvars.iv.3 = phi i64 [ %indvars.iv.next.3.1, %scalar.ph116 ], [ 0, %middle.block146 ]
  %.258.3 = phi ptr [ %693, %scalar.ph116 ], [ %.lcssa91, %middle.block146 ]
  %672 = getelementptr inbounds i8, ptr %590, i64 %indvars.iv.3
  %673 = load i8, ptr %672, align 1, !tbaa !5
  %674 = and i8 %673, 15
  %675 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv.3
  %676 = load i8, ptr %675, align 1, !tbaa !5
  %677 = lshr i8 %676, 2
  %678 = and i8 %677, 16
  %679 = or disjoint i8 %678, %674
  %680 = uitofp nneg i8 %679 to float
  %681 = call float @llvm.fmuladd.f32(float %593, float %680, float %598)
  %682 = getelementptr i8, ptr %.258.3, i64 4
  store float %681, ptr %.258.3, align 4, !tbaa !11
  %indvars.iv.next.3 = or disjoint i64 %indvars.iv.3, 1
  %683 = getelementptr inbounds i8, ptr %590, i64 %indvars.iv.next.3
  %684 = load i8, ptr %683, align 1, !tbaa !5
  %685 = and i8 %684, 15
  %686 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv.next.3
  %687 = load i8, ptr %686, align 1, !tbaa !5
  %688 = lshr i8 %687, 2
  %689 = and i8 %688, 16
  %690 = or disjoint i8 %689, %685
  %691 = uitofp nneg i8 %690 to float
  %692 = call float @llvm.fmuladd.f32(float %593, float %691, float %598)
  %693 = getelementptr i8, ptr %.258.3, i64 8
  store float %692, ptr %682, align 4, !tbaa !11
  %indvars.iv.next.3.1 = add nuw nsw i64 %indvars.iv.3, 2
  %exitcond.3.not.1 = icmp eq i64 %indvars.iv.next.3.1, 32
  br i1 %exitcond.3.not.1, label %.preheader.3, label %scalar.ph116, !llvm.loop !52

.preheader.3:                                     ; preds = %scalar.ph116, %vector.body121
  %indvars.iv.3.lcssa = phi i64 [ 31, %vector.body121 ], [ %indvars.iv.next.3, %scalar.ph116 ]
  %.lcssa92 = phi ptr [ %ind.end119, %vector.body121 ], [ %693, %scalar.ph116 ]
  %694 = uitofp i8 %596 to float
  %695 = fmul float %30, %694
  %696 = uitofp i8 %597 to float
  %697 = fmul float %35, %696
  %698 = add nuw i64 %indvars.iv.lcssa, %indvars.iv72.lcssa
  %699 = add i64 %698, %indvars.iv.1.lcssa
  %700 = add i64 %699, %indvars.iv72.1.lcssa
  %701 = add i64 %700, %indvars.iv.2.lcssa
  %702 = add i64 %701, %indvars.iv72.2.lcssa
  %703 = add i64 %702, %indvars.iv.3.lcssa
  %704 = shl i64 %703, 2
  %705 = add i64 %704, 156
  %scevgep = getelementptr i8, ptr %.04969, i64 %705
  %bound0 = icmp ult ptr %.lcssa92, %scevgep95
  %bound1 = icmp ult ptr %scevgep94, %scevgep
  %found.conflict = and i1 %bound0, %bound1
  br i1 %found.conflict, label %scalar.ph, label %vector.body

vector.body:                                      ; preds = %.preheader.3
  %broadcast.splatinsert101 = insertelement <4 x float> poison, float %697, i64 0
  %broadcast.splat102 = shufflevector <4 x float> %broadcast.splatinsert101, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert = insertelement <4 x float> poison, float %695, i64 0
  %broadcast.splat = shufflevector <4 x float> %broadcast.splatinsert, <4 x float> poison, <4 x i32> zeroinitializer
  %ind.end = getelementptr i8, ptr %.lcssa92, i64 128
  %706 = getelementptr inbounds i8, ptr %26, i64 148
  %wide.load = load <4 x i8>, ptr %590, align 1, !tbaa !5, !alias.scope !53
  %wide.load98 = load <4 x i8>, ptr %706, align 1, !tbaa !5, !alias.scope !53
  %707 = lshr <4 x i8> %wide.load, <i8 4, i8 4, i8 4, i8 4>
  %708 = lshr <4 x i8> %wide.load98, <i8 4, i8 4, i8 4, i8 4>
  %709 = getelementptr inbounds i8, ptr %26, i64 20
  %wide.load99 = load <4 x i8>, ptr %28, align 1, !tbaa !5, !alias.scope !53
  %wide.load100 = load <4 x i8>, ptr %709, align 1, !tbaa !5, !alias.scope !53
  %710 = lshr <4 x i8> %wide.load99, <i8 3, i8 3, i8 3, i8 3>
  %711 = lshr <4 x i8> %wide.load100, <i8 3, i8 3, i8 3, i8 3>
  %712 = and <4 x i8> %710, <i8 16, i8 16, i8 16, i8 16>
  %713 = and <4 x i8> %711, <i8 16, i8 16, i8 16, i8 16>
  %714 = or disjoint <4 x i8> %712, %707
  %715 = or disjoint <4 x i8> %713, %708
  %716 = uitofp nneg <4 x i8> %714 to <4 x float>
  %717 = uitofp nneg <4 x i8> %715 to <4 x float>
  %718 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat, <4 x float> %716, <4 x float> %broadcast.splat102)
  %719 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat, <4 x float> %717, <4 x float> %broadcast.splat102)
  %720 = getelementptr i8, ptr %.lcssa92, i64 16
  store <4 x float> %718, ptr %.lcssa92, align 4, !tbaa !11, !alias.scope !56, !noalias !53
  store <4 x float> %719, ptr %720, align 4, !tbaa !11, !alias.scope !56, !noalias !53
  %next.gep.1 = getelementptr i8, ptr %.lcssa92, i64 32
  %721 = getelementptr inbounds i8, ptr %26, i64 152
  %722 = getelementptr inbounds i8, ptr %26, i64 156
  %wide.load.1 = load <4 x i8>, ptr %721, align 1, !tbaa !5, !alias.scope !53
  %wide.load98.1 = load <4 x i8>, ptr %722, align 1, !tbaa !5, !alias.scope !53
  %723 = lshr <4 x i8> %wide.load.1, <i8 4, i8 4, i8 4, i8 4>
  %724 = lshr <4 x i8> %wide.load98.1, <i8 4, i8 4, i8 4, i8 4>
  %725 = getelementptr inbounds i8, ptr %26, i64 24
  %726 = getelementptr inbounds i8, ptr %26, i64 28
  %wide.load99.1 = load <4 x i8>, ptr %725, align 1, !tbaa !5, !alias.scope !53
  %wide.load100.1 = load <4 x i8>, ptr %726, align 1, !tbaa !5, !alias.scope !53
  %727 = lshr <4 x i8> %wide.load99.1, <i8 3, i8 3, i8 3, i8 3>
  %728 = lshr <4 x i8> %wide.load100.1, <i8 3, i8 3, i8 3, i8 3>
  %729 = and <4 x i8> %727, <i8 16, i8 16, i8 16, i8 16>
  %730 = and <4 x i8> %728, <i8 16, i8 16, i8 16, i8 16>
  %731 = or disjoint <4 x i8> %729, %723
  %732 = or disjoint <4 x i8> %730, %724
  %733 = uitofp nneg <4 x i8> %731 to <4 x float>
  %734 = uitofp nneg <4 x i8> %732 to <4 x float>
  %735 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat, <4 x float> %733, <4 x float> %broadcast.splat102)
  %736 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat, <4 x float> %734, <4 x float> %broadcast.splat102)
  %737 = getelementptr i8, ptr %.lcssa92, i64 48
  store <4 x float> %735, ptr %next.gep.1, align 4, !tbaa !11, !alias.scope !56, !noalias !53
  store <4 x float> %736, ptr %737, align 4, !tbaa !11, !alias.scope !56, !noalias !53
  %next.gep.2 = getelementptr i8, ptr %.lcssa92, i64 64
  %738 = getelementptr inbounds i8, ptr %26, i64 160
  %739 = getelementptr inbounds i8, ptr %26, i64 164
  %wide.load.2 = load <4 x i8>, ptr %738, align 1, !tbaa !5, !alias.scope !53
  %wide.load98.2 = load <4 x i8>, ptr %739, align 1, !tbaa !5, !alias.scope !53
  %740 = lshr <4 x i8> %wide.load.2, <i8 4, i8 4, i8 4, i8 4>
  %741 = lshr <4 x i8> %wide.load98.2, <i8 4, i8 4, i8 4, i8 4>
  %742 = getelementptr inbounds i8, ptr %26, i64 32
  %743 = getelementptr inbounds i8, ptr %26, i64 36
  %wide.load99.2 = load <4 x i8>, ptr %742, align 1, !tbaa !5, !alias.scope !53
  %wide.load100.2 = load <4 x i8>, ptr %743, align 1, !tbaa !5, !alias.scope !53
  %744 = lshr <4 x i8> %wide.load99.2, <i8 3, i8 3, i8 3, i8 3>
  %745 = lshr <4 x i8> %wide.load100.2, <i8 3, i8 3, i8 3, i8 3>
  %746 = and <4 x i8> %744, <i8 16, i8 16, i8 16, i8 16>
  %747 = and <4 x i8> %745, <i8 16, i8 16, i8 16, i8 16>
  %748 = or disjoint <4 x i8> %746, %740
  %749 = or disjoint <4 x i8> %747, %741
  %750 = uitofp nneg <4 x i8> %748 to <4 x float>
  %751 = uitofp nneg <4 x i8> %749 to <4 x float>
  %752 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat, <4 x float> %750, <4 x float> %broadcast.splat102)
  %753 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat, <4 x float> %751, <4 x float> %broadcast.splat102)
  %754 = getelementptr i8, ptr %.lcssa92, i64 80
  store <4 x float> %752, ptr %next.gep.2, align 4, !tbaa !11, !alias.scope !56, !noalias !53
  store <4 x float> %753, ptr %754, align 4, !tbaa !11, !alias.scope !56, !noalias !53
  %next.gep.3 = getelementptr i8, ptr %.lcssa92, i64 96
  %755 = getelementptr inbounds i8, ptr %26, i64 168
  %756 = getelementptr inbounds i8, ptr %26, i64 172
  %wide.load.3 = load <4 x i8>, ptr %755, align 1, !tbaa !5, !alias.scope !53
  %wide.load98.3 = load <4 x i8>, ptr %756, align 1, !tbaa !5, !alias.scope !53
  %757 = lshr <4 x i8> %wide.load.3, <i8 4, i8 4, i8 4, i8 4>
  %758 = lshr <4 x i8> %wide.load98.3, <i8 4, i8 4, i8 4, i8 4>
  %759 = getelementptr inbounds i8, ptr %26, i64 40
  %760 = getelementptr inbounds i8, ptr %26, i64 44
  %wide.load99.3 = load <4 x i8>, ptr %759, align 1, !tbaa !5, !alias.scope !53
  %wide.load100.3 = load <4 x i8>, ptr %760, align 1, !tbaa !5, !alias.scope !53
  %761 = lshr <4 x i8> %wide.load99.3, <i8 3, i8 3, i8 3, i8 3>
  %762 = lshr <4 x i8> %wide.load100.3, <i8 3, i8 3, i8 3, i8 3>
  %763 = and <4 x i8> %761, <i8 16, i8 16, i8 16, i8 16>
  %764 = and <4 x i8> %762, <i8 16, i8 16, i8 16, i8 16>
  %765 = or disjoint <4 x i8> %763, %757
  %766 = or disjoint <4 x i8> %764, %758
  %767 = uitofp nneg <4 x i8> %765 to <4 x float>
  %768 = uitofp nneg <4 x i8> %766 to <4 x float>
  %769 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat, <4 x float> %767, <4 x float> %broadcast.splat102)
  %770 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat, <4 x float> %768, <4 x float> %broadcast.splat102)
  %771 = getelementptr i8, ptr %.lcssa92, i64 112
  store <4 x float> %769, ptr %next.gep.3, align 4, !tbaa !11, !alias.scope !56, !noalias !53
  store <4 x float> %770, ptr %771, align 4, !tbaa !11, !alias.scope !56, !noalias !53
  br label %middle.block

scalar.ph:                                        ; preds = %.preheader.3, %scalar.ph
  %indvars.iv72.3 = phi i64 [ %indvars.iv.next73.3.1, %scalar.ph ], [ 0, %.preheader.3 ]
  %.360.3 = phi ptr [ %793, %scalar.ph ], [ %.lcssa92, %.preheader.3 ]
  %772 = getelementptr inbounds i8, ptr %590, i64 %indvars.iv72.3
  %773 = load i8, ptr %772, align 1, !tbaa !5
  %774 = lshr i8 %773, 4
  %775 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv72.3
  %776 = load i8, ptr %775, align 1, !tbaa !5
  %777 = lshr i8 %776, 3
  %778 = and i8 %777, 16
  %779 = or disjoint i8 %778, %774
  %780 = uitofp nneg i8 %779 to float
  %781 = call float @llvm.fmuladd.f32(float %695, float %780, float %697)
  %782 = getelementptr inbounds i8, ptr %.360.3, i64 4
  store float %781, ptr %.360.3, align 4, !tbaa !11
  %indvars.iv.next73.3 = or disjoint i64 %indvars.iv72.3, 1
  %783 = getelementptr inbounds i8, ptr %590, i64 %indvars.iv.next73.3
  %784 = load i8, ptr %783, align 1, !tbaa !5
  %785 = lshr i8 %784, 4
  %786 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv.next73.3
  %787 = load i8, ptr %786, align 1, !tbaa !5
  %788 = lshr i8 %787, 3
  %789 = and i8 %788, 16
  %790 = or disjoint i8 %789, %785
  %791 = uitofp nneg i8 %790 to float
  %792 = call float @llvm.fmuladd.f32(float %695, float %791, float %697)
  %793 = getelementptr inbounds i8, ptr %.360.3, i64 8
  store float %792, ptr %782, align 4, !tbaa !11
  %indvars.iv.next73.3.1 = add nuw nsw i64 %indvars.iv72.3, 2
  %exitcond75.3.not.1 = icmp eq i64 %indvars.iv.next73.3.1, 32
  br i1 %exitcond75.3.not.1, label %middle.block, label %scalar.ph, !llvm.loop !58

middle.block:                                     ; preds = %scalar.ph, %vector.body
  %.lcssa93 = phi ptr [ %ind.end, %vector.body ], [ %793, %scalar.ph ]
  call void @llvm.lifetime.end.p0(i64 1, ptr nonnull %5) #7
  call void @llvm.lifetime.end.p0(i64 1, ptr nonnull %4) #7
  %indvars.iv.next77 = add nuw nsw i64 %indvars.iv76, 1
  %exitcond79.not = icmp eq i64 %indvars.iv.next77, %10
  br i1 %exitcond79.not, label %._crit_edge, label %.lr.ph, !llvm.loop !59

scalar.ph263:                                     ; preds = %.preheader, %scalar.ph263
  %indvars.iv72 = phi i64 [ %indvars.iv.next73.1340, %scalar.ph263 ], [ 0, %.preheader ]
  %.360 = phi ptr [ %815, %scalar.ph263 ], [ %.lcssa, %.preheader ]
  %794 = getelementptr inbounds i8, ptr %27, i64 %indvars.iv72
  %795 = load i8, ptr %794, align 1, !tbaa !5
  %796 = lshr i8 %795, 4
  %797 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv72
  %798 = load i8, ptr %797, align 1, !tbaa !5
  %799 = shl i8 %798, 3
  %800 = and i8 %799, 16
  %801 = or disjoint i8 %800, %796
  %802 = uitofp nneg i8 %801 to float
  %803 = call float @llvm.fmuladd.f32(float %111, float %802, float %113)
  %804 = getelementptr i8, ptr %.360, i64 4
  store float %803, ptr %.360, align 4, !tbaa !11
  %indvars.iv.next73 = or disjoint i64 %indvars.iv72, 1
  %805 = getelementptr inbounds i8, ptr %27, i64 %indvars.iv.next73
  %806 = load i8, ptr %805, align 1, !tbaa !5
  %807 = lshr i8 %806, 4
  %808 = getelementptr inbounds i8, ptr %28, i64 %indvars.iv.next73
  %809 = load i8, ptr %808, align 1, !tbaa !5
  %810 = shl i8 %809, 3
  %811 = and i8 %810, 16
  %812 = or disjoint i8 %811, %807
  %813 = uitofp nneg i8 %812 to float
  %814 = call float @llvm.fmuladd.f32(float %111, float %813, float %113)
  %815 = getelementptr i8, ptr %.360, i64 8
  store float %814, ptr %804, align 4, !tbaa !11
  %indvars.iv.next73.1340 = add nuw nsw i64 %indvars.iv72, 2
  %exitcond75.not.1 = icmp eq i64 %indvars.iv.next73.1340, 32
  br i1 %exitcond75.not.1, label %middle.block262, label %scalar.ph263, !llvm.loop !60
}

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <4 x float> @llvm.fmuladd.v4f32(<4 x float>, <4 x float>, <4 x float>) #5

attributes #0 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { inlinehint 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 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { 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 #5 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #6 = { noreturn nounwind }
attributes #7 = { 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 = !{!"omnipotent char", !7, i64 0}
!7 = !{!"Simple C/C++ TBAA"}
!8 = !{!9}
!9 = distinct !{!9, !10}
!10 = distinct !{!10, !"LVerDomain"}
!11 = !{!12, !12, i64 0}
!12 = !{!"float", !6, i64 0}
!13 = !{!14}
!14 = distinct !{!14, !10}
!15 = !{!16}
!16 = distinct !{!16, !17}
!17 = distinct !{!17, !"LVerDomain"}
!18 = !{!19}
!19 = distinct !{!19, !17}
!20 = distinct !{!20, !21, !22}
!21 = !{!"llvm.loop.mustprogress"}
!22 = !{!"llvm.loop.isvectorized", i32 1}
!23 = !{!24}
!24 = distinct !{!24, !25}
!25 = distinct !{!25, !"LVerDomain"}
!26 = !{!27}
!27 = distinct !{!27, !25}
!28 = distinct !{!28, !21, !22}
!29 = !{!30}
!30 = distinct !{!30, !31}
!31 = distinct !{!31, !"LVerDomain"}
!32 = !{!33}
!33 = distinct !{!33, !31}
!34 = distinct !{!34, !21, !22}
!35 = !{!36}
!36 = distinct !{!36, !37}
!37 = distinct !{!37, !"LVerDomain"}
!38 = !{!39}
!39 = distinct !{!39, !37}
!40 = distinct !{!40, !21, !22}
!41 = !{!42}
!42 = distinct !{!42, !43}
!43 = distinct !{!43, !"LVerDomain"}
!44 = !{!45}
!45 = distinct !{!45, !43}
!46 = distinct !{!46, !21, !22}
!47 = !{!48}
!48 = distinct !{!48, !49}
!49 = distinct !{!49, !"LVerDomain"}
!50 = !{!51}
!51 = distinct !{!51, !49}
!52 = distinct !{!52, !21, !22}
!53 = !{!54}
!54 = distinct !{!54, !55}
!55 = distinct !{!55, !"LVerDomain"}
!56 = !{!57}
!57 = distinct !{!57, !55}
!58 = distinct !{!58, !21, !22}
!59 = distinct !{!59, !21}
!60 = distinct !{!60, !21, !22}


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