; LLVM IR from libxsmm/libxsmm :: samples/equation (equation_simple_layernorm)

; 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.libxsmm_meqn_arg_metadata = type { i32, i32 }
%struct.libxsmm_meqn_op_metadata = type { i32, i32 }
%struct.libxsmm_meqn_arg_shape = type { i32, i32, i32, i32 }
%struct.libxsmm_matrix_arg_attributes = type { i32, i32, i32, i32 }
%struct.libxsmm_meqn_param = type { ptr, ptr, %struct.libxsmm_matrix_arg }
%struct.libxsmm_matrix_arg = type { ptr, ptr, ptr, ptr, ptr, ptr }

@.str = external hidden unnamed_addr constant [21 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [20 x i8], align 1
@stderr = external global ptr, align 8
@.str.2 = external hidden unnamed_addr constant [35 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local i32 @main(i32 noundef %0, ptr noundef %1) #0 {
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca ptr, align 8
  %6 = alloca i32, align 4
  %7 = alloca ptr, align 8
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca i32, align 4
  %12 = alloca i32, align 4
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  %15 = alloca i32, align 4
  %16 = alloca i32, align 4
  %17 = alloca i32, align 4
  %18 = alloca i32, align 4
  %19 = alloca %struct.libxsmm_meqn_arg_metadata, align 4
  %20 = alloca %struct.libxsmm_meqn_op_metadata, align 4
  %21 = alloca %struct.libxsmm_meqn_arg_shape, align 4
  %22 = alloca %struct.libxsmm_meqn_arg_shape, align 4
  %23 = alloca %struct.libxsmm_matrix_arg_attributes, align 4
  %24 = alloca [5 x ptr], align 16
  %25 = alloca ptr, align 8
  %26 = alloca ptr, align 8
  %27 = alloca [5 x ptr], align 16
  %28 = alloca ptr, align 8
  %29 = alloca ptr, align 8
  %30 = alloca %struct.libxsmm_meqn_param, align 8
  %31 = alloca [5 x %struct.libxsmm_matrix_arg], align 16
  %32 = alloca i32, align 4
  %33 = alloca i32, align 4
  %34 = alloca %struct.libxsmm_meqn_op_metadata, align 4
  %35 = alloca %struct.libxsmm_meqn_arg_shape, align 4
  %36 = alloca %struct.libxsmm_meqn_arg_metadata, align 4
  %37 = alloca %struct.libxsmm_meqn_arg_shape, align 4
  %38 = alloca %struct.libxsmm_meqn_arg_metadata, align 4
  %39 = alloca %struct.libxsmm_meqn_arg_shape, align 4
  %40 = alloca %struct.libxsmm_meqn_arg_metadata, align 4
  %41 = alloca %struct.libxsmm_meqn_arg_shape, align 4
  %42 = alloca %struct.libxsmm_meqn_arg_metadata, align 4
  %43 = alloca %struct.libxsmm_meqn_arg_shape, align 4
  %44 = alloca %struct.libxsmm_meqn_arg_metadata, align 4
  %45 = alloca %struct.libxsmm_meqn_arg_shape, align 4
  store i32 0, ptr %3, align 4
  store i32 %0, ptr %4, align 4, !tbaa !5
  store ptr %1, ptr %5, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #8
  call void @llvm.lifetime.start.p0(i64 16, ptr %21) #8
  call void @llvm.lifetime.start.p0(i64 16, ptr %22) #8
  call void @llvm.lifetime.start.p0(i64 16, ptr %23) #8
  %46 = call { i64, i64 } @libxsmm_create_matrix_arg_attributes(i32 noundef 0, i32 noundef 0, i32 noundef 0, i32 noundef 0)
  %47 = getelementptr inbounds { i64, i64 }, ptr %23, i32 0, i32 0
  %48 = extractvalue { i64, i64 } %46, 0
  store i64 %48, ptr %47, align 4
  %49 = getelementptr inbounds { i64, i64 }, ptr %23, i32 0, i32 1
  %50 = extractvalue { i64, i64 } %46, 1
  store i64 %50, ptr %49, align 4
  call void @llvm.lifetime.start.p0(i64 40, ptr %24) #8
  call void @llvm.memset.p0.i64(ptr align 16 %24, i8 0, i64 40, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #8
  store ptr null, ptr %25, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #8
  store ptr null, ptr %26, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 40, ptr %27) #8
  call void @llvm.memset.p0.i64(ptr align 16 %27, i8 0, i64 40, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #8
  store ptr null, ptr %28, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #8
  store ptr null, ptr %29, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 64, ptr %30) #8
  call void @llvm.lifetime.start.p0(i64 240, ptr %31) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #8
  store i32 1, ptr %32, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #8
  store i32 0, ptr %33, align 4, !tbaa !5
  %51 = load i32, ptr %4, align 4, !tbaa !5
  %52 = load ptr, ptr %5, align 8, !tbaa !9
  store i32 16, ptr %8, align 4, !tbaa !5
  store i32 64, ptr %9, align 4, !tbaa !5
  store i32 64, ptr %10, align 4, !tbaa !5
  store i32 1, ptr %16, align 4, !tbaa !5
  store i32 4, ptr %17, align 4, !tbaa !5
  store i32 4, ptr %18, align 4, !tbaa !5
  store i32 1, ptr %14, align 4, !tbaa !5
  %53 = load i32, ptr %10, align 4, !tbaa !5
  store i32 %53, ptr %15, align 4, !tbaa !5
  %54 = load i32, ptr %9, align 4, !tbaa !5
  %55 = load i32, ptr %10, align 4, !tbaa !5
  %56 = mul nsw i32 %54, %55
  store i32 %56, ptr %13, align 4, !tbaa !5
  %57 = load i32, ptr %8, align 4, !tbaa !5
  %58 = sext i32 %57 to i64
  %59 = mul i64 4, %58
  %60 = load i32, ptr %13, align 4, !tbaa !5
  %61 = sext i32 %60 to i64
  %62 = mul i64 %59, %61
  %63 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %62, i64 noundef 64)
  %64 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 0
  store ptr %63, ptr %64, align 16, !tbaa !9
  %65 = load i32, ptr %14, align 4, !tbaa !5
  %66 = sext i32 %65 to i64
  %67 = mul i64 4, %66
  %68 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %67, i64 noundef 64)
  %69 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 1
  store ptr %68, ptr %69, align 8, !tbaa !9
  %70 = load i32, ptr %14, align 4, !tbaa !5
  %71 = sext i32 %70 to i64
  %72 = mul i64 4, %71
  %73 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %72, i64 noundef 64)
  %74 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 2
  store ptr %73, ptr %74, align 16, !tbaa !9
  %75 = load i32, ptr %8, align 4, !tbaa !5
  %76 = sext i32 %75 to i64
  %77 = mul i64 4, %76
  %78 = load i32, ptr %15, align 4, !tbaa !5
  %79 = sext i32 %78 to i64
  %80 = mul i64 %77, %79
  %81 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %80, i64 noundef 64)
  %82 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 3
  store ptr %81, ptr %82, align 8, !tbaa !9
  %83 = load i32, ptr %8, align 4, !tbaa !5
  %84 = sext i32 %83 to i64
  %85 = mul i64 4, %84
  %86 = load i32, ptr %15, align 4, !tbaa !5
  %87 = sext i32 %86 to i64
  %88 = mul i64 %85, %87
  %89 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %88, i64 noundef 64)
  %90 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 4
  store ptr %89, ptr %90, align 16, !tbaa !9
  %91 = load i32, ptr %8, align 4, !tbaa !5
  %92 = sext i32 %91 to i64
  %93 = mul i64 4, %92
  %94 = load i32, ptr %13, align 4, !tbaa !5
  %95 = sext i32 %94 to i64
  %96 = mul i64 %93, %95
  %97 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %96, i64 noundef 64)
  store ptr %97, ptr %25, align 8, !tbaa !9
  %98 = load i32, ptr %8, align 4, !tbaa !5
  %99 = sext i32 %98 to i64
  %100 = mul i64 4, %99
  %101 = load i32, ptr %13, align 4, !tbaa !5
  %102 = sext i32 %101 to i64
  %103 = mul i64 %100, %102
  %104 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %103, i64 noundef 64)
  store ptr %104, ptr %26, align 8, !tbaa !9
  %105 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 0
  %106 = load ptr, ptr %105, align 16, !tbaa !9
  %107 = load i32, ptr %13, align 4, !tbaa !5
  %108 = load i32, ptr %8, align 4, !tbaa !5
  call void @init_random_matrix(i32 noundef 1, ptr noundef %106, i32 noundef 1, i32 noundef %107, i32 noundef %108, i32 noundef 0)
  %109 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 1
  %110 = load ptr, ptr %109, align 8, !tbaa !9
  %111 = load i32, ptr %14, align 4, !tbaa !5
  call void @init_random_matrix(i32 noundef 1, ptr noundef %110, i32 noundef 1, i32 noundef %111, i32 noundef 1, i32 noundef 0)
  %112 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 2
  %113 = load ptr, ptr %112, align 16, !tbaa !9
  %114 = load i32, ptr %14, align 4, !tbaa !5
  call void @init_random_matrix(i32 noundef 1, ptr noundef %113, i32 noundef 1, i32 noundef %114, i32 noundef 1, i32 noundef 0)
  %115 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 3
  %116 = load ptr, ptr %115, align 8, !tbaa !9
  %117 = load i32, ptr %15, align 4, !tbaa !5
  %118 = load i32, ptr %8, align 4, !tbaa !5
  call void @init_random_matrix(i32 noundef 1, ptr noundef %116, i32 noundef 1, i32 noundef %117, i32 noundef %118, i32 noundef 0)
  %119 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 4
  %120 = load ptr, ptr %119, align 16, !tbaa !9
  %121 = load i32, ptr %15, align 4, !tbaa !5
  %122 = load i32, ptr %8, align 4, !tbaa !5
  call void @init_random_matrix(i32 noundef 1, ptr noundef %120, i32 noundef 1, i32 noundef %121, i32 noundef %122, i32 noundef 0)
  %123 = load ptr, ptr %25, align 8, !tbaa !9
  %124 = load i32, ptr %13, align 4, !tbaa !5
  %125 = load i32, ptr %8, align 4, !tbaa !5
  call void @init_random_matrix(i32 noundef 1, ptr noundef %123, i32 noundef 1, i32 noundef %124, i32 noundef %125, i32 noundef 0)
  %126 = load i32, ptr %8, align 4, !tbaa !5
  %127 = sext i32 %126 to i64
  %128 = mul i64 1, %127
  %129 = load i32, ptr %13, align 4, !tbaa !5
  %130 = sext i32 %129 to i64
  %131 = mul i64 %128, %130
  %132 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %131, i64 noundef 64)
  %133 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 0
  store ptr %132, ptr %133, align 16, !tbaa !9
  %134 = load i32, ptr %14, align 4, !tbaa !5
  %135 = sext i32 %134 to i64
  %136 = mul i64 1, %135
  %137 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %136, i64 noundef 64)
  %138 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 1
  store ptr %137, ptr %138, align 8, !tbaa !9
  %139 = load i32, ptr %14, align 4, !tbaa !5
  %140 = sext i32 %139 to i64
  %141 = mul i64 1, %140
  %142 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %141, i64 noundef 64)
  %143 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 2
  store ptr %142, ptr %143, align 16, !tbaa !9
  %144 = load i32, ptr %8, align 4, !tbaa !5
  %145 = sext i32 %144 to i64
  %146 = mul i64 1, %145
  %147 = load i32, ptr %15, align 4, !tbaa !5
  %148 = sext i32 %147 to i64
  %149 = mul i64 %146, %148
  %150 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %149, i64 noundef 64)
  %151 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 3
  store ptr %150, ptr %151, align 8, !tbaa !9
  %152 = load i32, ptr %8, align 4, !tbaa !5
  %153 = sext i32 %152 to i64
  %154 = mul i64 1, %153
  %155 = load i32, ptr %15, align 4, !tbaa !5
  %156 = sext i32 %155 to i64
  %157 = mul i64 %154, %156
  %158 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %157, i64 noundef 64)
  %159 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 4
  store ptr %158, ptr %159, align 16, !tbaa !9
  %160 = load i32, ptr %8, align 4, !tbaa !5
  %161 = sext i32 %160 to i64
  %162 = mul i64 1, %161
  %163 = load i32, ptr %13, align 4, !tbaa !5
  %164 = sext i32 %163 to i64
  %165 = mul i64 %162, %164
  %166 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %165, i64 noundef 64)
  store ptr %166, ptr %28, align 8, !tbaa !9
  %167 = load i32, ptr %8, align 4, !tbaa !5
  %168 = sext i32 %167 to i64
  %169 = mul i64 1, %168
  %170 = load i32, ptr %13, align 4, !tbaa !5
  %171 = sext i32 %170 to i64
  %172 = mul i64 %169, %171
  %173 = call noalias ptr @libxsmm_aligned_malloc(i64 noundef %172, i64 noundef 64)
  store ptr %173, ptr %29, align 8, !tbaa !9
  %174 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 0
  %175 = load ptr, ptr %174, align 16, !tbaa !9
  %176 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 0
  %177 = load ptr, ptr %176, align 16, !tbaa !9
  %178 = load i32, ptr %8, align 4, !tbaa !5
  %179 = load i32, ptr %13, align 4, !tbaa !5
  %180 = mul nsw i32 %178, %179
  %181 = sext i32 %180 to i64
  call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %175, ptr noundef %177, i64 noundef %181)
  %182 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 1
  %183 = load ptr, ptr %182, align 8, !tbaa !9
  %184 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 1
  %185 = load ptr, ptr %184, align 8, !tbaa !9
  %186 = load i32, ptr %14, align 4, !tbaa !5
  %187 = mul nsw i32 1, %186
  %188 = sext i32 %187 to i64
  call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %183, ptr noundef %185, i64 noundef %188)
  %189 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 2
  %190 = load ptr, ptr %189, align 16, !tbaa !9
  %191 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 2
  %192 = load ptr, ptr %191, align 16, !tbaa !9
  %193 = load i32, ptr %14, align 4, !tbaa !5
  %194 = mul nsw i32 1, %193
  %195 = sext i32 %194 to i64
  call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %190, ptr noundef %192, i64 noundef %195)
  %196 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 3
  %197 = load ptr, ptr %196, align 8, !tbaa !9
  %198 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 3
  %199 = load ptr, ptr %198, align 8, !tbaa !9
  %200 = load i32, ptr %8, align 4, !tbaa !5
  %201 = load i32, ptr %15, align 4, !tbaa !5
  %202 = mul nsw i32 %200, %201
  %203 = sext i32 %202 to i64
  call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %197, ptr noundef %199, i64 noundef %203)
  %204 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 4
  %205 = load ptr, ptr %204, align 16, !tbaa !9
  %206 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 4
  %207 = load ptr, ptr %206, align 16, !tbaa !9
  %208 = load i32, ptr %8, align 4, !tbaa !5
  %209 = load i32, ptr %15, align 4, !tbaa !5
  %210 = mul nsw i32 %208, %209
  %211 = sext i32 %210 to i64
  call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %205, ptr noundef %207, i64 noundef %211)
  %212 = load ptr, ptr %25, align 8, !tbaa !9
  %213 = load ptr, ptr %28, align 8, !tbaa !9
  %214 = load i32, ptr %8, align 4, !tbaa !5
  %215 = load i32, ptr %13, align 4, !tbaa !5
  %216 = mul nsw i32 %214, %215
  %217 = sext i32 %216 to i64
  call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %212, ptr noundef %213, i64 noundef %217)
  %218 = load ptr, ptr %25, align 8, !tbaa !9
  %219 = load ptr, ptr %29, align 8, !tbaa !9
  %220 = load i32, ptr %8, align 4, !tbaa !5
  %221 = load i32, ptr %13, align 4, !tbaa !5
  %222 = mul nsw i32 %220, %221
  %223 = sext i32 %222 to i64
  call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %218, ptr noundef %219, i64 noundef %223)
  %224 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 0
  %225 = load ptr, ptr %224, align 16, !tbaa !9
  %226 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 0
  %227 = load ptr, ptr %226, align 16, !tbaa !9
  %228 = load i32, ptr %8, align 4, !tbaa !5
  %229 = load i32, ptr %13, align 4, !tbaa !5
  %230 = mul nsw i32 %228, %229
  %231 = sext i32 %230 to i64
  call void @libxsmm_convert_bf8_f32(ptr noundef %225, ptr noundef %227, i64 noundef %231)
  %232 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 1
  %233 = load ptr, ptr %232, align 8, !tbaa !9
  %234 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 1
  %235 = load ptr, ptr %234, align 8, !tbaa !9
  %236 = load i32, ptr %14, align 4, !tbaa !5
  %237 = mul nsw i32 1, %236
  %238 = sext i32 %237 to i64
  call void @libxsmm_convert_bf8_f32(ptr noundef %233, ptr noundef %235, i64 noundef %238)
  %239 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 2
  %240 = load ptr, ptr %239, align 16, !tbaa !9
  %241 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 2
  %242 = load ptr, ptr %241, align 16, !tbaa !9
  %243 = load i32, ptr %14, align 4, !tbaa !5
  %244 = mul nsw i32 1, %243
  %245 = sext i32 %244 to i64
  call void @libxsmm_convert_bf8_f32(ptr noundef %240, ptr noundef %242, i64 noundef %245)
  %246 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 3
  %247 = load ptr, ptr %246, align 8, !tbaa !9
  %248 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 3
  %249 = load ptr, ptr %248, align 8, !tbaa !9
  %250 = load i32, ptr %8, align 4, !tbaa !5
  %251 = load i32, ptr %15, align 4, !tbaa !5
  %252 = mul nsw i32 %250, %251
  %253 = sext i32 %252 to i64
  call void @libxsmm_convert_bf8_f32(ptr noundef %247, ptr noundef %249, i64 noundef %253)
  %254 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 4
  %255 = load ptr, ptr %254, align 16, !tbaa !9
  %256 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 4
  %257 = load ptr, ptr %256, align 16, !tbaa !9
  %258 = load i32, ptr %8, align 4, !tbaa !5
  %259 = load i32, ptr %15, align 4, !tbaa !5
  %260 = mul nsw i32 %258, %259
  %261 = sext i32 %260 to i64
  call void @libxsmm_convert_bf8_f32(ptr noundef %255, ptr noundef %257, i64 noundef %261)
  %262 = load ptr, ptr %28, align 8, !tbaa !9
  %263 = load ptr, ptr %25, align 8, !tbaa !9
  %264 = load i32, ptr %8, align 4, !tbaa !5
  %265 = load i32, ptr %13, align 4, !tbaa !5
  %266 = mul nsw i32 %264, %265
  %267 = sext i32 %266 to i64
  call void @libxsmm_convert_bf8_f32(ptr noundef %262, ptr noundef %263, i64 noundef %267)
  %268 = load ptr, ptr %29, align 8, !tbaa !9
  %269 = load ptr, ptr %26, align 8, !tbaa !9
  %270 = load i32, ptr %8, align 4, !tbaa !5
  %271 = load i32, ptr %13, align 4, !tbaa !5
  %272 = mul nsw i32 %270, %271
  %273 = sext i32 %272 to i64
  call void @libxsmm_convert_bf8_f32(ptr noundef %268, ptr noundef %269, i64 noundef %273)
  %274 = call i32 @libxsmm_meqn_create()
  store i32 %274, ptr %6, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #8
  %275 = load i32, ptr %6, align 4, !tbaa !5
  %276 = call i64 @libxsmm_create_meqn_op_metadata(i32 noundef %275, i32 noundef -1)
  store i64 %276, ptr %34, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %20, ptr align 4 %34, i64 8, i1 false), !tbaa.struct !11
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #8
  %277 = load i64, ptr %20, align 4
  %278 = call i32 @libxsmm_meqn_push_back_ternary_op(i64 %277, i32 noundef 1, i32 noundef 1, i32 noundef 512)
  %279 = load i64, ptr %20, align 4
  %280 = call i32 @libxsmm_meqn_push_back_ternary_op(i64 %279, i32 noundef 1, i32 noundef 1, i32 noundef 896)
  call void @llvm.lifetime.start.p0(i64 16, ptr %35) #8
  %281 = load i32, ptr %10, align 4, !tbaa !5
  %282 = load i32, ptr %8, align 4, !tbaa !5
  %283 = load i32, ptr %13, align 4, !tbaa !5
  %284 = load i32, ptr %17, align 4, !tbaa !5
  %285 = call { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef %281, i32 noundef %282, i32 noundef %283, i32 noundef %284)
  %286 = getelementptr inbounds { i64, i64 }, ptr %35, i32 0, i32 0
  %287 = extractvalue { i64, i64 } %285, 0
  store i64 %287, ptr %286, align 4
  %288 = getelementptr inbounds { i64, i64 }, ptr %35, i32 0, i32 1
  %289 = extractvalue { i64, i64 } %285, 1
  store i64 %289, ptr %288, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %21, ptr align 4 %35, i64 16, i1 false), !tbaa.struct !12
  call void @llvm.lifetime.end.p0(i64 16, ptr %35) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #8
  %290 = load i32, ptr %6, align 4, !tbaa !5
  %291 = call i64 @libxsmm_create_meqn_arg_metadata(i32 noundef %290, i32 noundef 0)
  store i64 %291, ptr %36, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %19, ptr align 4 %36, i64 8, i1 false), !tbaa.struct !11
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #8
  %292 = load i64, ptr %19, align 4
  %293 = getelementptr inbounds { i64, i64 }, ptr %21, i32 0, i32 0
  %294 = load i64, ptr %293, align 4
  %295 = getelementptr inbounds { i64, i64 }, ptr %21, i32 0, i32 1
  %296 = load i64, ptr %295, align 4
  %297 = getelementptr inbounds { i64, i64 }, ptr %23, i32 0, i32 0
  %298 = load i64, ptr %297, align 4
  %299 = getelementptr inbounds { i64, i64 }, ptr %23, i32 0, i32 1
  %300 = load i64, ptr %299, align 4
  %301 = call i32 @libxsmm_meqn_push_back_arg(i64 %292, i64 %294, i64 %296, i64 %298, i64 %300)
  call void @llvm.lifetime.start.p0(i64 16, ptr %37) #8
  %302 = load i32, ptr %14, align 4, !tbaa !5
  %303 = call { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef 1, i32 noundef 1, i32 noundef %302, i32 noundef 1)
  %304 = getelementptr inbounds { i64, i64 }, ptr %37, i32 0, i32 0
  %305 = extractvalue { i64, i64 } %303, 0
  store i64 %305, ptr %304, align 4
  %306 = getelementptr inbounds { i64, i64 }, ptr %37, i32 0, i32 1
  %307 = extractvalue { i64, i64 } %303, 1
  store i64 %307, ptr %306, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %21, ptr align 4 %37, i64 16, i1 false), !tbaa.struct !12
  call void @llvm.lifetime.end.p0(i64 16, ptr %37) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #8
  %308 = load i32, ptr %6, align 4, !tbaa !5
  %309 = call i64 @libxsmm_create_meqn_arg_metadata(i32 noundef %308, i32 noundef 1)
  store i64 %309, ptr %38, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %19, ptr align 4 %38, i64 8, i1 false), !tbaa.struct !11
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #8
  %310 = load i64, ptr %19, align 4
  %311 = getelementptr inbounds { i64, i64 }, ptr %21, i32 0, i32 0
  %312 = load i64, ptr %311, align 4
  %313 = getelementptr inbounds { i64, i64 }, ptr %21, i32 0, i32 1
  %314 = load i64, ptr %313, align 4
  %315 = getelementptr inbounds { i64, i64 }, ptr %23, i32 0, i32 0
  %316 = load i64, ptr %315, align 4
  %317 = getelementptr inbounds { i64, i64 }, ptr %23, i32 0, i32 1
  %318 = load i64, ptr %317, align 4
  %319 = call i32 @libxsmm_meqn_push_back_arg(i64 %310, i64 %312, i64 %314, i64 %316, i64 %318)
  call void @llvm.lifetime.start.p0(i64 16, ptr %39) #8
  %320 = load i32, ptr %14, align 4, !tbaa !5
  %321 = call { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef 1, i32 noundef 1, i32 noundef %320, i32 noundef 1)
  %322 = getelementptr inbounds { i64, i64 }, ptr %39, i32 0, i32 0
  %323 = extractvalue { i64, i64 } %321, 0
  store i64 %323, ptr %322, align 4
  %324 = getelementptr inbounds { i64, i64 }, ptr %39, i32 0, i32 1
  %325 = extractvalue { i64, i64 } %321, 1
  store i64 %325, ptr %324, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %21, ptr align 4 %39, i64 16, i1 false), !tbaa.struct !12
  call void @llvm.lifetime.end.p0(i64 16, ptr %39) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #8
  %326 = load i32, ptr %6, align 4, !tbaa !5
  %327 = call i64 @libxsmm_create_meqn_arg_metadata(i32 noundef %326, i32 noundef 2)
  store i64 %327, ptr %40, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %19, ptr align 4 %40, i64 8, i1 false), !tbaa.struct !11
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #8
  %328 = load i64, ptr %19, align 4
  %329 = getelementptr inbounds { i64, i64 }, ptr %21, i32 0, i32 0
  %330 = load i64, ptr %329, align 4
  %331 = getelementptr inbounds { i64, i64 }, ptr %21, i32 0, i32 1
  %332 = load i64, ptr %331, align 4
  %333 = getelementptr inbounds { i64, i64 }, ptr %23, i32 0, i32 0
  %334 = load i64, ptr %333, align 4
  %335 = getelementptr inbounds { i64, i64 }, ptr %23, i32 0, i32 1
  %336 = load i64, ptr %335, align 4
  %337 = call i32 @libxsmm_meqn_push_back_arg(i64 %328, i64 %330, i64 %332, i64 %334, i64 %336)
  call void @llvm.lifetime.start.p0(i64 16, ptr %41) #8
  %338 = load i32, ptr %10, align 4, !tbaa !5
  %339 = load i32, ptr %8, align 4, !tbaa !5
  %340 = load i32, ptr %15, align 4, !tbaa !5
  %341 = load i32, ptr %16, align 4, !tbaa !5
  %342 = call { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef %338, i32 noundef %339, i32 noundef %340, i32 noundef %341)
  %343 = getelementptr inbounds { i64, i64 }, ptr %41, i32 0, i32 0
  %344 = extractvalue { i64, i64 } %342, 0
  store i64 %344, ptr %343, align 4
  %345 = getelementptr inbounds { i64, i64 }, ptr %41, i32 0, i32 1
  %346 = extractvalue { i64, i64 } %342, 1
  store i64 %346, ptr %345, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %21, ptr align 4 %41, i64 16, i1 false), !tbaa.struct !12
  call void @llvm.lifetime.end.p0(i64 16, ptr %41) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #8
  %347 = load i32, ptr %6, align 4, !tbaa !5
  %348 = call i64 @libxsmm_create_meqn_arg_metadata(i32 noundef %347, i32 noundef 3)
  store i64 %348, ptr %42, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %19, ptr align 4 %42, i64 8, i1 false), !tbaa.struct !11
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #8
  %349 = load i64, ptr %19, align 4
  %350 = getelementptr inbounds { i64, i64 }, ptr %21, i32 0, i32 0
  %351 = load i64, ptr %350, align 4
  %352 = getelementptr inbounds { i64, i64 }, ptr %21, i32 0, i32 1
  %353 = load i64, ptr %352, align 4
  %354 = getelementptr inbounds { i64, i64 }, ptr %23, i32 0, i32 0
  %355 = load i64, ptr %354, align 4
  %356 = getelementptr inbounds { i64, i64 }, ptr %23, i32 0, i32 1
  %357 = load i64, ptr %356, align 4
  %358 = call i32 @libxsmm_meqn_push_back_arg(i64 %349, i64 %351, i64 %353, i64 %355, i64 %357)
  call void @llvm.lifetime.start.p0(i64 16, ptr %43) #8
  %359 = load i32, ptr %10, align 4, !tbaa !5
  %360 = load i32, ptr %8, align 4, !tbaa !5
  %361 = load i32, ptr %15, align 4, !tbaa !5
  %362 = load i32, ptr %16, align 4, !tbaa !5
  %363 = call { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef %359, i32 noundef %360, i32 noundef %361, i32 noundef %362)
  %364 = getelementptr inbounds { i64, i64 }, ptr %43, i32 0, i32 0
  %365 = extractvalue { i64, i64 } %363, 0
  store i64 %365, ptr %364, align 4
  %366 = getelementptr inbounds { i64, i64 }, ptr %43, i32 0, i32 1
  %367 = extractvalue { i64, i64 } %363, 1
  store i64 %367, ptr %366, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %21, ptr align 4 %43, i64 16, i1 false), !tbaa.struct !12
  call void @llvm.lifetime.end.p0(i64 16, ptr %43) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #8
  %368 = load i32, ptr %6, align 4, !tbaa !5
  %369 = call i64 @libxsmm_create_meqn_arg_metadata(i32 noundef %368, i32 noundef 4)
  store i64 %369, ptr %44, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %19, ptr align 4 %44, i64 8, i1 false), !tbaa.struct !11
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #8
  %370 = load i64, ptr %19, align 4
  %371 = getelementptr inbounds { i64, i64 }, ptr %21, i32 0, i32 0
  %372 = load i64, ptr %371, align 4
  %373 = getelementptr inbounds { i64, i64 }, ptr %21, i32 0, i32 1
  %374 = load i64, ptr %373, align 4
  %375 = getelementptr inbounds { i64, i64 }, ptr %23, i32 0, i32 0
  %376 = load i64, ptr %375, align 4
  %377 = getelementptr inbounds { i64, i64 }, ptr %23, i32 0, i32 1
  %378 = load i64, ptr %377, align 4
  %379 = call i32 @libxsmm_meqn_push_back_arg(i64 %370, i64 %372, i64 %374, i64 %376, i64 %378)
  call void @llvm.lifetime.start.p0(i64 16, ptr %45) #8
  %380 = load i32, ptr %10, align 4, !tbaa !5
  %381 = load i32, ptr %8, align 4, !tbaa !5
  %382 = load i32, ptr %13, align 4, !tbaa !5
  %383 = load i32, ptr %18, align 4, !tbaa !5
  %384 = call { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef %380, i32 noundef %381, i32 noundef %382, i32 noundef %383)
  %385 = getelementptr inbounds { i64, i64 }, ptr %45, i32 0, i32 0
  %386 = extractvalue { i64, i64 } %384, 0
  store i64 %386, ptr %385, align 4
  %387 = getelementptr inbounds { i64, i64 }, ptr %45, i32 0, i32 1
  %388 = extractvalue { i64, i64 } %384, 1
  store i64 %388, ptr %387, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %22, ptr align 4 %45, i64 16, i1 false), !tbaa.struct !12
  call void @llvm.lifetime.end.p0(i64 16, ptr %45) #8
  %389 = load i32, ptr %6, align 4, !tbaa !5
  %390 = getelementptr inbounds { i64, i64 }, ptr %22, i32 0, i32 0
  %391 = load i64, ptr %390, align 4
  %392 = getelementptr inbounds { i64, i64 }, ptr %22, i32 0, i32 1
  %393 = load i64, ptr %392, align 4
  %394 = call ptr @libxsmm_dispatch_meqn(i32 noundef %389, i64 %391, i64 %393)
  store ptr %394, ptr %7, align 8, !tbaa !9
  %395 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 0
  %396 = load ptr, ptr %395, align 16, !tbaa !9
  %397 = getelementptr inbounds [5 x %struct.libxsmm_matrix_arg], ptr %31, i64 0, i64 0
  %398 = getelementptr inbounds %struct.libxsmm_matrix_arg, ptr %397, i32 0, i32 0
  store ptr %396, ptr %398, align 16, !tbaa !13
  %399 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 1
  %400 = load ptr, ptr %399, align 8, !tbaa !9
  %401 = getelementptr inbounds [5 x %struct.libxsmm_matrix_arg], ptr %31, i64 0, i64 1
  %402 = getelementptr inbounds %struct.libxsmm_matrix_arg, ptr %401, i32 0, i32 0
  store ptr %400, ptr %402, align 16, !tbaa !13
  %403 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 2
  %404 = load ptr, ptr %403, align 16, !tbaa !9
  %405 = getelementptr inbounds [5 x %struct.libxsmm_matrix_arg], ptr %31, i64 0, i64 2
  %406 = getelementptr inbounds %struct.libxsmm_matrix_arg, ptr %405, i32 0, i32 0
  store ptr %404, ptr %406, align 16, !tbaa !13
  %407 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 3
  %408 = load ptr, ptr %407, align 8, !tbaa !9
  %409 = getelementptr inbounds [5 x %struct.libxsmm_matrix_arg], ptr %31, i64 0, i64 3
  %410 = getelementptr inbounds %struct.libxsmm_matrix_arg, ptr %409, i32 0, i32 0
  store ptr %408, ptr %410, align 16, !tbaa !13
  %411 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 4
  %412 = load ptr, ptr %411, align 16, !tbaa !9
  %413 = getelementptr inbounds [5 x %struct.libxsmm_matrix_arg], ptr %31, i64 0, i64 4
  %414 = getelementptr inbounds %struct.libxsmm_matrix_arg, ptr %413, i32 0, i32 0
  store ptr %412, ptr %414, align 16, !tbaa !13
  %415 = getelementptr inbounds [5 x %struct.libxsmm_matrix_arg], ptr %31, i64 0, i64 0
  %416 = getelementptr inbounds %struct.libxsmm_meqn_param, ptr %30, i32 0, i32 1
  store ptr %415, ptr %416, align 8, !tbaa !15
  %417 = load ptr, ptr %29, align 8, !tbaa !9
  %418 = getelementptr inbounds %struct.libxsmm_meqn_param, ptr %30, i32 0, i32 2
  %419 = getelementptr inbounds %struct.libxsmm_matrix_arg, ptr %418, i32 0, i32 0
  store ptr %417, ptr %419, align 8, !tbaa !17
  %420 = load ptr, ptr %7, align 8, !tbaa !9
  %421 = icmp ne ptr null, %420
  br i1 %421, label %422, label %544

422:                                              ; preds = %2
  %423 = load ptr, ptr %7, align 8, !tbaa !9
  call void %423(ptr noundef %30)
  store i32 0, ptr %11, align 4, !tbaa !5
  br label %424

424:                                              ; preds = %486, %422
  %425 = load i32, ptr %11, align 4, !tbaa !5
  %426 = load i32, ptr %8, align 4, !tbaa !5
  %427 = icmp slt i32 %425, %426
  br i1 %427, label %428, label %489

428:                                              ; preds = %424
  store i32 0, ptr %12, align 4, !tbaa !5
  br label %429

429:                                              ; preds = %482, %428
  %430 = load i32, ptr %12, align 4, !tbaa !5
  %431 = load i32, ptr %10, align 4, !tbaa !5
  %432 = icmp slt i32 %430, %431
  br i1 %432, label %433, label %485

433:                                              ; preds = %429
  %434 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 0
  %435 = load ptr, ptr %434, align 16, !tbaa !9
  %436 = load i32, ptr %11, align 4, !tbaa !5
  %437 = load i32, ptr %13, align 4, !tbaa !5
  %438 = mul nsw i32 %436, %437
  %439 = load i32, ptr %12, align 4, !tbaa !5
  %440 = add nsw i32 %438, %439
  %441 = sext i32 %440 to i64
  %442 = getelementptr inbounds float, ptr %435, i64 %441
  %443 = load float, ptr %442, align 4, !tbaa !18
  %444 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 1
  %445 = load ptr, ptr %444, align 8, !tbaa !9
  %446 = getelementptr inbounds float, ptr %445, i64 0
  %447 = load float, ptr %446, align 4, !tbaa !18
  %448 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 2
  %449 = load ptr, ptr %448, align 16, !tbaa !9
  %450 = getelementptr inbounds float, ptr %449, i64 0
  %451 = load float, ptr %450, align 4, !tbaa !18
  %452 = call float @llvm.fmuladd.f32(float %443, float %447, float %451)
  %453 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 3
  %454 = load ptr, ptr %453, align 8, !tbaa !9
  %455 = load i32, ptr %11, align 4, !tbaa !5
  %456 = load i32, ptr %15, align 4, !tbaa !5
  %457 = mul nsw i32 %455, %456
  %458 = load i32, ptr %12, align 4, !tbaa !5
  %459 = add nsw i32 %457, %458
  %460 = sext i32 %459 to i64
  %461 = getelementptr inbounds float, ptr %454, i64 %460
  %462 = load float, ptr %461, align 4, !tbaa !18
  %463 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 4
  %464 = load ptr, ptr %463, align 16, !tbaa !9
  %465 = load i32, ptr %11, align 4, !tbaa !5
  %466 = load i32, ptr %15, align 4, !tbaa !5
  %467 = mul nsw i32 %465, %466
  %468 = load i32, ptr %12, align 4, !tbaa !5
  %469 = add nsw i32 %467, %468
  %470 = sext i32 %469 to i64
  %471 = getelementptr inbounds float, ptr %464, i64 %470
  %472 = load float, ptr %471, align 4, !tbaa !18
  %473 = call float @llvm.fmuladd.f32(float %452, float %462, float %472)
  %474 = load ptr, ptr %25, align 8, !tbaa !9
  %475 = load i32, ptr %11, align 4, !tbaa !5
  %476 = load i32, ptr %13, align 4, !tbaa !5
  %477 = mul nsw i32 %475, %476
  %478 = load i32, ptr %12, align 4, !tbaa !5
  %479 = add nsw i32 %477, %478
  %480 = sext i32 %479 to i64
  %481 = getelementptr inbounds float, ptr %474, i64 %480
  store float %473, ptr %481, align 4, !tbaa !18
  br label %482

482:                                              ; preds = %433
  %483 = load i32, ptr %12, align 4, !tbaa !5
  %484 = add nsw i32 %483, 1
  store i32 %484, ptr %12, align 4, !tbaa !5
  br label %429, !llvm.loop !20

485:                                              ; preds = %429
  br label %486

486:                                              ; preds = %485
  %487 = load i32, ptr %11, align 4, !tbaa !5
  %488 = add nsw i32 %487, 1
  store i32 %488, ptr %11, align 4, !tbaa !5
  br label %424, !llvm.loop !22

489:                                              ; preds = %424
  %490 = load ptr, ptr %25, align 8, !tbaa !9
  %491 = load ptr, ptr %28, align 8, !tbaa !9
  %492 = load i32, ptr %8, align 4, !tbaa !5
  %493 = load i32, ptr %13, align 4, !tbaa !5
  %494 = mul nsw i32 %492, %493
  %495 = sext i32 %494 to i64
  call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %490, ptr noundef %491, i64 noundef %495)
  store i32 0, ptr %11, align 4, !tbaa !5
  br label %496

496:                                              ; preds = %533, %489
  %497 = load i32, ptr %11, align 4, !tbaa !5
  %498 = load i32, ptr %8, align 4, !tbaa !5
  %499 = icmp slt i32 %497, %498
  br i1 %499, label %500, label %536

500:                                              ; preds = %496
  store i32 0, ptr %12, align 4, !tbaa !5
  br label %501

501:                                              ; preds = %529, %500
  %502 = load i32, ptr %12, align 4, !tbaa !5
  %503 = load i32, ptr %13, align 4, !tbaa !5
  %504 = icmp slt i32 %502, %503
  br i1 %504, label %505, label %532

505:                                              ; preds = %501
  %506 = load ptr, ptr %28, align 8, !tbaa !9
  %507 = load i32, ptr %11, align 4, !tbaa !5
  %508 = load i32, ptr %13, align 4, !tbaa !5
  %509 = mul nsw i32 %507, %508
  %510 = load i32, ptr %12, align 4, !tbaa !5
  %511 = add nsw i32 %509, %510
  %512 = sext i32 %511 to i64
  %513 = getelementptr inbounds i8, ptr %506, i64 %512
  %514 = load i8, ptr %513, align 1, !tbaa !23
  %515 = zext i8 %514 to i32
  %516 = load ptr, ptr %29, align 8, !tbaa !9
  %517 = load i32, ptr %11, align 4, !tbaa !5
  %518 = load i32, ptr %13, align 4, !tbaa !5
  %519 = mul nsw i32 %517, %518
  %520 = load i32, ptr %12, align 4, !tbaa !5
  %521 = add nsw i32 %519, %520
  %522 = sext i32 %521 to i64
  %523 = getelementptr inbounds i8, ptr %516, i64 %522
  %524 = load i8, ptr %523, align 1, !tbaa !23
  %525 = zext i8 %524 to i32
  %526 = icmp ne i32 %515, %525
  br i1 %526, label %527, label %528

527:                                              ; preds = %505
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %528

528:                                              ; preds = %527, %505
  br label %529

529:                                              ; preds = %528
  %530 = load i32, ptr %12, align 4, !tbaa !5
  %531 = add nsw i32 %530, 1
  store i32 %531, ptr %12, align 4, !tbaa !5
  br label %501, !llvm.loop !24

532:                                              ; preds = %501
  br label %533

533:                                              ; preds = %532
  %534 = load i32, ptr %11, align 4, !tbaa !5
  %535 = add nsw i32 %534, 1
  store i32 %535, ptr %11, align 4, !tbaa !5
  br label %496, !llvm.loop !25

536:                                              ; preds = %496
  %537 = load i32, ptr %32, align 4, !tbaa !5
  %538 = icmp eq i32 %537, 1
  br i1 %538, label %539, label %541

539:                                              ; preds = %536
  %540 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  br label %543

541:                                              ; preds = %536
  %542 = call i32 (ptr, ...) @printf(ptr noundef @.str.1)
  br label %543

543:                                              ; preds = %541, %539
  br label %547

544:                                              ; preds = %2
  %545 = load ptr, ptr @stderr, align 8, !tbaa !9
  %546 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %545, ptr noundef @.str.2) #8
  store i32 -1, ptr %33, align 4, !tbaa !5
  br label %547

547:                                              ; preds = %544, %543
  %548 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 0
  %549 = load ptr, ptr %548, align 16, !tbaa !9
  call void @libxsmm_free(ptr noundef %549)
  %550 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 1
  %551 = load ptr, ptr %550, align 8, !tbaa !9
  call void @libxsmm_free(ptr noundef %551)
  %552 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 2
  %553 = load ptr, ptr %552, align 16, !tbaa !9
  call void @libxsmm_free(ptr noundef %553)
  %554 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 3
  %555 = load ptr, ptr %554, align 8, !tbaa !9
  call void @libxsmm_free(ptr noundef %555)
  %556 = getelementptr inbounds [5 x ptr], ptr %24, i64 0, i64 4
  %557 = load ptr, ptr %556, align 16, !tbaa !9
  call void @libxsmm_free(ptr noundef %557)
  %558 = load ptr, ptr %25, align 8, !tbaa !9
  call void @libxsmm_free(ptr noundef %558)
  %559 = load ptr, ptr %26, align 8, !tbaa !9
  call void @libxsmm_free(ptr noundef %559)
  %560 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 0
  %561 = load ptr, ptr %560, align 16, !tbaa !9
  call void @libxsmm_free(ptr noundef %561)
  %562 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 1
  %563 = load ptr, ptr %562, align 8, !tbaa !9
  call void @libxsmm_free(ptr noundef %563)
  %564 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 2
  %565 = load ptr, ptr %564, align 16, !tbaa !9
  call void @libxsmm_free(ptr noundef %565)
  %566 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 3
  %567 = load ptr, ptr %566, align 8, !tbaa !9
  call void @libxsmm_free(ptr noundef %567)
  %568 = getelementptr inbounds [5 x ptr], ptr %27, i64 0, i64 4
  %569 = load ptr, ptr %568, align 16, !tbaa !9
  call void @libxsmm_free(ptr noundef %569)
  %570 = load ptr, ptr %28, align 8, !tbaa !9
  call void @libxsmm_free(ptr noundef %570)
  %571 = load ptr, ptr %29, align 8, !tbaa !9
  call void @libxsmm_free(ptr noundef %571)
  %572 = load i32, ptr %33, align 4, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #8
  call void @llvm.lifetime.end.p0(i64 240, ptr %31) #8
  call void @llvm.lifetime.end.p0(i64 64, ptr %30) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #8
  call void @llvm.lifetime.end.p0(i64 40, ptr %27) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #8
  call void @llvm.lifetime.end.p0(i64 40, ptr %24) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr %23) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr %22) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr %21) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #8
  ret i32 %572
}

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

declare { i64, i64 } @libxsmm_create_matrix_arg_attributes(i32 noundef, i32 noundef, i32 noundef, i32 noundef) #2

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

declare noalias ptr @libxsmm_aligned_malloc(i64 noundef, i64 noundef) #2

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @init_random_matrix(i32 noundef, ptr noundef, i32 noundef, i32 noundef, i32 noundef, i32 noundef) #4

declare void @libxsmm_rne_convert_fp32_bf8(ptr noundef, ptr noundef, i64 noundef) #2

declare void @libxsmm_convert_bf8_f32(ptr noundef, ptr noundef, i64 noundef) #2

declare i32 @libxsmm_meqn_create() #2

declare i64 @libxsmm_create_meqn_op_metadata(i32 noundef, i32 noundef) #2

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #5

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

declare i32 @libxsmm_meqn_push_back_ternary_op(i64, i32 noundef, i32 noundef, i32 noundef) #2

declare { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef, i32 noundef, i32 noundef, i32 noundef) #2

declare i64 @libxsmm_create_meqn_arg_metadata(i32 noundef, i32 noundef) #2

declare i32 @libxsmm_meqn_push_back_arg(i64, i64, i64, i64, i64) #2

declare ptr @libxsmm_dispatch_meqn(i32 noundef, i64, i64) #2

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

declare i32 @printf(ptr noundef, ...) #2

; Function Attrs: nounwind
declare i32 @fprintf(ptr noundef, ptr noundef, ...) #7

declare void @libxsmm_free(ptr noundef) #2

attributes #0 = { 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 #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #4 = { 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 #5 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #6 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #7 = { 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 #8 = { 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 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"any pointer", !7, i64 0}
!11 = !{i64 0, i64 4, !5, i64 4, i64 4, !5}
!12 = !{i64 0, i64 4, !5, i64 4, i64 4, !5, i64 8, i64 4, !5, i64 12, i64 4, !5}
!13 = !{!14, !10, i64 0}
!14 = !{!"libxsmm_matrix_arg", !10, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40}
!15 = !{!16, !10, i64 8}
!16 = !{!"libxsmm_meqn_param", !10, i64 0, !10, i64 8, !14, i64 16}
!17 = !{!16, !10, i64 16}
!18 = !{!19, !19, i64 0}
!19 = !{!"float", !7, i64 0}
!20 = distinct !{!20, !21}
!21 = !{!"llvm.loop.mustprogress"}
!22 = distinct !{!22, !21}
!23 = !{!7, !7, i64 0}
!24 = distinct !{!24, !21}
!25 = distinct !{!25, !21}


; 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.libxsmm_meqn_param = type { ptr, ptr, %struct.libxsmm_matrix_arg }
%struct.libxsmm_matrix_arg = type { ptr, ptr, ptr, ptr, ptr, ptr }

@.str = external hidden unnamed_addr constant [21 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [20 x i8], align 1
@stderr = external local_unnamed_addr global ptr, align 8
@.str.2 = external hidden unnamed_addr constant [35 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local range(i32 -1, 1) i32 @main(i32 noundef %0, ptr nocapture noundef readnone %1) local_unnamed_addr #0 {
  %3 = alloca %struct.libxsmm_meqn_param, align 8
  %4 = alloca [5 x %struct.libxsmm_matrix_arg], align 16
  %5 = tail call { i64, i64 } @libxsmm_create_matrix_arg_attributes(i32 noundef 0, i32 noundef 0, i32 noundef 0, i32 noundef 0) #6
  %6 = extractvalue { i64, i64 } %5, 0
  %7 = extractvalue { i64, i64 } %5, 1
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %3) #6
  call void @llvm.lifetime.start.p0(i64 240, ptr nonnull %4) #6
  %8 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 262144, i64 noundef 64) #6
  %9 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 4, i64 noundef 64) #6
  %10 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 4, i64 noundef 64) #6
  %11 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 4096, i64 noundef 64) #6
  %12 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 4096, i64 noundef 64) #6
  %13 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 262144, i64 noundef 64) #6
  %14 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 262144, i64 noundef 64) #6
  tail call void @init_random_matrix(i32 noundef 1, ptr noundef %8, i32 noundef 1, i32 noundef 4096, i32 noundef 16, i32 noundef 0)
  tail call void @init_random_matrix(i32 noundef 1, ptr noundef %9, i32 noundef 1, i32 noundef 1, i32 noundef 1, i32 noundef 0)
  tail call void @init_random_matrix(i32 noundef 1, ptr noundef %10, i32 noundef 1, i32 noundef 1, i32 noundef 1, i32 noundef 0)
  tail call void @init_random_matrix(i32 noundef 1, ptr noundef %11, i32 noundef 1, i32 noundef 64, i32 noundef 16, i32 noundef 0)
  tail call void @init_random_matrix(i32 noundef 1, ptr noundef %12, i32 noundef 1, i32 noundef 64, i32 noundef 16, i32 noundef 0)
  tail call void @init_random_matrix(i32 noundef 1, ptr noundef %13, i32 noundef 1, i32 noundef 4096, i32 noundef 16, i32 noundef 0)
  %15 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 65536, i64 noundef 64) #6
  %16 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 1, i64 noundef 64) #6
  %17 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 1, i64 noundef 64) #6
  %18 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 1024, i64 noundef 64) #6
  %19 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 1024, i64 noundef 64) #6
  %20 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 65536, i64 noundef 64) #6
  %21 = tail call noalias ptr @libxsmm_aligned_malloc(i64 noundef 65536, i64 noundef 64) #6
  tail call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %8, ptr noundef %15, i64 noundef 65536) #6
  tail call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %9, ptr noundef %16, i64 noundef 1) #6
  tail call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %10, ptr noundef %17, i64 noundef 1) #6
  tail call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %11, ptr noundef %18, i64 noundef 1024) #6
  tail call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %12, ptr noundef %19, i64 noundef 1024) #6
  tail call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %13, ptr noundef %20, i64 noundef 65536) #6
  tail call void @libxsmm_rne_convert_fp32_bf8(ptr noundef %13, ptr noundef %21, i64 noundef 65536) #6
  tail call void @libxsmm_convert_bf8_f32(ptr noundef %15, ptr noundef %8, i64 noundef 65536) #6
  tail call void @libxsmm_convert_bf8_f32(ptr noundef %16, ptr noundef %9, i64 noundef 1) #6
  tail call void @libxsmm_convert_bf8_f32(ptr noundef %17, ptr noundef %10, i64 noundef 1) #6
  tail call void @libxsmm_convert_bf8_f32(ptr noundef %18, ptr noundef %11, i64 noundef 1024) #6
  tail call void @libxsmm_convert_bf8_f32(ptr noundef %19, ptr noundef %12, i64 noundef 1024) #6
  tail call void @libxsmm_convert_bf8_f32(ptr noundef %20, ptr noundef %13, i64 noundef 65536) #6
  tail call void @libxsmm_convert_bf8_f32(ptr noundef %21, ptr noundef %14, i64 noundef 65536) #6
  %22 = tail call i32 @libxsmm_meqn_create() #6
  %23 = tail call i64 @libxsmm_create_meqn_op_metadata(i32 noundef %22, i32 noundef -1) #6
  %24 = tail call i32 @libxsmm_meqn_push_back_ternary_op(i64 %23, i32 noundef 1, i32 noundef 1, i32 noundef 512) #6
  %25 = tail call i32 @libxsmm_meqn_push_back_ternary_op(i64 %23, i32 noundef 1, i32 noundef 1, i32 noundef 896) #6
  %26 = tail call { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef 64, i32 noundef 16, i32 noundef 4096, i32 noundef 4) #6
  %27 = extractvalue { i64, i64 } %26, 0
  %28 = extractvalue { i64, i64 } %26, 1
  %29 = tail call i64 @libxsmm_create_meqn_arg_metadata(i32 noundef %22, i32 noundef 0) #6
  %30 = tail call i32 @libxsmm_meqn_push_back_arg(i64 %29, i64 %27, i64 %28, i64 %6, i64 %7) #6
  %31 = tail call { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef 1, i32 noundef 1, i32 noundef 1, i32 noundef 1) #6
  %32 = extractvalue { i64, i64 } %31, 0
  %33 = extractvalue { i64, i64 } %31, 1
  %34 = tail call i64 @libxsmm_create_meqn_arg_metadata(i32 noundef %22, i32 noundef 1) #6
  %35 = tail call i32 @libxsmm_meqn_push_back_arg(i64 %34, i64 %32, i64 %33, i64 %6, i64 %7) #6
  %36 = tail call { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef 1, i32 noundef 1, i32 noundef 1, i32 noundef 1) #6
  %37 = extractvalue { i64, i64 } %36, 0
  %38 = extractvalue { i64, i64 } %36, 1
  %39 = tail call i64 @libxsmm_create_meqn_arg_metadata(i32 noundef %22, i32 noundef 2) #6
  %40 = tail call i32 @libxsmm_meqn_push_back_arg(i64 %39, i64 %37, i64 %38, i64 %6, i64 %7) #6
  %41 = tail call { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef 64, i32 noundef 16, i32 noundef 64, i32 noundef 1) #6
  %42 = extractvalue { i64, i64 } %41, 0
  %43 = extractvalue { i64, i64 } %41, 1
  %44 = tail call i64 @libxsmm_create_meqn_arg_metadata(i32 noundef %22, i32 noundef 3) #6
  %45 = tail call i32 @libxsmm_meqn_push_back_arg(i64 %44, i64 %42, i64 %43, i64 %6, i64 %7) #6
  %46 = tail call { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef 64, i32 noundef 16, i32 noundef 64, i32 noundef 1) #6
  %47 = extractvalue { i64, i64 } %46, 0
  %48 = extractvalue { i64, i64 } %46, 1
  %49 = tail call i64 @libxsmm_create_meqn_arg_metadata(i32 noundef %22, i32 noundef 4) #6
  %50 = tail call i32 @libxsmm_meqn_push_back_arg(i64 %49, i64 %47, i64 %48, i64 %6, i64 %7) #6
  %51 = tail call { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef 64, i32 noundef 16, i32 noundef 4096, i32 noundef 4) #6
  %52 = extractvalue { i64, i64 } %51, 0
  %53 = extractvalue { i64, i64 } %51, 1
  %54 = tail call ptr @libxsmm_dispatch_meqn(i32 noundef %22, i64 %52, i64 %53) #6
  store ptr %15, ptr %4, align 16, !tbaa !5
  %55 = getelementptr inbounds i8, ptr %4, i64 48
  store ptr %9, ptr %55, align 16, !tbaa !5
  %56 = getelementptr inbounds i8, ptr %4, i64 96
  store ptr %10, ptr %56, align 16, !tbaa !5
  %57 = getelementptr inbounds i8, ptr %4, i64 144
  store ptr %11, ptr %57, align 16, !tbaa !5
  %58 = getelementptr inbounds i8, ptr %4, i64 192
  store ptr %12, ptr %58, align 16, !tbaa !5
  %59 = getelementptr inbounds i8, ptr %3, i64 8
  store ptr %4, ptr %59, align 8, !tbaa !10
  %60 = getelementptr inbounds i8, ptr %3, i64 16
  store ptr %21, ptr %60, align 8, !tbaa !12
  %.not = icmp eq ptr %54, null
  br i1 %.not, label %1920, label %.preheader232

.preheader232:                                    ; preds = %2
  call void %54(ptr noundef nonnull %3) #6
  %61 = load float, ptr %9, align 4, !tbaa !13
  %62 = load float, ptr %10, align 4, !tbaa !13
  %broadcast.splatinsert253 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat254 = shufflevector <4 x float> %broadcast.splatinsert253, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat = shufflevector <4 x float> %broadcast.splatinsert, <4 x float> poison, <4 x i32> zeroinitializer
  %63 = getelementptr inbounds i8, ptr %8, i64 16
  %wide.load = load <4 x float>, ptr %8, align 4, !tbaa !13
  %wide.load252 = load <4 x float>, ptr %63, align 4, !tbaa !13
  %64 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %65 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load252, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %66 = getelementptr inbounds i8, ptr %11, i64 16
  %wide.load255 = load <4 x float>, ptr %11, align 4, !tbaa !13
  %wide.load256 = load <4 x float>, ptr %66, align 4, !tbaa !13
  %67 = getelementptr inbounds i8, ptr %12, i64 16
  %wide.load257 = load <4 x float>, ptr %12, align 4, !tbaa !13
  %wide.load258 = load <4 x float>, ptr %67, align 4, !tbaa !13
  %68 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %64, <4 x float> %wide.load255, <4 x float> %wide.load257)
  %69 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %65, <4 x float> %wide.load256, <4 x float> %wide.load258)
  %70 = getelementptr inbounds i8, ptr %13, i64 16
  store <4 x float> %68, ptr %13, align 4, !tbaa !13
  store <4 x float> %69, ptr %70, align 4, !tbaa !13
  %71 = getelementptr inbounds i8, ptr %8, i64 32
  %72 = getelementptr inbounds i8, ptr %8, i64 48
  %wide.load.1 = load <4 x float>, ptr %71, align 4, !tbaa !13
  %wide.load252.1 = load <4 x float>, ptr %72, align 4, !tbaa !13
  %73 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load.1, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %74 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load252.1, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %75 = getelementptr inbounds i8, ptr %11, i64 32
  %76 = getelementptr inbounds i8, ptr %11, i64 48
  %wide.load255.1 = load <4 x float>, ptr %75, align 4, !tbaa !13
  %wide.load256.1 = load <4 x float>, ptr %76, align 4, !tbaa !13
  %77 = getelementptr inbounds i8, ptr %12, i64 32
  %78 = getelementptr inbounds i8, ptr %12, i64 48
  %wide.load257.1 = load <4 x float>, ptr %77, align 4, !tbaa !13
  %wide.load258.1 = load <4 x float>, ptr %78, align 4, !tbaa !13
  %79 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %73, <4 x float> %wide.load255.1, <4 x float> %wide.load257.1)
  %80 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %74, <4 x float> %wide.load256.1, <4 x float> %wide.load258.1)
  %81 = getelementptr inbounds i8, ptr %13, i64 32
  %82 = getelementptr inbounds i8, ptr %13, i64 48
  store <4 x float> %79, ptr %81, align 4, !tbaa !13
  store <4 x float> %80, ptr %82, align 4, !tbaa !13
  %83 = getelementptr inbounds i8, ptr %8, i64 64
  %84 = getelementptr inbounds i8, ptr %8, i64 80
  %wide.load.2 = load <4 x float>, ptr %83, align 4, !tbaa !13
  %wide.load252.2 = load <4 x float>, ptr %84, align 4, !tbaa !13
  %85 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load.2, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %86 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load252.2, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %87 = getelementptr inbounds i8, ptr %11, i64 64
  %88 = getelementptr inbounds i8, ptr %11, i64 80
  %wide.load255.2 = load <4 x float>, ptr %87, align 4, !tbaa !13
  %wide.load256.2 = load <4 x float>, ptr %88, align 4, !tbaa !13
  %89 = getelementptr inbounds i8, ptr %12, i64 64
  %90 = getelementptr inbounds i8, ptr %12, i64 80
  %wide.load257.2 = load <4 x float>, ptr %89, align 4, !tbaa !13
  %wide.load258.2 = load <4 x float>, ptr %90, align 4, !tbaa !13
  %91 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %85, <4 x float> %wide.load255.2, <4 x float> %wide.load257.2)
  %92 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %86, <4 x float> %wide.load256.2, <4 x float> %wide.load258.2)
  %93 = getelementptr inbounds i8, ptr %13, i64 64
  %94 = getelementptr inbounds i8, ptr %13, i64 80
  store <4 x float> %91, ptr %93, align 4, !tbaa !13
  store <4 x float> %92, ptr %94, align 4, !tbaa !13
  %95 = getelementptr inbounds i8, ptr %8, i64 96
  %96 = getelementptr inbounds i8, ptr %8, i64 112
  %wide.load.3 = load <4 x float>, ptr %95, align 4, !tbaa !13
  %wide.load252.3 = load <4 x float>, ptr %96, align 4, !tbaa !13
  %97 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load.3, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %98 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load252.3, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %99 = getelementptr inbounds i8, ptr %11, i64 96
  %100 = getelementptr inbounds i8, ptr %11, i64 112
  %wide.load255.3 = load <4 x float>, ptr %99, align 4, !tbaa !13
  %wide.load256.3 = load <4 x float>, ptr %100, align 4, !tbaa !13
  %101 = getelementptr inbounds i8, ptr %12, i64 96
  %102 = getelementptr inbounds i8, ptr %12, i64 112
  %wide.load257.3 = load <4 x float>, ptr %101, align 4, !tbaa !13
  %wide.load258.3 = load <4 x float>, ptr %102, align 4, !tbaa !13
  %103 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %97, <4 x float> %wide.load255.3, <4 x float> %wide.load257.3)
  %104 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %98, <4 x float> %wide.load256.3, <4 x float> %wide.load258.3)
  %105 = getelementptr inbounds i8, ptr %13, i64 96
  %106 = getelementptr inbounds i8, ptr %13, i64 112
  store <4 x float> %103, ptr %105, align 4, !tbaa !13
  store <4 x float> %104, ptr %106, align 4, !tbaa !13
  %107 = getelementptr inbounds i8, ptr %8, i64 128
  %108 = getelementptr inbounds i8, ptr %8, i64 144
  %wide.load.4 = load <4 x float>, ptr %107, align 4, !tbaa !13
  %wide.load252.4 = load <4 x float>, ptr %108, align 4, !tbaa !13
  %109 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load.4, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %110 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load252.4, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %111 = getelementptr inbounds i8, ptr %11, i64 128
  %112 = getelementptr inbounds i8, ptr %11, i64 144
  %wide.load255.4 = load <4 x float>, ptr %111, align 4, !tbaa !13
  %wide.load256.4 = load <4 x float>, ptr %112, align 4, !tbaa !13
  %113 = getelementptr inbounds i8, ptr %12, i64 128
  %114 = getelementptr inbounds i8, ptr %12, i64 144
  %wide.load257.4 = load <4 x float>, ptr %113, align 4, !tbaa !13
  %wide.load258.4 = load <4 x float>, ptr %114, align 4, !tbaa !13
  %115 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %109, <4 x float> %wide.load255.4, <4 x float> %wide.load257.4)
  %116 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %110, <4 x float> %wide.load256.4, <4 x float> %wide.load258.4)
  %117 = getelementptr inbounds i8, ptr %13, i64 128
  %118 = getelementptr inbounds i8, ptr %13, i64 144
  store <4 x float> %115, ptr %117, align 4, !tbaa !13
  store <4 x float> %116, ptr %118, align 4, !tbaa !13
  %119 = getelementptr inbounds i8, ptr %8, i64 160
  %120 = getelementptr inbounds i8, ptr %8, i64 176
  %wide.load.5 = load <4 x float>, ptr %119, align 4, !tbaa !13
  %wide.load252.5 = load <4 x float>, ptr %120, align 4, !tbaa !13
  %121 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load.5, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %122 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load252.5, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %123 = getelementptr inbounds i8, ptr %11, i64 160
  %124 = getelementptr inbounds i8, ptr %11, i64 176
  %wide.load255.5 = load <4 x float>, ptr %123, align 4, !tbaa !13
  %wide.load256.5 = load <4 x float>, ptr %124, align 4, !tbaa !13
  %125 = getelementptr inbounds i8, ptr %12, i64 160
  %126 = getelementptr inbounds i8, ptr %12, i64 176
  %wide.load257.5 = load <4 x float>, ptr %125, align 4, !tbaa !13
  %wide.load258.5 = load <4 x float>, ptr %126, align 4, !tbaa !13
  %127 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %121, <4 x float> %wide.load255.5, <4 x float> %wide.load257.5)
  %128 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %122, <4 x float> %wide.load256.5, <4 x float> %wide.load258.5)
  %129 = getelementptr inbounds i8, ptr %13, i64 160
  %130 = getelementptr inbounds i8, ptr %13, i64 176
  store <4 x float> %127, ptr %129, align 4, !tbaa !13
  store <4 x float> %128, ptr %130, align 4, !tbaa !13
  %131 = getelementptr inbounds i8, ptr %8, i64 192
  %132 = getelementptr inbounds i8, ptr %8, i64 208
  %wide.load.6 = load <4 x float>, ptr %131, align 4, !tbaa !13
  %wide.load252.6 = load <4 x float>, ptr %132, align 4, !tbaa !13
  %133 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load.6, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %134 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load252.6, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %135 = getelementptr inbounds i8, ptr %11, i64 192
  %136 = getelementptr inbounds i8, ptr %11, i64 208
  %wide.load255.6 = load <4 x float>, ptr %135, align 4, !tbaa !13
  %wide.load256.6 = load <4 x float>, ptr %136, align 4, !tbaa !13
  %137 = getelementptr inbounds i8, ptr %12, i64 192
  %138 = getelementptr inbounds i8, ptr %12, i64 208
  %wide.load257.6 = load <4 x float>, ptr %137, align 4, !tbaa !13
  %wide.load258.6 = load <4 x float>, ptr %138, align 4, !tbaa !13
  %139 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %133, <4 x float> %wide.load255.6, <4 x float> %wide.load257.6)
  %140 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %134, <4 x float> %wide.load256.6, <4 x float> %wide.load258.6)
  %141 = getelementptr inbounds i8, ptr %13, i64 192
  %142 = getelementptr inbounds i8, ptr %13, i64 208
  store <4 x float> %139, ptr %141, align 4, !tbaa !13
  store <4 x float> %140, ptr %142, align 4, !tbaa !13
  %143 = getelementptr inbounds i8, ptr %8, i64 224
  %144 = getelementptr inbounds i8, ptr %8, i64 240
  %wide.load.7 = load <4 x float>, ptr %143, align 4, !tbaa !13
  %wide.load252.7 = load <4 x float>, ptr %144, align 4, !tbaa !13
  %145 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load.7, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %146 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load252.7, <4 x float> %broadcast.splat, <4 x float> %broadcast.splat254)
  %147 = getelementptr inbounds i8, ptr %11, i64 224
  %148 = getelementptr inbounds i8, ptr %11, i64 240
  %wide.load255.7 = load <4 x float>, ptr %147, align 4, !tbaa !13
  %wide.load256.7 = load <4 x float>, ptr %148, align 4, !tbaa !13
  %149 = getelementptr inbounds i8, ptr %12, i64 224
  %150 = getelementptr inbounds i8, ptr %12, i64 240
  %wide.load257.7 = load <4 x float>, ptr %149, align 4, !tbaa !13
  %wide.load258.7 = load <4 x float>, ptr %150, align 4, !tbaa !13
  %151 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %145, <4 x float> %wide.load255.7, <4 x float> %wide.load257.7)
  %152 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %146, <4 x float> %wide.load256.7, <4 x float> %wide.load258.7)
  %153 = getelementptr inbounds i8, ptr %13, i64 224
  %154 = getelementptr inbounds i8, ptr %13, i64 240
  store <4 x float> %151, ptr %153, align 4, !tbaa !13
  store <4 x float> %152, ptr %154, align 4, !tbaa !13
  %broadcast.splatinsert269 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat270 = shufflevector <4 x float> %broadcast.splatinsert269, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert267 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat268 = shufflevector <4 x float> %broadcast.splatinsert267, <4 x float> poison, <4 x i32> zeroinitializer
  %155 = getelementptr inbounds i8, ptr %8, i64 16384
  %156 = getelementptr inbounds i8, ptr %8, i64 16400
  %wide.load265 = load <4 x float>, ptr %155, align 4, !tbaa !13
  %wide.load266 = load <4 x float>, ptr %156, align 4, !tbaa !13
  %157 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load265, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %158 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load266, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %159 = getelementptr inbounds i8, ptr %11, i64 256
  %160 = getelementptr inbounds i8, ptr %11, i64 272
  %wide.load271 = load <4 x float>, ptr %159, align 4, !tbaa !13
  %wide.load272 = load <4 x float>, ptr %160, align 4, !tbaa !13
  %161 = getelementptr inbounds i8, ptr %12, i64 256
  %162 = getelementptr inbounds i8, ptr %12, i64 272
  %wide.load273 = load <4 x float>, ptr %161, align 4, !tbaa !13
  %wide.load274 = load <4 x float>, ptr %162, align 4, !tbaa !13
  %163 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %157, <4 x float> %wide.load271, <4 x float> %wide.load273)
  %164 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %158, <4 x float> %wide.load272, <4 x float> %wide.load274)
  %165 = getelementptr inbounds i8, ptr %13, i64 16384
  %166 = getelementptr inbounds i8, ptr %13, i64 16400
  store <4 x float> %163, ptr %165, align 4, !tbaa !13
  store <4 x float> %164, ptr %166, align 4, !tbaa !13
  %167 = getelementptr inbounds i8, ptr %8, i64 16416
  %168 = getelementptr inbounds i8, ptr %8, i64 16432
  %wide.load265.1 = load <4 x float>, ptr %167, align 4, !tbaa !13
  %wide.load266.1 = load <4 x float>, ptr %168, align 4, !tbaa !13
  %169 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load265.1, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %170 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load266.1, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %171 = getelementptr inbounds i8, ptr %11, i64 288
  %172 = getelementptr inbounds i8, ptr %11, i64 304
  %wide.load271.1 = load <4 x float>, ptr %171, align 4, !tbaa !13
  %wide.load272.1 = load <4 x float>, ptr %172, align 4, !tbaa !13
  %173 = getelementptr inbounds i8, ptr %12, i64 288
  %174 = getelementptr inbounds i8, ptr %12, i64 304
  %wide.load273.1 = load <4 x float>, ptr %173, align 4, !tbaa !13
  %wide.load274.1 = load <4 x float>, ptr %174, align 4, !tbaa !13
  %175 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %169, <4 x float> %wide.load271.1, <4 x float> %wide.load273.1)
  %176 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %170, <4 x float> %wide.load272.1, <4 x float> %wide.load274.1)
  %177 = getelementptr inbounds i8, ptr %13, i64 16416
  %178 = getelementptr inbounds i8, ptr %13, i64 16432
  store <4 x float> %175, ptr %177, align 4, !tbaa !13
  store <4 x float> %176, ptr %178, align 4, !tbaa !13
  %179 = getelementptr inbounds i8, ptr %8, i64 16448
  %180 = getelementptr inbounds i8, ptr %8, i64 16464
  %wide.load265.2 = load <4 x float>, ptr %179, align 4, !tbaa !13
  %wide.load266.2 = load <4 x float>, ptr %180, align 4, !tbaa !13
  %181 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load265.2, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %182 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load266.2, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %183 = getelementptr inbounds i8, ptr %11, i64 320
  %184 = getelementptr inbounds i8, ptr %11, i64 336
  %wide.load271.2 = load <4 x float>, ptr %183, align 4, !tbaa !13
  %wide.load272.2 = load <4 x float>, ptr %184, align 4, !tbaa !13
  %185 = getelementptr inbounds i8, ptr %12, i64 320
  %186 = getelementptr inbounds i8, ptr %12, i64 336
  %wide.load273.2 = load <4 x float>, ptr %185, align 4, !tbaa !13
  %wide.load274.2 = load <4 x float>, ptr %186, align 4, !tbaa !13
  %187 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %181, <4 x float> %wide.load271.2, <4 x float> %wide.load273.2)
  %188 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %182, <4 x float> %wide.load272.2, <4 x float> %wide.load274.2)
  %189 = getelementptr inbounds i8, ptr %13, i64 16448
  %190 = getelementptr inbounds i8, ptr %13, i64 16464
  store <4 x float> %187, ptr %189, align 4, !tbaa !13
  store <4 x float> %188, ptr %190, align 4, !tbaa !13
  %191 = getelementptr inbounds i8, ptr %8, i64 16480
  %192 = getelementptr inbounds i8, ptr %8, i64 16496
  %wide.load265.3 = load <4 x float>, ptr %191, align 4, !tbaa !13
  %wide.load266.3 = load <4 x float>, ptr %192, align 4, !tbaa !13
  %193 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load265.3, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %194 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load266.3, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %195 = getelementptr inbounds i8, ptr %11, i64 352
  %196 = getelementptr inbounds i8, ptr %11, i64 368
  %wide.load271.3 = load <4 x float>, ptr %195, align 4, !tbaa !13
  %wide.load272.3 = load <4 x float>, ptr %196, align 4, !tbaa !13
  %197 = getelementptr inbounds i8, ptr %12, i64 352
  %198 = getelementptr inbounds i8, ptr %12, i64 368
  %wide.load273.3 = load <4 x float>, ptr %197, align 4, !tbaa !13
  %wide.load274.3 = load <4 x float>, ptr %198, align 4, !tbaa !13
  %199 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %193, <4 x float> %wide.load271.3, <4 x float> %wide.load273.3)
  %200 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %194, <4 x float> %wide.load272.3, <4 x float> %wide.load274.3)
  %201 = getelementptr inbounds i8, ptr %13, i64 16480
  %202 = getelementptr inbounds i8, ptr %13, i64 16496
  store <4 x float> %199, ptr %201, align 4, !tbaa !13
  store <4 x float> %200, ptr %202, align 4, !tbaa !13
  %203 = getelementptr inbounds i8, ptr %8, i64 16512
  %204 = getelementptr inbounds i8, ptr %8, i64 16528
  %wide.load265.4 = load <4 x float>, ptr %203, align 4, !tbaa !13
  %wide.load266.4 = load <4 x float>, ptr %204, align 4, !tbaa !13
  %205 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load265.4, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %206 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load266.4, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %207 = getelementptr inbounds i8, ptr %11, i64 384
  %208 = getelementptr inbounds i8, ptr %11, i64 400
  %wide.load271.4 = load <4 x float>, ptr %207, align 4, !tbaa !13
  %wide.load272.4 = load <4 x float>, ptr %208, align 4, !tbaa !13
  %209 = getelementptr inbounds i8, ptr %12, i64 384
  %210 = getelementptr inbounds i8, ptr %12, i64 400
  %wide.load273.4 = load <4 x float>, ptr %209, align 4, !tbaa !13
  %wide.load274.4 = load <4 x float>, ptr %210, align 4, !tbaa !13
  %211 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %205, <4 x float> %wide.load271.4, <4 x float> %wide.load273.4)
  %212 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %206, <4 x float> %wide.load272.4, <4 x float> %wide.load274.4)
  %213 = getelementptr inbounds i8, ptr %13, i64 16512
  %214 = getelementptr inbounds i8, ptr %13, i64 16528
  store <4 x float> %211, ptr %213, align 4, !tbaa !13
  store <4 x float> %212, ptr %214, align 4, !tbaa !13
  %215 = getelementptr inbounds i8, ptr %8, i64 16544
  %216 = getelementptr inbounds i8, ptr %8, i64 16560
  %wide.load265.5 = load <4 x float>, ptr %215, align 4, !tbaa !13
  %wide.load266.5 = load <4 x float>, ptr %216, align 4, !tbaa !13
  %217 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load265.5, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %218 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load266.5, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %219 = getelementptr inbounds i8, ptr %11, i64 416
  %220 = getelementptr inbounds i8, ptr %11, i64 432
  %wide.load271.5 = load <4 x float>, ptr %219, align 4, !tbaa !13
  %wide.load272.5 = load <4 x float>, ptr %220, align 4, !tbaa !13
  %221 = getelementptr inbounds i8, ptr %12, i64 416
  %222 = getelementptr inbounds i8, ptr %12, i64 432
  %wide.load273.5 = load <4 x float>, ptr %221, align 4, !tbaa !13
  %wide.load274.5 = load <4 x float>, ptr %222, align 4, !tbaa !13
  %223 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %217, <4 x float> %wide.load271.5, <4 x float> %wide.load273.5)
  %224 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %218, <4 x float> %wide.load272.5, <4 x float> %wide.load274.5)
  %225 = getelementptr inbounds i8, ptr %13, i64 16544
  %226 = getelementptr inbounds i8, ptr %13, i64 16560
  store <4 x float> %223, ptr %225, align 4, !tbaa !13
  store <4 x float> %224, ptr %226, align 4, !tbaa !13
  %227 = getelementptr inbounds i8, ptr %8, i64 16576
  %228 = getelementptr inbounds i8, ptr %8, i64 16592
  %wide.load265.6 = load <4 x float>, ptr %227, align 4, !tbaa !13
  %wide.load266.6 = load <4 x float>, ptr %228, align 4, !tbaa !13
  %229 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load265.6, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %230 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load266.6, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %231 = getelementptr inbounds i8, ptr %11, i64 448
  %232 = getelementptr inbounds i8, ptr %11, i64 464
  %wide.load271.6 = load <4 x float>, ptr %231, align 4, !tbaa !13
  %wide.load272.6 = load <4 x float>, ptr %232, align 4, !tbaa !13
  %233 = getelementptr inbounds i8, ptr %12, i64 448
  %234 = getelementptr inbounds i8, ptr %12, i64 464
  %wide.load273.6 = load <4 x float>, ptr %233, align 4, !tbaa !13
  %wide.load274.6 = load <4 x float>, ptr %234, align 4, !tbaa !13
  %235 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %229, <4 x float> %wide.load271.6, <4 x float> %wide.load273.6)
  %236 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %230, <4 x float> %wide.load272.6, <4 x float> %wide.load274.6)
  %237 = getelementptr inbounds i8, ptr %13, i64 16576
  %238 = getelementptr inbounds i8, ptr %13, i64 16592
  store <4 x float> %235, ptr %237, align 4, !tbaa !13
  store <4 x float> %236, ptr %238, align 4, !tbaa !13
  %239 = getelementptr inbounds i8, ptr %8, i64 16608
  %240 = getelementptr inbounds i8, ptr %8, i64 16624
  %wide.load265.7 = load <4 x float>, ptr %239, align 4, !tbaa !13
  %wide.load266.7 = load <4 x float>, ptr %240, align 4, !tbaa !13
  %241 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load265.7, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %242 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load266.7, <4 x float> %broadcast.splat268, <4 x float> %broadcast.splat270)
  %243 = getelementptr inbounds i8, ptr %11, i64 480
  %244 = getelementptr inbounds i8, ptr %11, i64 496
  %wide.load271.7 = load <4 x float>, ptr %243, align 4, !tbaa !13
  %wide.load272.7 = load <4 x float>, ptr %244, align 4, !tbaa !13
  %245 = getelementptr inbounds i8, ptr %12, i64 480
  %246 = getelementptr inbounds i8, ptr %12, i64 496
  %wide.load273.7 = load <4 x float>, ptr %245, align 4, !tbaa !13
  %wide.load274.7 = load <4 x float>, ptr %246, align 4, !tbaa !13
  %247 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %241, <4 x float> %wide.load271.7, <4 x float> %wide.load273.7)
  %248 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %242, <4 x float> %wide.load272.7, <4 x float> %wide.load274.7)
  %249 = getelementptr inbounds i8, ptr %13, i64 16608
  %250 = getelementptr inbounds i8, ptr %13, i64 16624
  store <4 x float> %247, ptr %249, align 4, !tbaa !13
  store <4 x float> %248, ptr %250, align 4, !tbaa !13
  %broadcast.splatinsert286 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat287 = shufflevector <4 x float> %broadcast.splatinsert286, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert284 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat285 = shufflevector <4 x float> %broadcast.splatinsert284, <4 x float> poison, <4 x i32> zeroinitializer
  %251 = getelementptr inbounds i8, ptr %8, i64 32768
  %252 = getelementptr inbounds i8, ptr %8, i64 32784
  %wide.load282 = load <4 x float>, ptr %251, align 4, !tbaa !13
  %wide.load283 = load <4 x float>, ptr %252, align 4, !tbaa !13
  %253 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load282, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %254 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load283, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %255 = getelementptr inbounds i8, ptr %11, i64 512
  %256 = getelementptr inbounds i8, ptr %11, i64 528
  %wide.load288 = load <4 x float>, ptr %255, align 4, !tbaa !13
  %wide.load289 = load <4 x float>, ptr %256, align 4, !tbaa !13
  %257 = getelementptr inbounds i8, ptr %12, i64 512
  %258 = getelementptr inbounds i8, ptr %12, i64 528
  %wide.load290 = load <4 x float>, ptr %257, align 4, !tbaa !13
  %wide.load291 = load <4 x float>, ptr %258, align 4, !tbaa !13
  %259 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %253, <4 x float> %wide.load288, <4 x float> %wide.load290)
  %260 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %254, <4 x float> %wide.load289, <4 x float> %wide.load291)
  %261 = getelementptr inbounds i8, ptr %13, i64 32768
  %262 = getelementptr inbounds i8, ptr %13, i64 32784
  store <4 x float> %259, ptr %261, align 4, !tbaa !13
  store <4 x float> %260, ptr %262, align 4, !tbaa !13
  %263 = getelementptr inbounds i8, ptr %8, i64 32800
  %264 = getelementptr inbounds i8, ptr %8, i64 32816
  %wide.load282.1 = load <4 x float>, ptr %263, align 4, !tbaa !13
  %wide.load283.1 = load <4 x float>, ptr %264, align 4, !tbaa !13
  %265 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load282.1, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %266 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load283.1, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %267 = getelementptr inbounds i8, ptr %11, i64 544
  %268 = getelementptr inbounds i8, ptr %11, i64 560
  %wide.load288.1 = load <4 x float>, ptr %267, align 4, !tbaa !13
  %wide.load289.1 = load <4 x float>, ptr %268, align 4, !tbaa !13
  %269 = getelementptr inbounds i8, ptr %12, i64 544
  %270 = getelementptr inbounds i8, ptr %12, i64 560
  %wide.load290.1 = load <4 x float>, ptr %269, align 4, !tbaa !13
  %wide.load291.1 = load <4 x float>, ptr %270, align 4, !tbaa !13
  %271 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %265, <4 x float> %wide.load288.1, <4 x float> %wide.load290.1)
  %272 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %266, <4 x float> %wide.load289.1, <4 x float> %wide.load291.1)
  %273 = getelementptr inbounds i8, ptr %13, i64 32800
  %274 = getelementptr inbounds i8, ptr %13, i64 32816
  store <4 x float> %271, ptr %273, align 4, !tbaa !13
  store <4 x float> %272, ptr %274, align 4, !tbaa !13
  %275 = getelementptr inbounds i8, ptr %8, i64 32832
  %276 = getelementptr inbounds i8, ptr %8, i64 32848
  %wide.load282.2 = load <4 x float>, ptr %275, align 4, !tbaa !13
  %wide.load283.2 = load <4 x float>, ptr %276, align 4, !tbaa !13
  %277 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load282.2, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %278 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load283.2, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %279 = getelementptr inbounds i8, ptr %11, i64 576
  %280 = getelementptr inbounds i8, ptr %11, i64 592
  %wide.load288.2 = load <4 x float>, ptr %279, align 4, !tbaa !13
  %wide.load289.2 = load <4 x float>, ptr %280, align 4, !tbaa !13
  %281 = getelementptr inbounds i8, ptr %12, i64 576
  %282 = getelementptr inbounds i8, ptr %12, i64 592
  %wide.load290.2 = load <4 x float>, ptr %281, align 4, !tbaa !13
  %wide.load291.2 = load <4 x float>, ptr %282, align 4, !tbaa !13
  %283 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %277, <4 x float> %wide.load288.2, <4 x float> %wide.load290.2)
  %284 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %278, <4 x float> %wide.load289.2, <4 x float> %wide.load291.2)
  %285 = getelementptr inbounds i8, ptr %13, i64 32832
  %286 = getelementptr inbounds i8, ptr %13, i64 32848
  store <4 x float> %283, ptr %285, align 4, !tbaa !13
  store <4 x float> %284, ptr %286, align 4, !tbaa !13
  %287 = getelementptr inbounds i8, ptr %8, i64 32864
  %288 = getelementptr inbounds i8, ptr %8, i64 32880
  %wide.load282.3 = load <4 x float>, ptr %287, align 4, !tbaa !13
  %wide.load283.3 = load <4 x float>, ptr %288, align 4, !tbaa !13
  %289 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load282.3, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %290 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load283.3, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %291 = getelementptr inbounds i8, ptr %11, i64 608
  %292 = getelementptr inbounds i8, ptr %11, i64 624
  %wide.load288.3 = load <4 x float>, ptr %291, align 4, !tbaa !13
  %wide.load289.3 = load <4 x float>, ptr %292, align 4, !tbaa !13
  %293 = getelementptr inbounds i8, ptr %12, i64 608
  %294 = getelementptr inbounds i8, ptr %12, i64 624
  %wide.load290.3 = load <4 x float>, ptr %293, align 4, !tbaa !13
  %wide.load291.3 = load <4 x float>, ptr %294, align 4, !tbaa !13
  %295 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %289, <4 x float> %wide.load288.3, <4 x float> %wide.load290.3)
  %296 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %290, <4 x float> %wide.load289.3, <4 x float> %wide.load291.3)
  %297 = getelementptr inbounds i8, ptr %13, i64 32864
  %298 = getelementptr inbounds i8, ptr %13, i64 32880
  store <4 x float> %295, ptr %297, align 4, !tbaa !13
  store <4 x float> %296, ptr %298, align 4, !tbaa !13
  %299 = getelementptr inbounds i8, ptr %8, i64 32896
  %300 = getelementptr inbounds i8, ptr %8, i64 32912
  %wide.load282.4 = load <4 x float>, ptr %299, align 4, !tbaa !13
  %wide.load283.4 = load <4 x float>, ptr %300, align 4, !tbaa !13
  %301 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load282.4, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %302 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load283.4, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %303 = getelementptr inbounds i8, ptr %11, i64 640
  %304 = getelementptr inbounds i8, ptr %11, i64 656
  %wide.load288.4 = load <4 x float>, ptr %303, align 4, !tbaa !13
  %wide.load289.4 = load <4 x float>, ptr %304, align 4, !tbaa !13
  %305 = getelementptr inbounds i8, ptr %12, i64 640
  %306 = getelementptr inbounds i8, ptr %12, i64 656
  %wide.load290.4 = load <4 x float>, ptr %305, align 4, !tbaa !13
  %wide.load291.4 = load <4 x float>, ptr %306, align 4, !tbaa !13
  %307 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %301, <4 x float> %wide.load288.4, <4 x float> %wide.load290.4)
  %308 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %302, <4 x float> %wide.load289.4, <4 x float> %wide.load291.4)
  %309 = getelementptr inbounds i8, ptr %13, i64 32896
  %310 = getelementptr inbounds i8, ptr %13, i64 32912
  store <4 x float> %307, ptr %309, align 4, !tbaa !13
  store <4 x float> %308, ptr %310, align 4, !tbaa !13
  %311 = getelementptr inbounds i8, ptr %8, i64 32928
  %312 = getelementptr inbounds i8, ptr %8, i64 32944
  %wide.load282.5 = load <4 x float>, ptr %311, align 4, !tbaa !13
  %wide.load283.5 = load <4 x float>, ptr %312, align 4, !tbaa !13
  %313 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load282.5, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %314 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load283.5, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %315 = getelementptr inbounds i8, ptr %11, i64 672
  %316 = getelementptr inbounds i8, ptr %11, i64 688
  %wide.load288.5 = load <4 x float>, ptr %315, align 4, !tbaa !13
  %wide.load289.5 = load <4 x float>, ptr %316, align 4, !tbaa !13
  %317 = getelementptr inbounds i8, ptr %12, i64 672
  %318 = getelementptr inbounds i8, ptr %12, i64 688
  %wide.load290.5 = load <4 x float>, ptr %317, align 4, !tbaa !13
  %wide.load291.5 = load <4 x float>, ptr %318, align 4, !tbaa !13
  %319 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %313, <4 x float> %wide.load288.5, <4 x float> %wide.load290.5)
  %320 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %314, <4 x float> %wide.load289.5, <4 x float> %wide.load291.5)
  %321 = getelementptr inbounds i8, ptr %13, i64 32928
  %322 = getelementptr inbounds i8, ptr %13, i64 32944
  store <4 x float> %319, ptr %321, align 4, !tbaa !13
  store <4 x float> %320, ptr %322, align 4, !tbaa !13
  %323 = getelementptr inbounds i8, ptr %8, i64 32960
  %324 = getelementptr inbounds i8, ptr %8, i64 32976
  %wide.load282.6 = load <4 x float>, ptr %323, align 4, !tbaa !13
  %wide.load283.6 = load <4 x float>, ptr %324, align 4, !tbaa !13
  %325 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load282.6, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %326 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load283.6, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %327 = getelementptr inbounds i8, ptr %11, i64 704
  %328 = getelementptr inbounds i8, ptr %11, i64 720
  %wide.load288.6 = load <4 x float>, ptr %327, align 4, !tbaa !13
  %wide.load289.6 = load <4 x float>, ptr %328, align 4, !tbaa !13
  %329 = getelementptr inbounds i8, ptr %12, i64 704
  %330 = getelementptr inbounds i8, ptr %12, i64 720
  %wide.load290.6 = load <4 x float>, ptr %329, align 4, !tbaa !13
  %wide.load291.6 = load <4 x float>, ptr %330, align 4, !tbaa !13
  %331 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %325, <4 x float> %wide.load288.6, <4 x float> %wide.load290.6)
  %332 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %326, <4 x float> %wide.load289.6, <4 x float> %wide.load291.6)
  %333 = getelementptr inbounds i8, ptr %13, i64 32960
  %334 = getelementptr inbounds i8, ptr %13, i64 32976
  store <4 x float> %331, ptr %333, align 4, !tbaa !13
  store <4 x float> %332, ptr %334, align 4, !tbaa !13
  %335 = getelementptr inbounds i8, ptr %8, i64 32992
  %336 = getelementptr inbounds i8, ptr %8, i64 33008
  %wide.load282.7 = load <4 x float>, ptr %335, align 4, !tbaa !13
  %wide.load283.7 = load <4 x float>, ptr %336, align 4, !tbaa !13
  %337 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load282.7, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %338 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load283.7, <4 x float> %broadcast.splat285, <4 x float> %broadcast.splat287)
  %339 = getelementptr inbounds i8, ptr %11, i64 736
  %340 = getelementptr inbounds i8, ptr %11, i64 752
  %wide.load288.7 = load <4 x float>, ptr %339, align 4, !tbaa !13
  %wide.load289.7 = load <4 x float>, ptr %340, align 4, !tbaa !13
  %341 = getelementptr inbounds i8, ptr %12, i64 736
  %342 = getelementptr inbounds i8, ptr %12, i64 752
  %wide.load290.7 = load <4 x float>, ptr %341, align 4, !tbaa !13
  %wide.load291.7 = load <4 x float>, ptr %342, align 4, !tbaa !13
  %343 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %337, <4 x float> %wide.load288.7, <4 x float> %wide.load290.7)
  %344 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %338, <4 x float> %wide.load289.7, <4 x float> %wide.load291.7)
  %345 = getelementptr inbounds i8, ptr %13, i64 32992
  %346 = getelementptr inbounds i8, ptr %13, i64 33008
  store <4 x float> %343, ptr %345, align 4, !tbaa !13
  store <4 x float> %344, ptr %346, align 4, !tbaa !13
  %broadcast.splatinsert303 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat304 = shufflevector <4 x float> %broadcast.splatinsert303, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert301 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat302 = shufflevector <4 x float> %broadcast.splatinsert301, <4 x float> poison, <4 x i32> zeroinitializer
  %347 = getelementptr inbounds i8, ptr %8, i64 49152
  %348 = getelementptr inbounds i8, ptr %8, i64 49168
  %wide.load299 = load <4 x float>, ptr %347, align 4, !tbaa !13
  %wide.load300 = load <4 x float>, ptr %348, align 4, !tbaa !13
  %349 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load299, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %350 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load300, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %351 = getelementptr inbounds i8, ptr %11, i64 768
  %352 = getelementptr inbounds i8, ptr %11, i64 784
  %wide.load305 = load <4 x float>, ptr %351, align 4, !tbaa !13
  %wide.load306 = load <4 x float>, ptr %352, align 4, !tbaa !13
  %353 = getelementptr inbounds i8, ptr %12, i64 768
  %354 = getelementptr inbounds i8, ptr %12, i64 784
  %wide.load307 = load <4 x float>, ptr %353, align 4, !tbaa !13
  %wide.load308 = load <4 x float>, ptr %354, align 4, !tbaa !13
  %355 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %349, <4 x float> %wide.load305, <4 x float> %wide.load307)
  %356 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %350, <4 x float> %wide.load306, <4 x float> %wide.load308)
  %357 = getelementptr inbounds i8, ptr %13, i64 49152
  %358 = getelementptr inbounds i8, ptr %13, i64 49168
  store <4 x float> %355, ptr %357, align 4, !tbaa !13
  store <4 x float> %356, ptr %358, align 4, !tbaa !13
  %359 = getelementptr inbounds i8, ptr %8, i64 49184
  %360 = getelementptr inbounds i8, ptr %8, i64 49200
  %wide.load299.1 = load <4 x float>, ptr %359, align 4, !tbaa !13
  %wide.load300.1 = load <4 x float>, ptr %360, align 4, !tbaa !13
  %361 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load299.1, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %362 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load300.1, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %363 = getelementptr inbounds i8, ptr %11, i64 800
  %364 = getelementptr inbounds i8, ptr %11, i64 816
  %wide.load305.1 = load <4 x float>, ptr %363, align 4, !tbaa !13
  %wide.load306.1 = load <4 x float>, ptr %364, align 4, !tbaa !13
  %365 = getelementptr inbounds i8, ptr %12, i64 800
  %366 = getelementptr inbounds i8, ptr %12, i64 816
  %wide.load307.1 = load <4 x float>, ptr %365, align 4, !tbaa !13
  %wide.load308.1 = load <4 x float>, ptr %366, align 4, !tbaa !13
  %367 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %361, <4 x float> %wide.load305.1, <4 x float> %wide.load307.1)
  %368 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %362, <4 x float> %wide.load306.1, <4 x float> %wide.load308.1)
  %369 = getelementptr inbounds i8, ptr %13, i64 49184
  %370 = getelementptr inbounds i8, ptr %13, i64 49200
  store <4 x float> %367, ptr %369, align 4, !tbaa !13
  store <4 x float> %368, ptr %370, align 4, !tbaa !13
  %371 = getelementptr inbounds i8, ptr %8, i64 49216
  %372 = getelementptr inbounds i8, ptr %8, i64 49232
  %wide.load299.2 = load <4 x float>, ptr %371, align 4, !tbaa !13
  %wide.load300.2 = load <4 x float>, ptr %372, align 4, !tbaa !13
  %373 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load299.2, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %374 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load300.2, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %375 = getelementptr inbounds i8, ptr %11, i64 832
  %376 = getelementptr inbounds i8, ptr %11, i64 848
  %wide.load305.2 = load <4 x float>, ptr %375, align 4, !tbaa !13
  %wide.load306.2 = load <4 x float>, ptr %376, align 4, !tbaa !13
  %377 = getelementptr inbounds i8, ptr %12, i64 832
  %378 = getelementptr inbounds i8, ptr %12, i64 848
  %wide.load307.2 = load <4 x float>, ptr %377, align 4, !tbaa !13
  %wide.load308.2 = load <4 x float>, ptr %378, align 4, !tbaa !13
  %379 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %373, <4 x float> %wide.load305.2, <4 x float> %wide.load307.2)
  %380 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %374, <4 x float> %wide.load306.2, <4 x float> %wide.load308.2)
  %381 = getelementptr inbounds i8, ptr %13, i64 49216
  %382 = getelementptr inbounds i8, ptr %13, i64 49232
  store <4 x float> %379, ptr %381, align 4, !tbaa !13
  store <4 x float> %380, ptr %382, align 4, !tbaa !13
  %383 = getelementptr inbounds i8, ptr %8, i64 49248
  %384 = getelementptr inbounds i8, ptr %8, i64 49264
  %wide.load299.3 = load <4 x float>, ptr %383, align 4, !tbaa !13
  %wide.load300.3 = load <4 x float>, ptr %384, align 4, !tbaa !13
  %385 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load299.3, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %386 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load300.3, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %387 = getelementptr inbounds i8, ptr %11, i64 864
  %388 = getelementptr inbounds i8, ptr %11, i64 880
  %wide.load305.3 = load <4 x float>, ptr %387, align 4, !tbaa !13
  %wide.load306.3 = load <4 x float>, ptr %388, align 4, !tbaa !13
  %389 = getelementptr inbounds i8, ptr %12, i64 864
  %390 = getelementptr inbounds i8, ptr %12, i64 880
  %wide.load307.3 = load <4 x float>, ptr %389, align 4, !tbaa !13
  %wide.load308.3 = load <4 x float>, ptr %390, align 4, !tbaa !13
  %391 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %385, <4 x float> %wide.load305.3, <4 x float> %wide.load307.3)
  %392 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %386, <4 x float> %wide.load306.3, <4 x float> %wide.load308.3)
  %393 = getelementptr inbounds i8, ptr %13, i64 49248
  %394 = getelementptr inbounds i8, ptr %13, i64 49264
  store <4 x float> %391, ptr %393, align 4, !tbaa !13
  store <4 x float> %392, ptr %394, align 4, !tbaa !13
  %395 = getelementptr inbounds i8, ptr %8, i64 49280
  %396 = getelementptr inbounds i8, ptr %8, i64 49296
  %wide.load299.4 = load <4 x float>, ptr %395, align 4, !tbaa !13
  %wide.load300.4 = load <4 x float>, ptr %396, align 4, !tbaa !13
  %397 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load299.4, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %398 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load300.4, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %399 = getelementptr inbounds i8, ptr %11, i64 896
  %400 = getelementptr inbounds i8, ptr %11, i64 912
  %wide.load305.4 = load <4 x float>, ptr %399, align 4, !tbaa !13
  %wide.load306.4 = load <4 x float>, ptr %400, align 4, !tbaa !13
  %401 = getelementptr inbounds i8, ptr %12, i64 896
  %402 = getelementptr inbounds i8, ptr %12, i64 912
  %wide.load307.4 = load <4 x float>, ptr %401, align 4, !tbaa !13
  %wide.load308.4 = load <4 x float>, ptr %402, align 4, !tbaa !13
  %403 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %397, <4 x float> %wide.load305.4, <4 x float> %wide.load307.4)
  %404 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %398, <4 x float> %wide.load306.4, <4 x float> %wide.load308.4)
  %405 = getelementptr inbounds i8, ptr %13, i64 49280
  %406 = getelementptr inbounds i8, ptr %13, i64 49296
  store <4 x float> %403, ptr %405, align 4, !tbaa !13
  store <4 x float> %404, ptr %406, align 4, !tbaa !13
  %407 = getelementptr inbounds i8, ptr %8, i64 49312
  %408 = getelementptr inbounds i8, ptr %8, i64 49328
  %wide.load299.5 = load <4 x float>, ptr %407, align 4, !tbaa !13
  %wide.load300.5 = load <4 x float>, ptr %408, align 4, !tbaa !13
  %409 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load299.5, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %410 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load300.5, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %411 = getelementptr inbounds i8, ptr %11, i64 928
  %412 = getelementptr inbounds i8, ptr %11, i64 944
  %wide.load305.5 = load <4 x float>, ptr %411, align 4, !tbaa !13
  %wide.load306.5 = load <4 x float>, ptr %412, align 4, !tbaa !13
  %413 = getelementptr inbounds i8, ptr %12, i64 928
  %414 = getelementptr inbounds i8, ptr %12, i64 944
  %wide.load307.5 = load <4 x float>, ptr %413, align 4, !tbaa !13
  %wide.load308.5 = load <4 x float>, ptr %414, align 4, !tbaa !13
  %415 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %409, <4 x float> %wide.load305.5, <4 x float> %wide.load307.5)
  %416 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %410, <4 x float> %wide.load306.5, <4 x float> %wide.load308.5)
  %417 = getelementptr inbounds i8, ptr %13, i64 49312
  %418 = getelementptr inbounds i8, ptr %13, i64 49328
  store <4 x float> %415, ptr %417, align 4, !tbaa !13
  store <4 x float> %416, ptr %418, align 4, !tbaa !13
  %419 = getelementptr inbounds i8, ptr %8, i64 49344
  %420 = getelementptr inbounds i8, ptr %8, i64 49360
  %wide.load299.6 = load <4 x float>, ptr %419, align 4, !tbaa !13
  %wide.load300.6 = load <4 x float>, ptr %420, align 4, !tbaa !13
  %421 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load299.6, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %422 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load300.6, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %423 = getelementptr inbounds i8, ptr %11, i64 960
  %424 = getelementptr inbounds i8, ptr %11, i64 976
  %wide.load305.6 = load <4 x float>, ptr %423, align 4, !tbaa !13
  %wide.load306.6 = load <4 x float>, ptr %424, align 4, !tbaa !13
  %425 = getelementptr inbounds i8, ptr %12, i64 960
  %426 = getelementptr inbounds i8, ptr %12, i64 976
  %wide.load307.6 = load <4 x float>, ptr %425, align 4, !tbaa !13
  %wide.load308.6 = load <4 x float>, ptr %426, align 4, !tbaa !13
  %427 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %421, <4 x float> %wide.load305.6, <4 x float> %wide.load307.6)
  %428 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %422, <4 x float> %wide.load306.6, <4 x float> %wide.load308.6)
  %429 = getelementptr inbounds i8, ptr %13, i64 49344
  %430 = getelementptr inbounds i8, ptr %13, i64 49360
  store <4 x float> %427, ptr %429, align 4, !tbaa !13
  store <4 x float> %428, ptr %430, align 4, !tbaa !13
  %431 = getelementptr inbounds i8, ptr %8, i64 49376
  %432 = getelementptr inbounds i8, ptr %8, i64 49392
  %wide.load299.7 = load <4 x float>, ptr %431, align 4, !tbaa !13
  %wide.load300.7 = load <4 x float>, ptr %432, align 4, !tbaa !13
  %433 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load299.7, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %434 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load300.7, <4 x float> %broadcast.splat302, <4 x float> %broadcast.splat304)
  %435 = getelementptr inbounds i8, ptr %11, i64 992
  %436 = getelementptr inbounds i8, ptr %11, i64 1008
  %wide.load305.7 = load <4 x float>, ptr %435, align 4, !tbaa !13
  %wide.load306.7 = load <4 x float>, ptr %436, align 4, !tbaa !13
  %437 = getelementptr inbounds i8, ptr %12, i64 992
  %438 = getelementptr inbounds i8, ptr %12, i64 1008
  %wide.load307.7 = load <4 x float>, ptr %437, align 4, !tbaa !13
  %wide.load308.7 = load <4 x float>, ptr %438, align 4, !tbaa !13
  %439 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %433, <4 x float> %wide.load305.7, <4 x float> %wide.load307.7)
  %440 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %434, <4 x float> %wide.load306.7, <4 x float> %wide.load308.7)
  %441 = getelementptr inbounds i8, ptr %13, i64 49376
  %442 = getelementptr inbounds i8, ptr %13, i64 49392
  store <4 x float> %439, ptr %441, align 4, !tbaa !13
  store <4 x float> %440, ptr %442, align 4, !tbaa !13
  %broadcast.splatinsert320 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat321 = shufflevector <4 x float> %broadcast.splatinsert320, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert318 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat319 = shufflevector <4 x float> %broadcast.splatinsert318, <4 x float> poison, <4 x i32> zeroinitializer
  %443 = getelementptr inbounds i8, ptr %8, i64 65536
  %444 = getelementptr inbounds i8, ptr %8, i64 65552
  %wide.load316 = load <4 x float>, ptr %443, align 4, !tbaa !13
  %wide.load317 = load <4 x float>, ptr %444, align 4, !tbaa !13
  %445 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load316, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %446 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load317, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %447 = getelementptr inbounds i8, ptr %11, i64 1024
  %448 = getelementptr inbounds i8, ptr %11, i64 1040
  %wide.load322 = load <4 x float>, ptr %447, align 4, !tbaa !13
  %wide.load323 = load <4 x float>, ptr %448, align 4, !tbaa !13
  %449 = getelementptr inbounds i8, ptr %12, i64 1024
  %450 = getelementptr inbounds i8, ptr %12, i64 1040
  %wide.load324 = load <4 x float>, ptr %449, align 4, !tbaa !13
  %wide.load325 = load <4 x float>, ptr %450, align 4, !tbaa !13
  %451 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %445, <4 x float> %wide.load322, <4 x float> %wide.load324)
  %452 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %446, <4 x float> %wide.load323, <4 x float> %wide.load325)
  %453 = getelementptr inbounds i8, ptr %13, i64 65536
  %454 = getelementptr inbounds i8, ptr %13, i64 65552
  store <4 x float> %451, ptr %453, align 4, !tbaa !13
  store <4 x float> %452, ptr %454, align 4, !tbaa !13
  %455 = getelementptr inbounds i8, ptr %8, i64 65568
  %456 = getelementptr inbounds i8, ptr %8, i64 65584
  %wide.load316.1 = load <4 x float>, ptr %455, align 4, !tbaa !13
  %wide.load317.1 = load <4 x float>, ptr %456, align 4, !tbaa !13
  %457 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load316.1, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %458 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load317.1, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %459 = getelementptr inbounds i8, ptr %11, i64 1056
  %460 = getelementptr inbounds i8, ptr %11, i64 1072
  %wide.load322.1 = load <4 x float>, ptr %459, align 4, !tbaa !13
  %wide.load323.1 = load <4 x float>, ptr %460, align 4, !tbaa !13
  %461 = getelementptr inbounds i8, ptr %12, i64 1056
  %462 = getelementptr inbounds i8, ptr %12, i64 1072
  %wide.load324.1 = load <4 x float>, ptr %461, align 4, !tbaa !13
  %wide.load325.1 = load <4 x float>, ptr %462, align 4, !tbaa !13
  %463 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %457, <4 x float> %wide.load322.1, <4 x float> %wide.load324.1)
  %464 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %458, <4 x float> %wide.load323.1, <4 x float> %wide.load325.1)
  %465 = getelementptr inbounds i8, ptr %13, i64 65568
  %466 = getelementptr inbounds i8, ptr %13, i64 65584
  store <4 x float> %463, ptr %465, align 4, !tbaa !13
  store <4 x float> %464, ptr %466, align 4, !tbaa !13
  %467 = getelementptr inbounds i8, ptr %8, i64 65600
  %468 = getelementptr inbounds i8, ptr %8, i64 65616
  %wide.load316.2 = load <4 x float>, ptr %467, align 4, !tbaa !13
  %wide.load317.2 = load <4 x float>, ptr %468, align 4, !tbaa !13
  %469 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load316.2, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %470 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load317.2, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %471 = getelementptr inbounds i8, ptr %11, i64 1088
  %472 = getelementptr inbounds i8, ptr %11, i64 1104
  %wide.load322.2 = load <4 x float>, ptr %471, align 4, !tbaa !13
  %wide.load323.2 = load <4 x float>, ptr %472, align 4, !tbaa !13
  %473 = getelementptr inbounds i8, ptr %12, i64 1088
  %474 = getelementptr inbounds i8, ptr %12, i64 1104
  %wide.load324.2 = load <4 x float>, ptr %473, align 4, !tbaa !13
  %wide.load325.2 = load <4 x float>, ptr %474, align 4, !tbaa !13
  %475 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %469, <4 x float> %wide.load322.2, <4 x float> %wide.load324.2)
  %476 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %470, <4 x float> %wide.load323.2, <4 x float> %wide.load325.2)
  %477 = getelementptr inbounds i8, ptr %13, i64 65600
  %478 = getelementptr inbounds i8, ptr %13, i64 65616
  store <4 x float> %475, ptr %477, align 4, !tbaa !13
  store <4 x float> %476, ptr %478, align 4, !tbaa !13
  %479 = getelementptr inbounds i8, ptr %8, i64 65632
  %480 = getelementptr inbounds i8, ptr %8, i64 65648
  %wide.load316.3 = load <4 x float>, ptr %479, align 4, !tbaa !13
  %wide.load317.3 = load <4 x float>, ptr %480, align 4, !tbaa !13
  %481 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load316.3, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %482 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load317.3, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %483 = getelementptr inbounds i8, ptr %11, i64 1120
  %484 = getelementptr inbounds i8, ptr %11, i64 1136
  %wide.load322.3 = load <4 x float>, ptr %483, align 4, !tbaa !13
  %wide.load323.3 = load <4 x float>, ptr %484, align 4, !tbaa !13
  %485 = getelementptr inbounds i8, ptr %12, i64 1120
  %486 = getelementptr inbounds i8, ptr %12, i64 1136
  %wide.load324.3 = load <4 x float>, ptr %485, align 4, !tbaa !13
  %wide.load325.3 = load <4 x float>, ptr %486, align 4, !tbaa !13
  %487 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %481, <4 x float> %wide.load322.3, <4 x float> %wide.load324.3)
  %488 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %482, <4 x float> %wide.load323.3, <4 x float> %wide.load325.3)
  %489 = getelementptr inbounds i8, ptr %13, i64 65632
  %490 = getelementptr inbounds i8, ptr %13, i64 65648
  store <4 x float> %487, ptr %489, align 4, !tbaa !13
  store <4 x float> %488, ptr %490, align 4, !tbaa !13
  %491 = getelementptr inbounds i8, ptr %8, i64 65664
  %492 = getelementptr inbounds i8, ptr %8, i64 65680
  %wide.load316.4 = load <4 x float>, ptr %491, align 4, !tbaa !13
  %wide.load317.4 = load <4 x float>, ptr %492, align 4, !tbaa !13
  %493 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load316.4, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %494 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load317.4, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %495 = getelementptr inbounds i8, ptr %11, i64 1152
  %496 = getelementptr inbounds i8, ptr %11, i64 1168
  %wide.load322.4 = load <4 x float>, ptr %495, align 4, !tbaa !13
  %wide.load323.4 = load <4 x float>, ptr %496, align 4, !tbaa !13
  %497 = getelementptr inbounds i8, ptr %12, i64 1152
  %498 = getelementptr inbounds i8, ptr %12, i64 1168
  %wide.load324.4 = load <4 x float>, ptr %497, align 4, !tbaa !13
  %wide.load325.4 = load <4 x float>, ptr %498, align 4, !tbaa !13
  %499 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %493, <4 x float> %wide.load322.4, <4 x float> %wide.load324.4)
  %500 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %494, <4 x float> %wide.load323.4, <4 x float> %wide.load325.4)
  %501 = getelementptr inbounds i8, ptr %13, i64 65664
  %502 = getelementptr inbounds i8, ptr %13, i64 65680
  store <4 x float> %499, ptr %501, align 4, !tbaa !13
  store <4 x float> %500, ptr %502, align 4, !tbaa !13
  %503 = getelementptr inbounds i8, ptr %8, i64 65696
  %504 = getelementptr inbounds i8, ptr %8, i64 65712
  %wide.load316.5 = load <4 x float>, ptr %503, align 4, !tbaa !13
  %wide.load317.5 = load <4 x float>, ptr %504, align 4, !tbaa !13
  %505 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load316.5, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %506 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load317.5, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %507 = getelementptr inbounds i8, ptr %11, i64 1184
  %508 = getelementptr inbounds i8, ptr %11, i64 1200
  %wide.load322.5 = load <4 x float>, ptr %507, align 4, !tbaa !13
  %wide.load323.5 = load <4 x float>, ptr %508, align 4, !tbaa !13
  %509 = getelementptr inbounds i8, ptr %12, i64 1184
  %510 = getelementptr inbounds i8, ptr %12, i64 1200
  %wide.load324.5 = load <4 x float>, ptr %509, align 4, !tbaa !13
  %wide.load325.5 = load <4 x float>, ptr %510, align 4, !tbaa !13
  %511 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %505, <4 x float> %wide.load322.5, <4 x float> %wide.load324.5)
  %512 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %506, <4 x float> %wide.load323.5, <4 x float> %wide.load325.5)
  %513 = getelementptr inbounds i8, ptr %13, i64 65696
  %514 = getelementptr inbounds i8, ptr %13, i64 65712
  store <4 x float> %511, ptr %513, align 4, !tbaa !13
  store <4 x float> %512, ptr %514, align 4, !tbaa !13
  %515 = getelementptr inbounds i8, ptr %8, i64 65728
  %516 = getelementptr inbounds i8, ptr %8, i64 65744
  %wide.load316.6 = load <4 x float>, ptr %515, align 4, !tbaa !13
  %wide.load317.6 = load <4 x float>, ptr %516, align 4, !tbaa !13
  %517 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load316.6, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %518 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load317.6, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %519 = getelementptr inbounds i8, ptr %11, i64 1216
  %520 = getelementptr inbounds i8, ptr %11, i64 1232
  %wide.load322.6 = load <4 x float>, ptr %519, align 4, !tbaa !13
  %wide.load323.6 = load <4 x float>, ptr %520, align 4, !tbaa !13
  %521 = getelementptr inbounds i8, ptr %12, i64 1216
  %522 = getelementptr inbounds i8, ptr %12, i64 1232
  %wide.load324.6 = load <4 x float>, ptr %521, align 4, !tbaa !13
  %wide.load325.6 = load <4 x float>, ptr %522, align 4, !tbaa !13
  %523 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %517, <4 x float> %wide.load322.6, <4 x float> %wide.load324.6)
  %524 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %518, <4 x float> %wide.load323.6, <4 x float> %wide.load325.6)
  %525 = getelementptr inbounds i8, ptr %13, i64 65728
  %526 = getelementptr inbounds i8, ptr %13, i64 65744
  store <4 x float> %523, ptr %525, align 4, !tbaa !13
  store <4 x float> %524, ptr %526, align 4, !tbaa !13
  %527 = getelementptr inbounds i8, ptr %8, i64 65760
  %528 = getelementptr inbounds i8, ptr %8, i64 65776
  %wide.load316.7 = load <4 x float>, ptr %527, align 4, !tbaa !13
  %wide.load317.7 = load <4 x float>, ptr %528, align 4, !tbaa !13
  %529 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load316.7, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %530 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load317.7, <4 x float> %broadcast.splat319, <4 x float> %broadcast.splat321)
  %531 = getelementptr inbounds i8, ptr %11, i64 1248
  %532 = getelementptr inbounds i8, ptr %11, i64 1264
  %wide.load322.7 = load <4 x float>, ptr %531, align 4, !tbaa !13
  %wide.load323.7 = load <4 x float>, ptr %532, align 4, !tbaa !13
  %533 = getelementptr inbounds i8, ptr %12, i64 1248
  %534 = getelementptr inbounds i8, ptr %12, i64 1264
  %wide.load324.7 = load <4 x float>, ptr %533, align 4, !tbaa !13
  %wide.load325.7 = load <4 x float>, ptr %534, align 4, !tbaa !13
  %535 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %529, <4 x float> %wide.load322.7, <4 x float> %wide.load324.7)
  %536 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %530, <4 x float> %wide.load323.7, <4 x float> %wide.load325.7)
  %537 = getelementptr inbounds i8, ptr %13, i64 65760
  %538 = getelementptr inbounds i8, ptr %13, i64 65776
  store <4 x float> %535, ptr %537, align 4, !tbaa !13
  store <4 x float> %536, ptr %538, align 4, !tbaa !13
  %broadcast.splatinsert337 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat338 = shufflevector <4 x float> %broadcast.splatinsert337, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert335 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat336 = shufflevector <4 x float> %broadcast.splatinsert335, <4 x float> poison, <4 x i32> zeroinitializer
  %539 = getelementptr inbounds i8, ptr %8, i64 81920
  %540 = getelementptr inbounds i8, ptr %8, i64 81936
  %wide.load333 = load <4 x float>, ptr %539, align 4, !tbaa !13
  %wide.load334 = load <4 x float>, ptr %540, align 4, !tbaa !13
  %541 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load333, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %542 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load334, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %543 = getelementptr inbounds i8, ptr %11, i64 1280
  %544 = getelementptr inbounds i8, ptr %11, i64 1296
  %wide.load339 = load <4 x float>, ptr %543, align 4, !tbaa !13
  %wide.load340 = load <4 x float>, ptr %544, align 4, !tbaa !13
  %545 = getelementptr inbounds i8, ptr %12, i64 1280
  %546 = getelementptr inbounds i8, ptr %12, i64 1296
  %wide.load341 = load <4 x float>, ptr %545, align 4, !tbaa !13
  %wide.load342 = load <4 x float>, ptr %546, align 4, !tbaa !13
  %547 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %541, <4 x float> %wide.load339, <4 x float> %wide.load341)
  %548 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %542, <4 x float> %wide.load340, <4 x float> %wide.load342)
  %549 = getelementptr inbounds i8, ptr %13, i64 81920
  %550 = getelementptr inbounds i8, ptr %13, i64 81936
  store <4 x float> %547, ptr %549, align 4, !tbaa !13
  store <4 x float> %548, ptr %550, align 4, !tbaa !13
  %551 = getelementptr inbounds i8, ptr %8, i64 81952
  %552 = getelementptr inbounds i8, ptr %8, i64 81968
  %wide.load333.1 = load <4 x float>, ptr %551, align 4, !tbaa !13
  %wide.load334.1 = load <4 x float>, ptr %552, align 4, !tbaa !13
  %553 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load333.1, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %554 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load334.1, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %555 = getelementptr inbounds i8, ptr %11, i64 1312
  %556 = getelementptr inbounds i8, ptr %11, i64 1328
  %wide.load339.1 = load <4 x float>, ptr %555, align 4, !tbaa !13
  %wide.load340.1 = load <4 x float>, ptr %556, align 4, !tbaa !13
  %557 = getelementptr inbounds i8, ptr %12, i64 1312
  %558 = getelementptr inbounds i8, ptr %12, i64 1328
  %wide.load341.1 = load <4 x float>, ptr %557, align 4, !tbaa !13
  %wide.load342.1 = load <4 x float>, ptr %558, align 4, !tbaa !13
  %559 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %553, <4 x float> %wide.load339.1, <4 x float> %wide.load341.1)
  %560 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %554, <4 x float> %wide.load340.1, <4 x float> %wide.load342.1)
  %561 = getelementptr inbounds i8, ptr %13, i64 81952
  %562 = getelementptr inbounds i8, ptr %13, i64 81968
  store <4 x float> %559, ptr %561, align 4, !tbaa !13
  store <4 x float> %560, ptr %562, align 4, !tbaa !13
  %563 = getelementptr inbounds i8, ptr %8, i64 81984
  %564 = getelementptr inbounds i8, ptr %8, i64 82000
  %wide.load333.2 = load <4 x float>, ptr %563, align 4, !tbaa !13
  %wide.load334.2 = load <4 x float>, ptr %564, align 4, !tbaa !13
  %565 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load333.2, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %566 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load334.2, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %567 = getelementptr inbounds i8, ptr %11, i64 1344
  %568 = getelementptr inbounds i8, ptr %11, i64 1360
  %wide.load339.2 = load <4 x float>, ptr %567, align 4, !tbaa !13
  %wide.load340.2 = load <4 x float>, ptr %568, align 4, !tbaa !13
  %569 = getelementptr inbounds i8, ptr %12, i64 1344
  %570 = getelementptr inbounds i8, ptr %12, i64 1360
  %wide.load341.2 = load <4 x float>, ptr %569, align 4, !tbaa !13
  %wide.load342.2 = load <4 x float>, ptr %570, align 4, !tbaa !13
  %571 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %565, <4 x float> %wide.load339.2, <4 x float> %wide.load341.2)
  %572 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %566, <4 x float> %wide.load340.2, <4 x float> %wide.load342.2)
  %573 = getelementptr inbounds i8, ptr %13, i64 81984
  %574 = getelementptr inbounds i8, ptr %13, i64 82000
  store <4 x float> %571, ptr %573, align 4, !tbaa !13
  store <4 x float> %572, ptr %574, align 4, !tbaa !13
  %575 = getelementptr inbounds i8, ptr %8, i64 82016
  %576 = getelementptr inbounds i8, ptr %8, i64 82032
  %wide.load333.3 = load <4 x float>, ptr %575, align 4, !tbaa !13
  %wide.load334.3 = load <4 x float>, ptr %576, align 4, !tbaa !13
  %577 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load333.3, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %578 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load334.3, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %579 = getelementptr inbounds i8, ptr %11, i64 1376
  %580 = getelementptr inbounds i8, ptr %11, i64 1392
  %wide.load339.3 = load <4 x float>, ptr %579, align 4, !tbaa !13
  %wide.load340.3 = load <4 x float>, ptr %580, align 4, !tbaa !13
  %581 = getelementptr inbounds i8, ptr %12, i64 1376
  %582 = getelementptr inbounds i8, ptr %12, i64 1392
  %wide.load341.3 = load <4 x float>, ptr %581, align 4, !tbaa !13
  %wide.load342.3 = load <4 x float>, ptr %582, align 4, !tbaa !13
  %583 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %577, <4 x float> %wide.load339.3, <4 x float> %wide.load341.3)
  %584 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %578, <4 x float> %wide.load340.3, <4 x float> %wide.load342.3)
  %585 = getelementptr inbounds i8, ptr %13, i64 82016
  %586 = getelementptr inbounds i8, ptr %13, i64 82032
  store <4 x float> %583, ptr %585, align 4, !tbaa !13
  store <4 x float> %584, ptr %586, align 4, !tbaa !13
  %587 = getelementptr inbounds i8, ptr %8, i64 82048
  %588 = getelementptr inbounds i8, ptr %8, i64 82064
  %wide.load333.4 = load <4 x float>, ptr %587, align 4, !tbaa !13
  %wide.load334.4 = load <4 x float>, ptr %588, align 4, !tbaa !13
  %589 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load333.4, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %590 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load334.4, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %591 = getelementptr inbounds i8, ptr %11, i64 1408
  %592 = getelementptr inbounds i8, ptr %11, i64 1424
  %wide.load339.4 = load <4 x float>, ptr %591, align 4, !tbaa !13
  %wide.load340.4 = load <4 x float>, ptr %592, align 4, !tbaa !13
  %593 = getelementptr inbounds i8, ptr %12, i64 1408
  %594 = getelementptr inbounds i8, ptr %12, i64 1424
  %wide.load341.4 = load <4 x float>, ptr %593, align 4, !tbaa !13
  %wide.load342.4 = load <4 x float>, ptr %594, align 4, !tbaa !13
  %595 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %589, <4 x float> %wide.load339.4, <4 x float> %wide.load341.4)
  %596 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %590, <4 x float> %wide.load340.4, <4 x float> %wide.load342.4)
  %597 = getelementptr inbounds i8, ptr %13, i64 82048
  %598 = getelementptr inbounds i8, ptr %13, i64 82064
  store <4 x float> %595, ptr %597, align 4, !tbaa !13
  store <4 x float> %596, ptr %598, align 4, !tbaa !13
  %599 = getelementptr inbounds i8, ptr %8, i64 82080
  %600 = getelementptr inbounds i8, ptr %8, i64 82096
  %wide.load333.5 = load <4 x float>, ptr %599, align 4, !tbaa !13
  %wide.load334.5 = load <4 x float>, ptr %600, align 4, !tbaa !13
  %601 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load333.5, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %602 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load334.5, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %603 = getelementptr inbounds i8, ptr %11, i64 1440
  %604 = getelementptr inbounds i8, ptr %11, i64 1456
  %wide.load339.5 = load <4 x float>, ptr %603, align 4, !tbaa !13
  %wide.load340.5 = load <4 x float>, ptr %604, align 4, !tbaa !13
  %605 = getelementptr inbounds i8, ptr %12, i64 1440
  %606 = getelementptr inbounds i8, ptr %12, i64 1456
  %wide.load341.5 = load <4 x float>, ptr %605, align 4, !tbaa !13
  %wide.load342.5 = load <4 x float>, ptr %606, align 4, !tbaa !13
  %607 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %601, <4 x float> %wide.load339.5, <4 x float> %wide.load341.5)
  %608 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %602, <4 x float> %wide.load340.5, <4 x float> %wide.load342.5)
  %609 = getelementptr inbounds i8, ptr %13, i64 82080
  %610 = getelementptr inbounds i8, ptr %13, i64 82096
  store <4 x float> %607, ptr %609, align 4, !tbaa !13
  store <4 x float> %608, ptr %610, align 4, !tbaa !13
  %611 = getelementptr inbounds i8, ptr %8, i64 82112
  %612 = getelementptr inbounds i8, ptr %8, i64 82128
  %wide.load333.6 = load <4 x float>, ptr %611, align 4, !tbaa !13
  %wide.load334.6 = load <4 x float>, ptr %612, align 4, !tbaa !13
  %613 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load333.6, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %614 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load334.6, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %615 = getelementptr inbounds i8, ptr %11, i64 1472
  %616 = getelementptr inbounds i8, ptr %11, i64 1488
  %wide.load339.6 = load <4 x float>, ptr %615, align 4, !tbaa !13
  %wide.load340.6 = load <4 x float>, ptr %616, align 4, !tbaa !13
  %617 = getelementptr inbounds i8, ptr %12, i64 1472
  %618 = getelementptr inbounds i8, ptr %12, i64 1488
  %wide.load341.6 = load <4 x float>, ptr %617, align 4, !tbaa !13
  %wide.load342.6 = load <4 x float>, ptr %618, align 4, !tbaa !13
  %619 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %613, <4 x float> %wide.load339.6, <4 x float> %wide.load341.6)
  %620 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %614, <4 x float> %wide.load340.6, <4 x float> %wide.load342.6)
  %621 = getelementptr inbounds i8, ptr %13, i64 82112
  %622 = getelementptr inbounds i8, ptr %13, i64 82128
  store <4 x float> %619, ptr %621, align 4, !tbaa !13
  store <4 x float> %620, ptr %622, align 4, !tbaa !13
  %623 = getelementptr inbounds i8, ptr %8, i64 82144
  %624 = getelementptr inbounds i8, ptr %8, i64 82160
  %wide.load333.7 = load <4 x float>, ptr %623, align 4, !tbaa !13
  %wide.load334.7 = load <4 x float>, ptr %624, align 4, !tbaa !13
  %625 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load333.7, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %626 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load334.7, <4 x float> %broadcast.splat336, <4 x float> %broadcast.splat338)
  %627 = getelementptr inbounds i8, ptr %11, i64 1504
  %628 = getelementptr inbounds i8, ptr %11, i64 1520
  %wide.load339.7 = load <4 x float>, ptr %627, align 4, !tbaa !13
  %wide.load340.7 = load <4 x float>, ptr %628, align 4, !tbaa !13
  %629 = getelementptr inbounds i8, ptr %12, i64 1504
  %630 = getelementptr inbounds i8, ptr %12, i64 1520
  %wide.load341.7 = load <4 x float>, ptr %629, align 4, !tbaa !13
  %wide.load342.7 = load <4 x float>, ptr %630, align 4, !tbaa !13
  %631 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %625, <4 x float> %wide.load339.7, <4 x float> %wide.load341.7)
  %632 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %626, <4 x float> %wide.load340.7, <4 x float> %wide.load342.7)
  %633 = getelementptr inbounds i8, ptr %13, i64 82144
  %634 = getelementptr inbounds i8, ptr %13, i64 82160
  store <4 x float> %631, ptr %633, align 4, !tbaa !13
  store <4 x float> %632, ptr %634, align 4, !tbaa !13
  %broadcast.splatinsert354 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat355 = shufflevector <4 x float> %broadcast.splatinsert354, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert352 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat353 = shufflevector <4 x float> %broadcast.splatinsert352, <4 x float> poison, <4 x i32> zeroinitializer
  %635 = getelementptr inbounds i8, ptr %8, i64 98304
  %636 = getelementptr inbounds i8, ptr %8, i64 98320
  %wide.load350 = load <4 x float>, ptr %635, align 4, !tbaa !13
  %wide.load351 = load <4 x float>, ptr %636, align 4, !tbaa !13
  %637 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load350, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %638 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load351, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %639 = getelementptr inbounds i8, ptr %11, i64 1536
  %640 = getelementptr inbounds i8, ptr %11, i64 1552
  %wide.load356 = load <4 x float>, ptr %639, align 4, !tbaa !13
  %wide.load357 = load <4 x float>, ptr %640, align 4, !tbaa !13
  %641 = getelementptr inbounds i8, ptr %12, i64 1536
  %642 = getelementptr inbounds i8, ptr %12, i64 1552
  %wide.load358 = load <4 x float>, ptr %641, align 4, !tbaa !13
  %wide.load359 = load <4 x float>, ptr %642, align 4, !tbaa !13
  %643 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %637, <4 x float> %wide.load356, <4 x float> %wide.load358)
  %644 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %638, <4 x float> %wide.load357, <4 x float> %wide.load359)
  %645 = getelementptr inbounds i8, ptr %13, i64 98304
  %646 = getelementptr inbounds i8, ptr %13, i64 98320
  store <4 x float> %643, ptr %645, align 4, !tbaa !13
  store <4 x float> %644, ptr %646, align 4, !tbaa !13
  %647 = getelementptr inbounds i8, ptr %8, i64 98336
  %648 = getelementptr inbounds i8, ptr %8, i64 98352
  %wide.load350.1 = load <4 x float>, ptr %647, align 4, !tbaa !13
  %wide.load351.1 = load <4 x float>, ptr %648, align 4, !tbaa !13
  %649 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load350.1, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %650 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load351.1, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %651 = getelementptr inbounds i8, ptr %11, i64 1568
  %652 = getelementptr inbounds i8, ptr %11, i64 1584
  %wide.load356.1 = load <4 x float>, ptr %651, align 4, !tbaa !13
  %wide.load357.1 = load <4 x float>, ptr %652, align 4, !tbaa !13
  %653 = getelementptr inbounds i8, ptr %12, i64 1568
  %654 = getelementptr inbounds i8, ptr %12, i64 1584
  %wide.load358.1 = load <4 x float>, ptr %653, align 4, !tbaa !13
  %wide.load359.1 = load <4 x float>, ptr %654, align 4, !tbaa !13
  %655 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %649, <4 x float> %wide.load356.1, <4 x float> %wide.load358.1)
  %656 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %650, <4 x float> %wide.load357.1, <4 x float> %wide.load359.1)
  %657 = getelementptr inbounds i8, ptr %13, i64 98336
  %658 = getelementptr inbounds i8, ptr %13, i64 98352
  store <4 x float> %655, ptr %657, align 4, !tbaa !13
  store <4 x float> %656, ptr %658, align 4, !tbaa !13
  %659 = getelementptr inbounds i8, ptr %8, i64 98368
  %660 = getelementptr inbounds i8, ptr %8, i64 98384
  %wide.load350.2 = load <4 x float>, ptr %659, align 4, !tbaa !13
  %wide.load351.2 = load <4 x float>, ptr %660, align 4, !tbaa !13
  %661 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load350.2, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %662 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load351.2, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %663 = getelementptr inbounds i8, ptr %11, i64 1600
  %664 = getelementptr inbounds i8, ptr %11, i64 1616
  %wide.load356.2 = load <4 x float>, ptr %663, align 4, !tbaa !13
  %wide.load357.2 = load <4 x float>, ptr %664, align 4, !tbaa !13
  %665 = getelementptr inbounds i8, ptr %12, i64 1600
  %666 = getelementptr inbounds i8, ptr %12, i64 1616
  %wide.load358.2 = load <4 x float>, ptr %665, align 4, !tbaa !13
  %wide.load359.2 = load <4 x float>, ptr %666, align 4, !tbaa !13
  %667 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %661, <4 x float> %wide.load356.2, <4 x float> %wide.load358.2)
  %668 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %662, <4 x float> %wide.load357.2, <4 x float> %wide.load359.2)
  %669 = getelementptr inbounds i8, ptr %13, i64 98368
  %670 = getelementptr inbounds i8, ptr %13, i64 98384
  store <4 x float> %667, ptr %669, align 4, !tbaa !13
  store <4 x float> %668, ptr %670, align 4, !tbaa !13
  %671 = getelementptr inbounds i8, ptr %8, i64 98400
  %672 = getelementptr inbounds i8, ptr %8, i64 98416
  %wide.load350.3 = load <4 x float>, ptr %671, align 4, !tbaa !13
  %wide.load351.3 = load <4 x float>, ptr %672, align 4, !tbaa !13
  %673 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load350.3, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %674 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load351.3, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %675 = getelementptr inbounds i8, ptr %11, i64 1632
  %676 = getelementptr inbounds i8, ptr %11, i64 1648
  %wide.load356.3 = load <4 x float>, ptr %675, align 4, !tbaa !13
  %wide.load357.3 = load <4 x float>, ptr %676, align 4, !tbaa !13
  %677 = getelementptr inbounds i8, ptr %12, i64 1632
  %678 = getelementptr inbounds i8, ptr %12, i64 1648
  %wide.load358.3 = load <4 x float>, ptr %677, align 4, !tbaa !13
  %wide.load359.3 = load <4 x float>, ptr %678, align 4, !tbaa !13
  %679 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %673, <4 x float> %wide.load356.3, <4 x float> %wide.load358.3)
  %680 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %674, <4 x float> %wide.load357.3, <4 x float> %wide.load359.3)
  %681 = getelementptr inbounds i8, ptr %13, i64 98400
  %682 = getelementptr inbounds i8, ptr %13, i64 98416
  store <4 x float> %679, ptr %681, align 4, !tbaa !13
  store <4 x float> %680, ptr %682, align 4, !tbaa !13
  %683 = getelementptr inbounds i8, ptr %8, i64 98432
  %684 = getelementptr inbounds i8, ptr %8, i64 98448
  %wide.load350.4 = load <4 x float>, ptr %683, align 4, !tbaa !13
  %wide.load351.4 = load <4 x float>, ptr %684, align 4, !tbaa !13
  %685 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load350.4, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %686 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load351.4, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %687 = getelementptr inbounds i8, ptr %11, i64 1664
  %688 = getelementptr inbounds i8, ptr %11, i64 1680
  %wide.load356.4 = load <4 x float>, ptr %687, align 4, !tbaa !13
  %wide.load357.4 = load <4 x float>, ptr %688, align 4, !tbaa !13
  %689 = getelementptr inbounds i8, ptr %12, i64 1664
  %690 = getelementptr inbounds i8, ptr %12, i64 1680
  %wide.load358.4 = load <4 x float>, ptr %689, align 4, !tbaa !13
  %wide.load359.4 = load <4 x float>, ptr %690, align 4, !tbaa !13
  %691 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %685, <4 x float> %wide.load356.4, <4 x float> %wide.load358.4)
  %692 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %686, <4 x float> %wide.load357.4, <4 x float> %wide.load359.4)
  %693 = getelementptr inbounds i8, ptr %13, i64 98432
  %694 = getelementptr inbounds i8, ptr %13, i64 98448
  store <4 x float> %691, ptr %693, align 4, !tbaa !13
  store <4 x float> %692, ptr %694, align 4, !tbaa !13
  %695 = getelementptr inbounds i8, ptr %8, i64 98464
  %696 = getelementptr inbounds i8, ptr %8, i64 98480
  %wide.load350.5 = load <4 x float>, ptr %695, align 4, !tbaa !13
  %wide.load351.5 = load <4 x float>, ptr %696, align 4, !tbaa !13
  %697 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load350.5, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %698 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load351.5, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %699 = getelementptr inbounds i8, ptr %11, i64 1696
  %700 = getelementptr inbounds i8, ptr %11, i64 1712
  %wide.load356.5 = load <4 x float>, ptr %699, align 4, !tbaa !13
  %wide.load357.5 = load <4 x float>, ptr %700, align 4, !tbaa !13
  %701 = getelementptr inbounds i8, ptr %12, i64 1696
  %702 = getelementptr inbounds i8, ptr %12, i64 1712
  %wide.load358.5 = load <4 x float>, ptr %701, align 4, !tbaa !13
  %wide.load359.5 = load <4 x float>, ptr %702, align 4, !tbaa !13
  %703 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %697, <4 x float> %wide.load356.5, <4 x float> %wide.load358.5)
  %704 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %698, <4 x float> %wide.load357.5, <4 x float> %wide.load359.5)
  %705 = getelementptr inbounds i8, ptr %13, i64 98464
  %706 = getelementptr inbounds i8, ptr %13, i64 98480
  store <4 x float> %703, ptr %705, align 4, !tbaa !13
  store <4 x float> %704, ptr %706, align 4, !tbaa !13
  %707 = getelementptr inbounds i8, ptr %8, i64 98496
  %708 = getelementptr inbounds i8, ptr %8, i64 98512
  %wide.load350.6 = load <4 x float>, ptr %707, align 4, !tbaa !13
  %wide.load351.6 = load <4 x float>, ptr %708, align 4, !tbaa !13
  %709 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load350.6, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %710 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load351.6, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %711 = getelementptr inbounds i8, ptr %11, i64 1728
  %712 = getelementptr inbounds i8, ptr %11, i64 1744
  %wide.load356.6 = load <4 x float>, ptr %711, align 4, !tbaa !13
  %wide.load357.6 = load <4 x float>, ptr %712, align 4, !tbaa !13
  %713 = getelementptr inbounds i8, ptr %12, i64 1728
  %714 = getelementptr inbounds i8, ptr %12, i64 1744
  %wide.load358.6 = load <4 x float>, ptr %713, align 4, !tbaa !13
  %wide.load359.6 = load <4 x float>, ptr %714, align 4, !tbaa !13
  %715 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %709, <4 x float> %wide.load356.6, <4 x float> %wide.load358.6)
  %716 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %710, <4 x float> %wide.load357.6, <4 x float> %wide.load359.6)
  %717 = getelementptr inbounds i8, ptr %13, i64 98496
  %718 = getelementptr inbounds i8, ptr %13, i64 98512
  store <4 x float> %715, ptr %717, align 4, !tbaa !13
  store <4 x float> %716, ptr %718, align 4, !tbaa !13
  %719 = getelementptr inbounds i8, ptr %8, i64 98528
  %720 = getelementptr inbounds i8, ptr %8, i64 98544
  %wide.load350.7 = load <4 x float>, ptr %719, align 4, !tbaa !13
  %wide.load351.7 = load <4 x float>, ptr %720, align 4, !tbaa !13
  %721 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load350.7, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %722 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load351.7, <4 x float> %broadcast.splat353, <4 x float> %broadcast.splat355)
  %723 = getelementptr inbounds i8, ptr %11, i64 1760
  %724 = getelementptr inbounds i8, ptr %11, i64 1776
  %wide.load356.7 = load <4 x float>, ptr %723, align 4, !tbaa !13
  %wide.load357.7 = load <4 x float>, ptr %724, align 4, !tbaa !13
  %725 = getelementptr inbounds i8, ptr %12, i64 1760
  %726 = getelementptr inbounds i8, ptr %12, i64 1776
  %wide.load358.7 = load <4 x float>, ptr %725, align 4, !tbaa !13
  %wide.load359.7 = load <4 x float>, ptr %726, align 4, !tbaa !13
  %727 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %721, <4 x float> %wide.load356.7, <4 x float> %wide.load358.7)
  %728 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %722, <4 x float> %wide.load357.7, <4 x float> %wide.load359.7)
  %729 = getelementptr inbounds i8, ptr %13, i64 98528
  %730 = getelementptr inbounds i8, ptr %13, i64 98544
  store <4 x float> %727, ptr %729, align 4, !tbaa !13
  store <4 x float> %728, ptr %730, align 4, !tbaa !13
  %broadcast.splatinsert371 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat372 = shufflevector <4 x float> %broadcast.splatinsert371, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert369 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat370 = shufflevector <4 x float> %broadcast.splatinsert369, <4 x float> poison, <4 x i32> zeroinitializer
  %731 = getelementptr inbounds i8, ptr %8, i64 114688
  %732 = getelementptr inbounds i8, ptr %8, i64 114704
  %wide.load367 = load <4 x float>, ptr %731, align 4, !tbaa !13
  %wide.load368 = load <4 x float>, ptr %732, align 4, !tbaa !13
  %733 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load367, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %734 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load368, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %735 = getelementptr inbounds i8, ptr %11, i64 1792
  %736 = getelementptr inbounds i8, ptr %11, i64 1808
  %wide.load373 = load <4 x float>, ptr %735, align 4, !tbaa !13
  %wide.load374 = load <4 x float>, ptr %736, align 4, !tbaa !13
  %737 = getelementptr inbounds i8, ptr %12, i64 1792
  %738 = getelementptr inbounds i8, ptr %12, i64 1808
  %wide.load375 = load <4 x float>, ptr %737, align 4, !tbaa !13
  %wide.load376 = load <4 x float>, ptr %738, align 4, !tbaa !13
  %739 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %733, <4 x float> %wide.load373, <4 x float> %wide.load375)
  %740 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %734, <4 x float> %wide.load374, <4 x float> %wide.load376)
  %741 = getelementptr inbounds i8, ptr %13, i64 114688
  %742 = getelementptr inbounds i8, ptr %13, i64 114704
  store <4 x float> %739, ptr %741, align 4, !tbaa !13
  store <4 x float> %740, ptr %742, align 4, !tbaa !13
  %743 = getelementptr inbounds i8, ptr %8, i64 114720
  %744 = getelementptr inbounds i8, ptr %8, i64 114736
  %wide.load367.1 = load <4 x float>, ptr %743, align 4, !tbaa !13
  %wide.load368.1 = load <4 x float>, ptr %744, align 4, !tbaa !13
  %745 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load367.1, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %746 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load368.1, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %747 = getelementptr inbounds i8, ptr %11, i64 1824
  %748 = getelementptr inbounds i8, ptr %11, i64 1840
  %wide.load373.1 = load <4 x float>, ptr %747, align 4, !tbaa !13
  %wide.load374.1 = load <4 x float>, ptr %748, align 4, !tbaa !13
  %749 = getelementptr inbounds i8, ptr %12, i64 1824
  %750 = getelementptr inbounds i8, ptr %12, i64 1840
  %wide.load375.1 = load <4 x float>, ptr %749, align 4, !tbaa !13
  %wide.load376.1 = load <4 x float>, ptr %750, align 4, !tbaa !13
  %751 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %745, <4 x float> %wide.load373.1, <4 x float> %wide.load375.1)
  %752 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %746, <4 x float> %wide.load374.1, <4 x float> %wide.load376.1)
  %753 = getelementptr inbounds i8, ptr %13, i64 114720
  %754 = getelementptr inbounds i8, ptr %13, i64 114736
  store <4 x float> %751, ptr %753, align 4, !tbaa !13
  store <4 x float> %752, ptr %754, align 4, !tbaa !13
  %755 = getelementptr inbounds i8, ptr %8, i64 114752
  %756 = getelementptr inbounds i8, ptr %8, i64 114768
  %wide.load367.2 = load <4 x float>, ptr %755, align 4, !tbaa !13
  %wide.load368.2 = load <4 x float>, ptr %756, align 4, !tbaa !13
  %757 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load367.2, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %758 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load368.2, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %759 = getelementptr inbounds i8, ptr %11, i64 1856
  %760 = getelementptr inbounds i8, ptr %11, i64 1872
  %wide.load373.2 = load <4 x float>, ptr %759, align 4, !tbaa !13
  %wide.load374.2 = load <4 x float>, ptr %760, align 4, !tbaa !13
  %761 = getelementptr inbounds i8, ptr %12, i64 1856
  %762 = getelementptr inbounds i8, ptr %12, i64 1872
  %wide.load375.2 = load <4 x float>, ptr %761, align 4, !tbaa !13
  %wide.load376.2 = load <4 x float>, ptr %762, align 4, !tbaa !13
  %763 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %757, <4 x float> %wide.load373.2, <4 x float> %wide.load375.2)
  %764 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %758, <4 x float> %wide.load374.2, <4 x float> %wide.load376.2)
  %765 = getelementptr inbounds i8, ptr %13, i64 114752
  %766 = getelementptr inbounds i8, ptr %13, i64 114768
  store <4 x float> %763, ptr %765, align 4, !tbaa !13
  store <4 x float> %764, ptr %766, align 4, !tbaa !13
  %767 = getelementptr inbounds i8, ptr %8, i64 114784
  %768 = getelementptr inbounds i8, ptr %8, i64 114800
  %wide.load367.3 = load <4 x float>, ptr %767, align 4, !tbaa !13
  %wide.load368.3 = load <4 x float>, ptr %768, align 4, !tbaa !13
  %769 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load367.3, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %770 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load368.3, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %771 = getelementptr inbounds i8, ptr %11, i64 1888
  %772 = getelementptr inbounds i8, ptr %11, i64 1904
  %wide.load373.3 = load <4 x float>, ptr %771, align 4, !tbaa !13
  %wide.load374.3 = load <4 x float>, ptr %772, align 4, !tbaa !13
  %773 = getelementptr inbounds i8, ptr %12, i64 1888
  %774 = getelementptr inbounds i8, ptr %12, i64 1904
  %wide.load375.3 = load <4 x float>, ptr %773, align 4, !tbaa !13
  %wide.load376.3 = load <4 x float>, ptr %774, align 4, !tbaa !13
  %775 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %769, <4 x float> %wide.load373.3, <4 x float> %wide.load375.3)
  %776 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %770, <4 x float> %wide.load374.3, <4 x float> %wide.load376.3)
  %777 = getelementptr inbounds i8, ptr %13, i64 114784
  %778 = getelementptr inbounds i8, ptr %13, i64 114800
  store <4 x float> %775, ptr %777, align 4, !tbaa !13
  store <4 x float> %776, ptr %778, align 4, !tbaa !13
  %779 = getelementptr inbounds i8, ptr %8, i64 114816
  %780 = getelementptr inbounds i8, ptr %8, i64 114832
  %wide.load367.4 = load <4 x float>, ptr %779, align 4, !tbaa !13
  %wide.load368.4 = load <4 x float>, ptr %780, align 4, !tbaa !13
  %781 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load367.4, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %782 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load368.4, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %783 = getelementptr inbounds i8, ptr %11, i64 1920
  %784 = getelementptr inbounds i8, ptr %11, i64 1936
  %wide.load373.4 = load <4 x float>, ptr %783, align 4, !tbaa !13
  %wide.load374.4 = load <4 x float>, ptr %784, align 4, !tbaa !13
  %785 = getelementptr inbounds i8, ptr %12, i64 1920
  %786 = getelementptr inbounds i8, ptr %12, i64 1936
  %wide.load375.4 = load <4 x float>, ptr %785, align 4, !tbaa !13
  %wide.load376.4 = load <4 x float>, ptr %786, align 4, !tbaa !13
  %787 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %781, <4 x float> %wide.load373.4, <4 x float> %wide.load375.4)
  %788 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %782, <4 x float> %wide.load374.4, <4 x float> %wide.load376.4)
  %789 = getelementptr inbounds i8, ptr %13, i64 114816
  %790 = getelementptr inbounds i8, ptr %13, i64 114832
  store <4 x float> %787, ptr %789, align 4, !tbaa !13
  store <4 x float> %788, ptr %790, align 4, !tbaa !13
  %791 = getelementptr inbounds i8, ptr %8, i64 114848
  %792 = getelementptr inbounds i8, ptr %8, i64 114864
  %wide.load367.5 = load <4 x float>, ptr %791, align 4, !tbaa !13
  %wide.load368.5 = load <4 x float>, ptr %792, align 4, !tbaa !13
  %793 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load367.5, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %794 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load368.5, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %795 = getelementptr inbounds i8, ptr %11, i64 1952
  %796 = getelementptr inbounds i8, ptr %11, i64 1968
  %wide.load373.5 = load <4 x float>, ptr %795, align 4, !tbaa !13
  %wide.load374.5 = load <4 x float>, ptr %796, align 4, !tbaa !13
  %797 = getelementptr inbounds i8, ptr %12, i64 1952
  %798 = getelementptr inbounds i8, ptr %12, i64 1968
  %wide.load375.5 = load <4 x float>, ptr %797, align 4, !tbaa !13
  %wide.load376.5 = load <4 x float>, ptr %798, align 4, !tbaa !13
  %799 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %793, <4 x float> %wide.load373.5, <4 x float> %wide.load375.5)
  %800 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %794, <4 x float> %wide.load374.5, <4 x float> %wide.load376.5)
  %801 = getelementptr inbounds i8, ptr %13, i64 114848
  %802 = getelementptr inbounds i8, ptr %13, i64 114864
  store <4 x float> %799, ptr %801, align 4, !tbaa !13
  store <4 x float> %800, ptr %802, align 4, !tbaa !13
  %803 = getelementptr inbounds i8, ptr %8, i64 114880
  %804 = getelementptr inbounds i8, ptr %8, i64 114896
  %wide.load367.6 = load <4 x float>, ptr %803, align 4, !tbaa !13
  %wide.load368.6 = load <4 x float>, ptr %804, align 4, !tbaa !13
  %805 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load367.6, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %806 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load368.6, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %807 = getelementptr inbounds i8, ptr %11, i64 1984
  %808 = getelementptr inbounds i8, ptr %11, i64 2000
  %wide.load373.6 = load <4 x float>, ptr %807, align 4, !tbaa !13
  %wide.load374.6 = load <4 x float>, ptr %808, align 4, !tbaa !13
  %809 = getelementptr inbounds i8, ptr %12, i64 1984
  %810 = getelementptr inbounds i8, ptr %12, i64 2000
  %wide.load375.6 = load <4 x float>, ptr %809, align 4, !tbaa !13
  %wide.load376.6 = load <4 x float>, ptr %810, align 4, !tbaa !13
  %811 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %805, <4 x float> %wide.load373.6, <4 x float> %wide.load375.6)
  %812 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %806, <4 x float> %wide.load374.6, <4 x float> %wide.load376.6)
  %813 = getelementptr inbounds i8, ptr %13, i64 114880
  %814 = getelementptr inbounds i8, ptr %13, i64 114896
  store <4 x float> %811, ptr %813, align 4, !tbaa !13
  store <4 x float> %812, ptr %814, align 4, !tbaa !13
  %815 = getelementptr inbounds i8, ptr %8, i64 114912
  %816 = getelementptr inbounds i8, ptr %8, i64 114928
  %wide.load367.7 = load <4 x float>, ptr %815, align 4, !tbaa !13
  %wide.load368.7 = load <4 x float>, ptr %816, align 4, !tbaa !13
  %817 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load367.7, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %818 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load368.7, <4 x float> %broadcast.splat370, <4 x float> %broadcast.splat372)
  %819 = getelementptr inbounds i8, ptr %11, i64 2016
  %820 = getelementptr inbounds i8, ptr %11, i64 2032
  %wide.load373.7 = load <4 x float>, ptr %819, align 4, !tbaa !13
  %wide.load374.7 = load <4 x float>, ptr %820, align 4, !tbaa !13
  %821 = getelementptr inbounds i8, ptr %12, i64 2016
  %822 = getelementptr inbounds i8, ptr %12, i64 2032
  %wide.load375.7 = load <4 x float>, ptr %821, align 4, !tbaa !13
  %wide.load376.7 = load <4 x float>, ptr %822, align 4, !tbaa !13
  %823 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %817, <4 x float> %wide.load373.7, <4 x float> %wide.load375.7)
  %824 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %818, <4 x float> %wide.load374.7, <4 x float> %wide.load376.7)
  %825 = getelementptr inbounds i8, ptr %13, i64 114912
  %826 = getelementptr inbounds i8, ptr %13, i64 114928
  store <4 x float> %823, ptr %825, align 4, !tbaa !13
  store <4 x float> %824, ptr %826, align 4, !tbaa !13
  %broadcast.splatinsert388 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat389 = shufflevector <4 x float> %broadcast.splatinsert388, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert386 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat387 = shufflevector <4 x float> %broadcast.splatinsert386, <4 x float> poison, <4 x i32> zeroinitializer
  %827 = getelementptr inbounds i8, ptr %8, i64 131072
  %828 = getelementptr inbounds i8, ptr %8, i64 131088
  %wide.load384 = load <4 x float>, ptr %827, align 4, !tbaa !13
  %wide.load385 = load <4 x float>, ptr %828, align 4, !tbaa !13
  %829 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load384, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %830 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load385, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %831 = getelementptr inbounds i8, ptr %11, i64 2048
  %832 = getelementptr inbounds i8, ptr %11, i64 2064
  %wide.load390 = load <4 x float>, ptr %831, align 4, !tbaa !13
  %wide.load391 = load <4 x float>, ptr %832, align 4, !tbaa !13
  %833 = getelementptr inbounds i8, ptr %12, i64 2048
  %834 = getelementptr inbounds i8, ptr %12, i64 2064
  %wide.load392 = load <4 x float>, ptr %833, align 4, !tbaa !13
  %wide.load393 = load <4 x float>, ptr %834, align 4, !tbaa !13
  %835 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %829, <4 x float> %wide.load390, <4 x float> %wide.load392)
  %836 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %830, <4 x float> %wide.load391, <4 x float> %wide.load393)
  %837 = getelementptr inbounds i8, ptr %13, i64 131072
  %838 = getelementptr inbounds i8, ptr %13, i64 131088
  store <4 x float> %835, ptr %837, align 4, !tbaa !13
  store <4 x float> %836, ptr %838, align 4, !tbaa !13
  %839 = getelementptr inbounds i8, ptr %8, i64 131104
  %840 = getelementptr inbounds i8, ptr %8, i64 131120
  %wide.load384.1 = load <4 x float>, ptr %839, align 4, !tbaa !13
  %wide.load385.1 = load <4 x float>, ptr %840, align 4, !tbaa !13
  %841 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load384.1, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %842 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load385.1, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %843 = getelementptr inbounds i8, ptr %11, i64 2080
  %844 = getelementptr inbounds i8, ptr %11, i64 2096
  %wide.load390.1 = load <4 x float>, ptr %843, align 4, !tbaa !13
  %wide.load391.1 = load <4 x float>, ptr %844, align 4, !tbaa !13
  %845 = getelementptr inbounds i8, ptr %12, i64 2080
  %846 = getelementptr inbounds i8, ptr %12, i64 2096
  %wide.load392.1 = load <4 x float>, ptr %845, align 4, !tbaa !13
  %wide.load393.1 = load <4 x float>, ptr %846, align 4, !tbaa !13
  %847 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %841, <4 x float> %wide.load390.1, <4 x float> %wide.load392.1)
  %848 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %842, <4 x float> %wide.load391.1, <4 x float> %wide.load393.1)
  %849 = getelementptr inbounds i8, ptr %13, i64 131104
  %850 = getelementptr inbounds i8, ptr %13, i64 131120
  store <4 x float> %847, ptr %849, align 4, !tbaa !13
  store <4 x float> %848, ptr %850, align 4, !tbaa !13
  %851 = getelementptr inbounds i8, ptr %8, i64 131136
  %852 = getelementptr inbounds i8, ptr %8, i64 131152
  %wide.load384.2 = load <4 x float>, ptr %851, align 4, !tbaa !13
  %wide.load385.2 = load <4 x float>, ptr %852, align 4, !tbaa !13
  %853 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load384.2, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %854 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load385.2, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %855 = getelementptr inbounds i8, ptr %11, i64 2112
  %856 = getelementptr inbounds i8, ptr %11, i64 2128
  %wide.load390.2 = load <4 x float>, ptr %855, align 4, !tbaa !13
  %wide.load391.2 = load <4 x float>, ptr %856, align 4, !tbaa !13
  %857 = getelementptr inbounds i8, ptr %12, i64 2112
  %858 = getelementptr inbounds i8, ptr %12, i64 2128
  %wide.load392.2 = load <4 x float>, ptr %857, align 4, !tbaa !13
  %wide.load393.2 = load <4 x float>, ptr %858, align 4, !tbaa !13
  %859 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %853, <4 x float> %wide.load390.2, <4 x float> %wide.load392.2)
  %860 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %854, <4 x float> %wide.load391.2, <4 x float> %wide.load393.2)
  %861 = getelementptr inbounds i8, ptr %13, i64 131136
  %862 = getelementptr inbounds i8, ptr %13, i64 131152
  store <4 x float> %859, ptr %861, align 4, !tbaa !13
  store <4 x float> %860, ptr %862, align 4, !tbaa !13
  %863 = getelementptr inbounds i8, ptr %8, i64 131168
  %864 = getelementptr inbounds i8, ptr %8, i64 131184
  %wide.load384.3 = load <4 x float>, ptr %863, align 4, !tbaa !13
  %wide.load385.3 = load <4 x float>, ptr %864, align 4, !tbaa !13
  %865 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load384.3, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %866 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load385.3, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %867 = getelementptr inbounds i8, ptr %11, i64 2144
  %868 = getelementptr inbounds i8, ptr %11, i64 2160
  %wide.load390.3 = load <4 x float>, ptr %867, align 4, !tbaa !13
  %wide.load391.3 = load <4 x float>, ptr %868, align 4, !tbaa !13
  %869 = getelementptr inbounds i8, ptr %12, i64 2144
  %870 = getelementptr inbounds i8, ptr %12, i64 2160
  %wide.load392.3 = load <4 x float>, ptr %869, align 4, !tbaa !13
  %wide.load393.3 = load <4 x float>, ptr %870, align 4, !tbaa !13
  %871 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %865, <4 x float> %wide.load390.3, <4 x float> %wide.load392.3)
  %872 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %866, <4 x float> %wide.load391.3, <4 x float> %wide.load393.3)
  %873 = getelementptr inbounds i8, ptr %13, i64 131168
  %874 = getelementptr inbounds i8, ptr %13, i64 131184
  store <4 x float> %871, ptr %873, align 4, !tbaa !13
  store <4 x float> %872, ptr %874, align 4, !tbaa !13
  %875 = getelementptr inbounds i8, ptr %8, i64 131200
  %876 = getelementptr inbounds i8, ptr %8, i64 131216
  %wide.load384.4 = load <4 x float>, ptr %875, align 4, !tbaa !13
  %wide.load385.4 = load <4 x float>, ptr %876, align 4, !tbaa !13
  %877 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load384.4, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %878 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load385.4, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %879 = getelementptr inbounds i8, ptr %11, i64 2176
  %880 = getelementptr inbounds i8, ptr %11, i64 2192
  %wide.load390.4 = load <4 x float>, ptr %879, align 4, !tbaa !13
  %wide.load391.4 = load <4 x float>, ptr %880, align 4, !tbaa !13
  %881 = getelementptr inbounds i8, ptr %12, i64 2176
  %882 = getelementptr inbounds i8, ptr %12, i64 2192
  %wide.load392.4 = load <4 x float>, ptr %881, align 4, !tbaa !13
  %wide.load393.4 = load <4 x float>, ptr %882, align 4, !tbaa !13
  %883 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %877, <4 x float> %wide.load390.4, <4 x float> %wide.load392.4)
  %884 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %878, <4 x float> %wide.load391.4, <4 x float> %wide.load393.4)
  %885 = getelementptr inbounds i8, ptr %13, i64 131200
  %886 = getelementptr inbounds i8, ptr %13, i64 131216
  store <4 x float> %883, ptr %885, align 4, !tbaa !13
  store <4 x float> %884, ptr %886, align 4, !tbaa !13
  %887 = getelementptr inbounds i8, ptr %8, i64 131232
  %888 = getelementptr inbounds i8, ptr %8, i64 131248
  %wide.load384.5 = load <4 x float>, ptr %887, align 4, !tbaa !13
  %wide.load385.5 = load <4 x float>, ptr %888, align 4, !tbaa !13
  %889 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load384.5, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %890 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load385.5, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %891 = getelementptr inbounds i8, ptr %11, i64 2208
  %892 = getelementptr inbounds i8, ptr %11, i64 2224
  %wide.load390.5 = load <4 x float>, ptr %891, align 4, !tbaa !13
  %wide.load391.5 = load <4 x float>, ptr %892, align 4, !tbaa !13
  %893 = getelementptr inbounds i8, ptr %12, i64 2208
  %894 = getelementptr inbounds i8, ptr %12, i64 2224
  %wide.load392.5 = load <4 x float>, ptr %893, align 4, !tbaa !13
  %wide.load393.5 = load <4 x float>, ptr %894, align 4, !tbaa !13
  %895 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %889, <4 x float> %wide.load390.5, <4 x float> %wide.load392.5)
  %896 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %890, <4 x float> %wide.load391.5, <4 x float> %wide.load393.5)
  %897 = getelementptr inbounds i8, ptr %13, i64 131232
  %898 = getelementptr inbounds i8, ptr %13, i64 131248
  store <4 x float> %895, ptr %897, align 4, !tbaa !13
  store <4 x float> %896, ptr %898, align 4, !tbaa !13
  %899 = getelementptr inbounds i8, ptr %8, i64 131264
  %900 = getelementptr inbounds i8, ptr %8, i64 131280
  %wide.load384.6 = load <4 x float>, ptr %899, align 4, !tbaa !13
  %wide.load385.6 = load <4 x float>, ptr %900, align 4, !tbaa !13
  %901 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load384.6, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %902 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load385.6, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %903 = getelementptr inbounds i8, ptr %11, i64 2240
  %904 = getelementptr inbounds i8, ptr %11, i64 2256
  %wide.load390.6 = load <4 x float>, ptr %903, align 4, !tbaa !13
  %wide.load391.6 = load <4 x float>, ptr %904, align 4, !tbaa !13
  %905 = getelementptr inbounds i8, ptr %12, i64 2240
  %906 = getelementptr inbounds i8, ptr %12, i64 2256
  %wide.load392.6 = load <4 x float>, ptr %905, align 4, !tbaa !13
  %wide.load393.6 = load <4 x float>, ptr %906, align 4, !tbaa !13
  %907 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %901, <4 x float> %wide.load390.6, <4 x float> %wide.load392.6)
  %908 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %902, <4 x float> %wide.load391.6, <4 x float> %wide.load393.6)
  %909 = getelementptr inbounds i8, ptr %13, i64 131264
  %910 = getelementptr inbounds i8, ptr %13, i64 131280
  store <4 x float> %907, ptr %909, align 4, !tbaa !13
  store <4 x float> %908, ptr %910, align 4, !tbaa !13
  %911 = getelementptr inbounds i8, ptr %8, i64 131296
  %912 = getelementptr inbounds i8, ptr %8, i64 131312
  %wide.load384.7 = load <4 x float>, ptr %911, align 4, !tbaa !13
  %wide.load385.7 = load <4 x float>, ptr %912, align 4, !tbaa !13
  %913 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load384.7, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %914 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load385.7, <4 x float> %broadcast.splat387, <4 x float> %broadcast.splat389)
  %915 = getelementptr inbounds i8, ptr %11, i64 2272
  %916 = getelementptr inbounds i8, ptr %11, i64 2288
  %wide.load390.7 = load <4 x float>, ptr %915, align 4, !tbaa !13
  %wide.load391.7 = load <4 x float>, ptr %916, align 4, !tbaa !13
  %917 = getelementptr inbounds i8, ptr %12, i64 2272
  %918 = getelementptr inbounds i8, ptr %12, i64 2288
  %wide.load392.7 = load <4 x float>, ptr %917, align 4, !tbaa !13
  %wide.load393.7 = load <4 x float>, ptr %918, align 4, !tbaa !13
  %919 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %913, <4 x float> %wide.load390.7, <4 x float> %wide.load392.7)
  %920 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %914, <4 x float> %wide.load391.7, <4 x float> %wide.load393.7)
  %921 = getelementptr inbounds i8, ptr %13, i64 131296
  %922 = getelementptr inbounds i8, ptr %13, i64 131312
  store <4 x float> %919, ptr %921, align 4, !tbaa !13
  store <4 x float> %920, ptr %922, align 4, !tbaa !13
  %broadcast.splatinsert405 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat406 = shufflevector <4 x float> %broadcast.splatinsert405, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert403 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat404 = shufflevector <4 x float> %broadcast.splatinsert403, <4 x float> poison, <4 x i32> zeroinitializer
  %923 = getelementptr inbounds i8, ptr %8, i64 147456
  %924 = getelementptr inbounds i8, ptr %8, i64 147472
  %wide.load401 = load <4 x float>, ptr %923, align 4, !tbaa !13
  %wide.load402 = load <4 x float>, ptr %924, align 4, !tbaa !13
  %925 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load401, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %926 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load402, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %927 = getelementptr inbounds i8, ptr %11, i64 2304
  %928 = getelementptr inbounds i8, ptr %11, i64 2320
  %wide.load407 = load <4 x float>, ptr %927, align 4, !tbaa !13
  %wide.load408 = load <4 x float>, ptr %928, align 4, !tbaa !13
  %929 = getelementptr inbounds i8, ptr %12, i64 2304
  %930 = getelementptr inbounds i8, ptr %12, i64 2320
  %wide.load409 = load <4 x float>, ptr %929, align 4, !tbaa !13
  %wide.load410 = load <4 x float>, ptr %930, align 4, !tbaa !13
  %931 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %925, <4 x float> %wide.load407, <4 x float> %wide.load409)
  %932 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %926, <4 x float> %wide.load408, <4 x float> %wide.load410)
  %933 = getelementptr inbounds i8, ptr %13, i64 147456
  %934 = getelementptr inbounds i8, ptr %13, i64 147472
  store <4 x float> %931, ptr %933, align 4, !tbaa !13
  store <4 x float> %932, ptr %934, align 4, !tbaa !13
  %935 = getelementptr inbounds i8, ptr %8, i64 147488
  %936 = getelementptr inbounds i8, ptr %8, i64 147504
  %wide.load401.1 = load <4 x float>, ptr %935, align 4, !tbaa !13
  %wide.load402.1 = load <4 x float>, ptr %936, align 4, !tbaa !13
  %937 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load401.1, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %938 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load402.1, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %939 = getelementptr inbounds i8, ptr %11, i64 2336
  %940 = getelementptr inbounds i8, ptr %11, i64 2352
  %wide.load407.1 = load <4 x float>, ptr %939, align 4, !tbaa !13
  %wide.load408.1 = load <4 x float>, ptr %940, align 4, !tbaa !13
  %941 = getelementptr inbounds i8, ptr %12, i64 2336
  %942 = getelementptr inbounds i8, ptr %12, i64 2352
  %wide.load409.1 = load <4 x float>, ptr %941, align 4, !tbaa !13
  %wide.load410.1 = load <4 x float>, ptr %942, align 4, !tbaa !13
  %943 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %937, <4 x float> %wide.load407.1, <4 x float> %wide.load409.1)
  %944 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %938, <4 x float> %wide.load408.1, <4 x float> %wide.load410.1)
  %945 = getelementptr inbounds i8, ptr %13, i64 147488
  %946 = getelementptr inbounds i8, ptr %13, i64 147504
  store <4 x float> %943, ptr %945, align 4, !tbaa !13
  store <4 x float> %944, ptr %946, align 4, !tbaa !13
  %947 = getelementptr inbounds i8, ptr %8, i64 147520
  %948 = getelementptr inbounds i8, ptr %8, i64 147536
  %wide.load401.2 = load <4 x float>, ptr %947, align 4, !tbaa !13
  %wide.load402.2 = load <4 x float>, ptr %948, align 4, !tbaa !13
  %949 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load401.2, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %950 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load402.2, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %951 = getelementptr inbounds i8, ptr %11, i64 2368
  %952 = getelementptr inbounds i8, ptr %11, i64 2384
  %wide.load407.2 = load <4 x float>, ptr %951, align 4, !tbaa !13
  %wide.load408.2 = load <4 x float>, ptr %952, align 4, !tbaa !13
  %953 = getelementptr inbounds i8, ptr %12, i64 2368
  %954 = getelementptr inbounds i8, ptr %12, i64 2384
  %wide.load409.2 = load <4 x float>, ptr %953, align 4, !tbaa !13
  %wide.load410.2 = load <4 x float>, ptr %954, align 4, !tbaa !13
  %955 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %949, <4 x float> %wide.load407.2, <4 x float> %wide.load409.2)
  %956 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %950, <4 x float> %wide.load408.2, <4 x float> %wide.load410.2)
  %957 = getelementptr inbounds i8, ptr %13, i64 147520
  %958 = getelementptr inbounds i8, ptr %13, i64 147536
  store <4 x float> %955, ptr %957, align 4, !tbaa !13
  store <4 x float> %956, ptr %958, align 4, !tbaa !13
  %959 = getelementptr inbounds i8, ptr %8, i64 147552
  %960 = getelementptr inbounds i8, ptr %8, i64 147568
  %wide.load401.3 = load <4 x float>, ptr %959, align 4, !tbaa !13
  %wide.load402.3 = load <4 x float>, ptr %960, align 4, !tbaa !13
  %961 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load401.3, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %962 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load402.3, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %963 = getelementptr inbounds i8, ptr %11, i64 2400
  %964 = getelementptr inbounds i8, ptr %11, i64 2416
  %wide.load407.3 = load <4 x float>, ptr %963, align 4, !tbaa !13
  %wide.load408.3 = load <4 x float>, ptr %964, align 4, !tbaa !13
  %965 = getelementptr inbounds i8, ptr %12, i64 2400
  %966 = getelementptr inbounds i8, ptr %12, i64 2416
  %wide.load409.3 = load <4 x float>, ptr %965, align 4, !tbaa !13
  %wide.load410.3 = load <4 x float>, ptr %966, align 4, !tbaa !13
  %967 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %961, <4 x float> %wide.load407.3, <4 x float> %wide.load409.3)
  %968 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %962, <4 x float> %wide.load408.3, <4 x float> %wide.load410.3)
  %969 = getelementptr inbounds i8, ptr %13, i64 147552
  %970 = getelementptr inbounds i8, ptr %13, i64 147568
  store <4 x float> %967, ptr %969, align 4, !tbaa !13
  store <4 x float> %968, ptr %970, align 4, !tbaa !13
  %971 = getelementptr inbounds i8, ptr %8, i64 147584
  %972 = getelementptr inbounds i8, ptr %8, i64 147600
  %wide.load401.4 = load <4 x float>, ptr %971, align 4, !tbaa !13
  %wide.load402.4 = load <4 x float>, ptr %972, align 4, !tbaa !13
  %973 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load401.4, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %974 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load402.4, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %975 = getelementptr inbounds i8, ptr %11, i64 2432
  %976 = getelementptr inbounds i8, ptr %11, i64 2448
  %wide.load407.4 = load <4 x float>, ptr %975, align 4, !tbaa !13
  %wide.load408.4 = load <4 x float>, ptr %976, align 4, !tbaa !13
  %977 = getelementptr inbounds i8, ptr %12, i64 2432
  %978 = getelementptr inbounds i8, ptr %12, i64 2448
  %wide.load409.4 = load <4 x float>, ptr %977, align 4, !tbaa !13
  %wide.load410.4 = load <4 x float>, ptr %978, align 4, !tbaa !13
  %979 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %973, <4 x float> %wide.load407.4, <4 x float> %wide.load409.4)
  %980 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %974, <4 x float> %wide.load408.4, <4 x float> %wide.load410.4)
  %981 = getelementptr inbounds i8, ptr %13, i64 147584
  %982 = getelementptr inbounds i8, ptr %13, i64 147600
  store <4 x float> %979, ptr %981, align 4, !tbaa !13
  store <4 x float> %980, ptr %982, align 4, !tbaa !13
  %983 = getelementptr inbounds i8, ptr %8, i64 147616
  %984 = getelementptr inbounds i8, ptr %8, i64 147632
  %wide.load401.5 = load <4 x float>, ptr %983, align 4, !tbaa !13
  %wide.load402.5 = load <4 x float>, ptr %984, align 4, !tbaa !13
  %985 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load401.5, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %986 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load402.5, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %987 = getelementptr inbounds i8, ptr %11, i64 2464
  %988 = getelementptr inbounds i8, ptr %11, i64 2480
  %wide.load407.5 = load <4 x float>, ptr %987, align 4, !tbaa !13
  %wide.load408.5 = load <4 x float>, ptr %988, align 4, !tbaa !13
  %989 = getelementptr inbounds i8, ptr %12, i64 2464
  %990 = getelementptr inbounds i8, ptr %12, i64 2480
  %wide.load409.5 = load <4 x float>, ptr %989, align 4, !tbaa !13
  %wide.load410.5 = load <4 x float>, ptr %990, align 4, !tbaa !13
  %991 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %985, <4 x float> %wide.load407.5, <4 x float> %wide.load409.5)
  %992 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %986, <4 x float> %wide.load408.5, <4 x float> %wide.load410.5)
  %993 = getelementptr inbounds i8, ptr %13, i64 147616
  %994 = getelementptr inbounds i8, ptr %13, i64 147632
  store <4 x float> %991, ptr %993, align 4, !tbaa !13
  store <4 x float> %992, ptr %994, align 4, !tbaa !13
  %995 = getelementptr inbounds i8, ptr %8, i64 147648
  %996 = getelementptr inbounds i8, ptr %8, i64 147664
  %wide.load401.6 = load <4 x float>, ptr %995, align 4, !tbaa !13
  %wide.load402.6 = load <4 x float>, ptr %996, align 4, !tbaa !13
  %997 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load401.6, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %998 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load402.6, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %999 = getelementptr inbounds i8, ptr %11, i64 2496
  %1000 = getelementptr inbounds i8, ptr %11, i64 2512
  %wide.load407.6 = load <4 x float>, ptr %999, align 4, !tbaa !13
  %wide.load408.6 = load <4 x float>, ptr %1000, align 4, !tbaa !13
  %1001 = getelementptr inbounds i8, ptr %12, i64 2496
  %1002 = getelementptr inbounds i8, ptr %12, i64 2512
  %wide.load409.6 = load <4 x float>, ptr %1001, align 4, !tbaa !13
  %wide.load410.6 = load <4 x float>, ptr %1002, align 4, !tbaa !13
  %1003 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %997, <4 x float> %wide.load407.6, <4 x float> %wide.load409.6)
  %1004 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %998, <4 x float> %wide.load408.6, <4 x float> %wide.load410.6)
  %1005 = getelementptr inbounds i8, ptr %13, i64 147648
  %1006 = getelementptr inbounds i8, ptr %13, i64 147664
  store <4 x float> %1003, ptr %1005, align 4, !tbaa !13
  store <4 x float> %1004, ptr %1006, align 4, !tbaa !13
  %1007 = getelementptr inbounds i8, ptr %8, i64 147680
  %1008 = getelementptr inbounds i8, ptr %8, i64 147696
  %wide.load401.7 = load <4 x float>, ptr %1007, align 4, !tbaa !13
  %wide.load402.7 = load <4 x float>, ptr %1008, align 4, !tbaa !13
  %1009 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load401.7, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %1010 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load402.7, <4 x float> %broadcast.splat404, <4 x float> %broadcast.splat406)
  %1011 = getelementptr inbounds i8, ptr %11, i64 2528
  %1012 = getelementptr inbounds i8, ptr %11, i64 2544
  %wide.load407.7 = load <4 x float>, ptr %1011, align 4, !tbaa !13
  %wide.load408.7 = load <4 x float>, ptr %1012, align 4, !tbaa !13
  %1013 = getelementptr inbounds i8, ptr %12, i64 2528
  %1014 = getelementptr inbounds i8, ptr %12, i64 2544
  %wide.load409.7 = load <4 x float>, ptr %1013, align 4, !tbaa !13
  %wide.load410.7 = load <4 x float>, ptr %1014, align 4, !tbaa !13
  %1015 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1009, <4 x float> %wide.load407.7, <4 x float> %wide.load409.7)
  %1016 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1010, <4 x float> %wide.load408.7, <4 x float> %wide.load410.7)
  %1017 = getelementptr inbounds i8, ptr %13, i64 147680
  %1018 = getelementptr inbounds i8, ptr %13, i64 147696
  store <4 x float> %1015, ptr %1017, align 4, !tbaa !13
  store <4 x float> %1016, ptr %1018, align 4, !tbaa !13
  %broadcast.splatinsert422 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat423 = shufflevector <4 x float> %broadcast.splatinsert422, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert420 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat421 = shufflevector <4 x float> %broadcast.splatinsert420, <4 x float> poison, <4 x i32> zeroinitializer
  %1019 = getelementptr inbounds i8, ptr %8, i64 163840
  %1020 = getelementptr inbounds i8, ptr %8, i64 163856
  %wide.load418 = load <4 x float>, ptr %1019, align 4, !tbaa !13
  %wide.load419 = load <4 x float>, ptr %1020, align 4, !tbaa !13
  %1021 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load418, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1022 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load419, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1023 = getelementptr inbounds i8, ptr %11, i64 2560
  %1024 = getelementptr inbounds i8, ptr %11, i64 2576
  %wide.load424 = load <4 x float>, ptr %1023, align 4, !tbaa !13
  %wide.load425 = load <4 x float>, ptr %1024, align 4, !tbaa !13
  %1025 = getelementptr inbounds i8, ptr %12, i64 2560
  %1026 = getelementptr inbounds i8, ptr %12, i64 2576
  %wide.load426 = load <4 x float>, ptr %1025, align 4, !tbaa !13
  %wide.load427 = load <4 x float>, ptr %1026, align 4, !tbaa !13
  %1027 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1021, <4 x float> %wide.load424, <4 x float> %wide.load426)
  %1028 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1022, <4 x float> %wide.load425, <4 x float> %wide.load427)
  %1029 = getelementptr inbounds i8, ptr %13, i64 163840
  %1030 = getelementptr inbounds i8, ptr %13, i64 163856
  store <4 x float> %1027, ptr %1029, align 4, !tbaa !13
  store <4 x float> %1028, ptr %1030, align 4, !tbaa !13
  %1031 = getelementptr inbounds i8, ptr %8, i64 163872
  %1032 = getelementptr inbounds i8, ptr %8, i64 163888
  %wide.load418.1 = load <4 x float>, ptr %1031, align 4, !tbaa !13
  %wide.load419.1 = load <4 x float>, ptr %1032, align 4, !tbaa !13
  %1033 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load418.1, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1034 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load419.1, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1035 = getelementptr inbounds i8, ptr %11, i64 2592
  %1036 = getelementptr inbounds i8, ptr %11, i64 2608
  %wide.load424.1 = load <4 x float>, ptr %1035, align 4, !tbaa !13
  %wide.load425.1 = load <4 x float>, ptr %1036, align 4, !tbaa !13
  %1037 = getelementptr inbounds i8, ptr %12, i64 2592
  %1038 = getelementptr inbounds i8, ptr %12, i64 2608
  %wide.load426.1 = load <4 x float>, ptr %1037, align 4, !tbaa !13
  %wide.load427.1 = load <4 x float>, ptr %1038, align 4, !tbaa !13
  %1039 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1033, <4 x float> %wide.load424.1, <4 x float> %wide.load426.1)
  %1040 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1034, <4 x float> %wide.load425.1, <4 x float> %wide.load427.1)
  %1041 = getelementptr inbounds i8, ptr %13, i64 163872
  %1042 = getelementptr inbounds i8, ptr %13, i64 163888
  store <4 x float> %1039, ptr %1041, align 4, !tbaa !13
  store <4 x float> %1040, ptr %1042, align 4, !tbaa !13
  %1043 = getelementptr inbounds i8, ptr %8, i64 163904
  %1044 = getelementptr inbounds i8, ptr %8, i64 163920
  %wide.load418.2 = load <4 x float>, ptr %1043, align 4, !tbaa !13
  %wide.load419.2 = load <4 x float>, ptr %1044, align 4, !tbaa !13
  %1045 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load418.2, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1046 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load419.2, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1047 = getelementptr inbounds i8, ptr %11, i64 2624
  %1048 = getelementptr inbounds i8, ptr %11, i64 2640
  %wide.load424.2 = load <4 x float>, ptr %1047, align 4, !tbaa !13
  %wide.load425.2 = load <4 x float>, ptr %1048, align 4, !tbaa !13
  %1049 = getelementptr inbounds i8, ptr %12, i64 2624
  %1050 = getelementptr inbounds i8, ptr %12, i64 2640
  %wide.load426.2 = load <4 x float>, ptr %1049, align 4, !tbaa !13
  %wide.load427.2 = load <4 x float>, ptr %1050, align 4, !tbaa !13
  %1051 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1045, <4 x float> %wide.load424.2, <4 x float> %wide.load426.2)
  %1052 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1046, <4 x float> %wide.load425.2, <4 x float> %wide.load427.2)
  %1053 = getelementptr inbounds i8, ptr %13, i64 163904
  %1054 = getelementptr inbounds i8, ptr %13, i64 163920
  store <4 x float> %1051, ptr %1053, align 4, !tbaa !13
  store <4 x float> %1052, ptr %1054, align 4, !tbaa !13
  %1055 = getelementptr inbounds i8, ptr %8, i64 163936
  %1056 = getelementptr inbounds i8, ptr %8, i64 163952
  %wide.load418.3 = load <4 x float>, ptr %1055, align 4, !tbaa !13
  %wide.load419.3 = load <4 x float>, ptr %1056, align 4, !tbaa !13
  %1057 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load418.3, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1058 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load419.3, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1059 = getelementptr inbounds i8, ptr %11, i64 2656
  %1060 = getelementptr inbounds i8, ptr %11, i64 2672
  %wide.load424.3 = load <4 x float>, ptr %1059, align 4, !tbaa !13
  %wide.load425.3 = load <4 x float>, ptr %1060, align 4, !tbaa !13
  %1061 = getelementptr inbounds i8, ptr %12, i64 2656
  %1062 = getelementptr inbounds i8, ptr %12, i64 2672
  %wide.load426.3 = load <4 x float>, ptr %1061, align 4, !tbaa !13
  %wide.load427.3 = load <4 x float>, ptr %1062, align 4, !tbaa !13
  %1063 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1057, <4 x float> %wide.load424.3, <4 x float> %wide.load426.3)
  %1064 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1058, <4 x float> %wide.load425.3, <4 x float> %wide.load427.3)
  %1065 = getelementptr inbounds i8, ptr %13, i64 163936
  %1066 = getelementptr inbounds i8, ptr %13, i64 163952
  store <4 x float> %1063, ptr %1065, align 4, !tbaa !13
  store <4 x float> %1064, ptr %1066, align 4, !tbaa !13
  %1067 = getelementptr inbounds i8, ptr %8, i64 163968
  %1068 = getelementptr inbounds i8, ptr %8, i64 163984
  %wide.load418.4 = load <4 x float>, ptr %1067, align 4, !tbaa !13
  %wide.load419.4 = load <4 x float>, ptr %1068, align 4, !tbaa !13
  %1069 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load418.4, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1070 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load419.4, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1071 = getelementptr inbounds i8, ptr %11, i64 2688
  %1072 = getelementptr inbounds i8, ptr %11, i64 2704
  %wide.load424.4 = load <4 x float>, ptr %1071, align 4, !tbaa !13
  %wide.load425.4 = load <4 x float>, ptr %1072, align 4, !tbaa !13
  %1073 = getelementptr inbounds i8, ptr %12, i64 2688
  %1074 = getelementptr inbounds i8, ptr %12, i64 2704
  %wide.load426.4 = load <4 x float>, ptr %1073, align 4, !tbaa !13
  %wide.load427.4 = load <4 x float>, ptr %1074, align 4, !tbaa !13
  %1075 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1069, <4 x float> %wide.load424.4, <4 x float> %wide.load426.4)
  %1076 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1070, <4 x float> %wide.load425.4, <4 x float> %wide.load427.4)
  %1077 = getelementptr inbounds i8, ptr %13, i64 163968
  %1078 = getelementptr inbounds i8, ptr %13, i64 163984
  store <4 x float> %1075, ptr %1077, align 4, !tbaa !13
  store <4 x float> %1076, ptr %1078, align 4, !tbaa !13
  %1079 = getelementptr inbounds i8, ptr %8, i64 164000
  %1080 = getelementptr inbounds i8, ptr %8, i64 164016
  %wide.load418.5 = load <4 x float>, ptr %1079, align 4, !tbaa !13
  %wide.load419.5 = load <4 x float>, ptr %1080, align 4, !tbaa !13
  %1081 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load418.5, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1082 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load419.5, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1083 = getelementptr inbounds i8, ptr %11, i64 2720
  %1084 = getelementptr inbounds i8, ptr %11, i64 2736
  %wide.load424.5 = load <4 x float>, ptr %1083, align 4, !tbaa !13
  %wide.load425.5 = load <4 x float>, ptr %1084, align 4, !tbaa !13
  %1085 = getelementptr inbounds i8, ptr %12, i64 2720
  %1086 = getelementptr inbounds i8, ptr %12, i64 2736
  %wide.load426.5 = load <4 x float>, ptr %1085, align 4, !tbaa !13
  %wide.load427.5 = load <4 x float>, ptr %1086, align 4, !tbaa !13
  %1087 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1081, <4 x float> %wide.load424.5, <4 x float> %wide.load426.5)
  %1088 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1082, <4 x float> %wide.load425.5, <4 x float> %wide.load427.5)
  %1089 = getelementptr inbounds i8, ptr %13, i64 164000
  %1090 = getelementptr inbounds i8, ptr %13, i64 164016
  store <4 x float> %1087, ptr %1089, align 4, !tbaa !13
  store <4 x float> %1088, ptr %1090, align 4, !tbaa !13
  %1091 = getelementptr inbounds i8, ptr %8, i64 164032
  %1092 = getelementptr inbounds i8, ptr %8, i64 164048
  %wide.load418.6 = load <4 x float>, ptr %1091, align 4, !tbaa !13
  %wide.load419.6 = load <4 x float>, ptr %1092, align 4, !tbaa !13
  %1093 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load418.6, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1094 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load419.6, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1095 = getelementptr inbounds i8, ptr %11, i64 2752
  %1096 = getelementptr inbounds i8, ptr %11, i64 2768
  %wide.load424.6 = load <4 x float>, ptr %1095, align 4, !tbaa !13
  %wide.load425.6 = load <4 x float>, ptr %1096, align 4, !tbaa !13
  %1097 = getelementptr inbounds i8, ptr %12, i64 2752
  %1098 = getelementptr inbounds i8, ptr %12, i64 2768
  %wide.load426.6 = load <4 x float>, ptr %1097, align 4, !tbaa !13
  %wide.load427.6 = load <4 x float>, ptr %1098, align 4, !tbaa !13
  %1099 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1093, <4 x float> %wide.load424.6, <4 x float> %wide.load426.6)
  %1100 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1094, <4 x float> %wide.load425.6, <4 x float> %wide.load427.6)
  %1101 = getelementptr inbounds i8, ptr %13, i64 164032
  %1102 = getelementptr inbounds i8, ptr %13, i64 164048
  store <4 x float> %1099, ptr %1101, align 4, !tbaa !13
  store <4 x float> %1100, ptr %1102, align 4, !tbaa !13
  %1103 = getelementptr inbounds i8, ptr %8, i64 164064
  %1104 = getelementptr inbounds i8, ptr %8, i64 164080
  %wide.load418.7 = load <4 x float>, ptr %1103, align 4, !tbaa !13
  %wide.load419.7 = load <4 x float>, ptr %1104, align 4, !tbaa !13
  %1105 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load418.7, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1106 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load419.7, <4 x float> %broadcast.splat421, <4 x float> %broadcast.splat423)
  %1107 = getelementptr inbounds i8, ptr %11, i64 2784
  %1108 = getelementptr inbounds i8, ptr %11, i64 2800
  %wide.load424.7 = load <4 x float>, ptr %1107, align 4, !tbaa !13
  %wide.load425.7 = load <4 x float>, ptr %1108, align 4, !tbaa !13
  %1109 = getelementptr inbounds i8, ptr %12, i64 2784
  %1110 = getelementptr inbounds i8, ptr %12, i64 2800
  %wide.load426.7 = load <4 x float>, ptr %1109, align 4, !tbaa !13
  %wide.load427.7 = load <4 x float>, ptr %1110, align 4, !tbaa !13
  %1111 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1105, <4 x float> %wide.load424.7, <4 x float> %wide.load426.7)
  %1112 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1106, <4 x float> %wide.load425.7, <4 x float> %wide.load427.7)
  %1113 = getelementptr inbounds i8, ptr %13, i64 164064
  %1114 = getelementptr inbounds i8, ptr %13, i64 164080
  store <4 x float> %1111, ptr %1113, align 4, !tbaa !13
  store <4 x float> %1112, ptr %1114, align 4, !tbaa !13
  %broadcast.splatinsert439 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat440 = shufflevector <4 x float> %broadcast.splatinsert439, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert437 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat438 = shufflevector <4 x float> %broadcast.splatinsert437, <4 x float> poison, <4 x i32> zeroinitializer
  %1115 = getelementptr inbounds i8, ptr %8, i64 180224
  %1116 = getelementptr inbounds i8, ptr %8, i64 180240
  %wide.load435 = load <4 x float>, ptr %1115, align 4, !tbaa !13
  %wide.load436 = load <4 x float>, ptr %1116, align 4, !tbaa !13
  %1117 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load435, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1118 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load436, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1119 = getelementptr inbounds i8, ptr %11, i64 2816
  %1120 = getelementptr inbounds i8, ptr %11, i64 2832
  %wide.load441 = load <4 x float>, ptr %1119, align 4, !tbaa !13
  %wide.load442 = load <4 x float>, ptr %1120, align 4, !tbaa !13
  %1121 = getelementptr inbounds i8, ptr %12, i64 2816
  %1122 = getelementptr inbounds i8, ptr %12, i64 2832
  %wide.load443 = load <4 x float>, ptr %1121, align 4, !tbaa !13
  %wide.load444 = load <4 x float>, ptr %1122, align 4, !tbaa !13
  %1123 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1117, <4 x float> %wide.load441, <4 x float> %wide.load443)
  %1124 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1118, <4 x float> %wide.load442, <4 x float> %wide.load444)
  %1125 = getelementptr inbounds i8, ptr %13, i64 180224
  %1126 = getelementptr inbounds i8, ptr %13, i64 180240
  store <4 x float> %1123, ptr %1125, align 4, !tbaa !13
  store <4 x float> %1124, ptr %1126, align 4, !tbaa !13
  %1127 = getelementptr inbounds i8, ptr %8, i64 180256
  %1128 = getelementptr inbounds i8, ptr %8, i64 180272
  %wide.load435.1 = load <4 x float>, ptr %1127, align 4, !tbaa !13
  %wide.load436.1 = load <4 x float>, ptr %1128, align 4, !tbaa !13
  %1129 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load435.1, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1130 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load436.1, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1131 = getelementptr inbounds i8, ptr %11, i64 2848
  %1132 = getelementptr inbounds i8, ptr %11, i64 2864
  %wide.load441.1 = load <4 x float>, ptr %1131, align 4, !tbaa !13
  %wide.load442.1 = load <4 x float>, ptr %1132, align 4, !tbaa !13
  %1133 = getelementptr inbounds i8, ptr %12, i64 2848
  %1134 = getelementptr inbounds i8, ptr %12, i64 2864
  %wide.load443.1 = load <4 x float>, ptr %1133, align 4, !tbaa !13
  %wide.load444.1 = load <4 x float>, ptr %1134, align 4, !tbaa !13
  %1135 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1129, <4 x float> %wide.load441.1, <4 x float> %wide.load443.1)
  %1136 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1130, <4 x float> %wide.load442.1, <4 x float> %wide.load444.1)
  %1137 = getelementptr inbounds i8, ptr %13, i64 180256
  %1138 = getelementptr inbounds i8, ptr %13, i64 180272
  store <4 x float> %1135, ptr %1137, align 4, !tbaa !13
  store <4 x float> %1136, ptr %1138, align 4, !tbaa !13
  %1139 = getelementptr inbounds i8, ptr %8, i64 180288
  %1140 = getelementptr inbounds i8, ptr %8, i64 180304
  %wide.load435.2 = load <4 x float>, ptr %1139, align 4, !tbaa !13
  %wide.load436.2 = load <4 x float>, ptr %1140, align 4, !tbaa !13
  %1141 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load435.2, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1142 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load436.2, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1143 = getelementptr inbounds i8, ptr %11, i64 2880
  %1144 = getelementptr inbounds i8, ptr %11, i64 2896
  %wide.load441.2 = load <4 x float>, ptr %1143, align 4, !tbaa !13
  %wide.load442.2 = load <4 x float>, ptr %1144, align 4, !tbaa !13
  %1145 = getelementptr inbounds i8, ptr %12, i64 2880
  %1146 = getelementptr inbounds i8, ptr %12, i64 2896
  %wide.load443.2 = load <4 x float>, ptr %1145, align 4, !tbaa !13
  %wide.load444.2 = load <4 x float>, ptr %1146, align 4, !tbaa !13
  %1147 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1141, <4 x float> %wide.load441.2, <4 x float> %wide.load443.2)
  %1148 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1142, <4 x float> %wide.load442.2, <4 x float> %wide.load444.2)
  %1149 = getelementptr inbounds i8, ptr %13, i64 180288
  %1150 = getelementptr inbounds i8, ptr %13, i64 180304
  store <4 x float> %1147, ptr %1149, align 4, !tbaa !13
  store <4 x float> %1148, ptr %1150, align 4, !tbaa !13
  %1151 = getelementptr inbounds i8, ptr %8, i64 180320
  %1152 = getelementptr inbounds i8, ptr %8, i64 180336
  %wide.load435.3 = load <4 x float>, ptr %1151, align 4, !tbaa !13
  %wide.load436.3 = load <4 x float>, ptr %1152, align 4, !tbaa !13
  %1153 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load435.3, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1154 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load436.3, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1155 = getelementptr inbounds i8, ptr %11, i64 2912
  %1156 = getelementptr inbounds i8, ptr %11, i64 2928
  %wide.load441.3 = load <4 x float>, ptr %1155, align 4, !tbaa !13
  %wide.load442.3 = load <4 x float>, ptr %1156, align 4, !tbaa !13
  %1157 = getelementptr inbounds i8, ptr %12, i64 2912
  %1158 = getelementptr inbounds i8, ptr %12, i64 2928
  %wide.load443.3 = load <4 x float>, ptr %1157, align 4, !tbaa !13
  %wide.load444.3 = load <4 x float>, ptr %1158, align 4, !tbaa !13
  %1159 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1153, <4 x float> %wide.load441.3, <4 x float> %wide.load443.3)
  %1160 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1154, <4 x float> %wide.load442.3, <4 x float> %wide.load444.3)
  %1161 = getelementptr inbounds i8, ptr %13, i64 180320
  %1162 = getelementptr inbounds i8, ptr %13, i64 180336
  store <4 x float> %1159, ptr %1161, align 4, !tbaa !13
  store <4 x float> %1160, ptr %1162, align 4, !tbaa !13
  %1163 = getelementptr inbounds i8, ptr %8, i64 180352
  %1164 = getelementptr inbounds i8, ptr %8, i64 180368
  %wide.load435.4 = load <4 x float>, ptr %1163, align 4, !tbaa !13
  %wide.load436.4 = load <4 x float>, ptr %1164, align 4, !tbaa !13
  %1165 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load435.4, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1166 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load436.4, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1167 = getelementptr inbounds i8, ptr %11, i64 2944
  %1168 = getelementptr inbounds i8, ptr %11, i64 2960
  %wide.load441.4 = load <4 x float>, ptr %1167, align 4, !tbaa !13
  %wide.load442.4 = load <4 x float>, ptr %1168, align 4, !tbaa !13
  %1169 = getelementptr inbounds i8, ptr %12, i64 2944
  %1170 = getelementptr inbounds i8, ptr %12, i64 2960
  %wide.load443.4 = load <4 x float>, ptr %1169, align 4, !tbaa !13
  %wide.load444.4 = load <4 x float>, ptr %1170, align 4, !tbaa !13
  %1171 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1165, <4 x float> %wide.load441.4, <4 x float> %wide.load443.4)
  %1172 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1166, <4 x float> %wide.load442.4, <4 x float> %wide.load444.4)
  %1173 = getelementptr inbounds i8, ptr %13, i64 180352
  %1174 = getelementptr inbounds i8, ptr %13, i64 180368
  store <4 x float> %1171, ptr %1173, align 4, !tbaa !13
  store <4 x float> %1172, ptr %1174, align 4, !tbaa !13
  %1175 = getelementptr inbounds i8, ptr %8, i64 180384
  %1176 = getelementptr inbounds i8, ptr %8, i64 180400
  %wide.load435.5 = load <4 x float>, ptr %1175, align 4, !tbaa !13
  %wide.load436.5 = load <4 x float>, ptr %1176, align 4, !tbaa !13
  %1177 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load435.5, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1178 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load436.5, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1179 = getelementptr inbounds i8, ptr %11, i64 2976
  %1180 = getelementptr inbounds i8, ptr %11, i64 2992
  %wide.load441.5 = load <4 x float>, ptr %1179, align 4, !tbaa !13
  %wide.load442.5 = load <4 x float>, ptr %1180, align 4, !tbaa !13
  %1181 = getelementptr inbounds i8, ptr %12, i64 2976
  %1182 = getelementptr inbounds i8, ptr %12, i64 2992
  %wide.load443.5 = load <4 x float>, ptr %1181, align 4, !tbaa !13
  %wide.load444.5 = load <4 x float>, ptr %1182, align 4, !tbaa !13
  %1183 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1177, <4 x float> %wide.load441.5, <4 x float> %wide.load443.5)
  %1184 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1178, <4 x float> %wide.load442.5, <4 x float> %wide.load444.5)
  %1185 = getelementptr inbounds i8, ptr %13, i64 180384
  %1186 = getelementptr inbounds i8, ptr %13, i64 180400
  store <4 x float> %1183, ptr %1185, align 4, !tbaa !13
  store <4 x float> %1184, ptr %1186, align 4, !tbaa !13
  %1187 = getelementptr inbounds i8, ptr %8, i64 180416
  %1188 = getelementptr inbounds i8, ptr %8, i64 180432
  %wide.load435.6 = load <4 x float>, ptr %1187, align 4, !tbaa !13
  %wide.load436.6 = load <4 x float>, ptr %1188, align 4, !tbaa !13
  %1189 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load435.6, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1190 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load436.6, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1191 = getelementptr inbounds i8, ptr %11, i64 3008
  %1192 = getelementptr inbounds i8, ptr %11, i64 3024
  %wide.load441.6 = load <4 x float>, ptr %1191, align 4, !tbaa !13
  %wide.load442.6 = load <4 x float>, ptr %1192, align 4, !tbaa !13
  %1193 = getelementptr inbounds i8, ptr %12, i64 3008
  %1194 = getelementptr inbounds i8, ptr %12, i64 3024
  %wide.load443.6 = load <4 x float>, ptr %1193, align 4, !tbaa !13
  %wide.load444.6 = load <4 x float>, ptr %1194, align 4, !tbaa !13
  %1195 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1189, <4 x float> %wide.load441.6, <4 x float> %wide.load443.6)
  %1196 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1190, <4 x float> %wide.load442.6, <4 x float> %wide.load444.6)
  %1197 = getelementptr inbounds i8, ptr %13, i64 180416
  %1198 = getelementptr inbounds i8, ptr %13, i64 180432
  store <4 x float> %1195, ptr %1197, align 4, !tbaa !13
  store <4 x float> %1196, ptr %1198, align 4, !tbaa !13
  %1199 = getelementptr inbounds i8, ptr %8, i64 180448
  %1200 = getelementptr inbounds i8, ptr %8, i64 180464
  %wide.load435.7 = load <4 x float>, ptr %1199, align 4, !tbaa !13
  %wide.load436.7 = load <4 x float>, ptr %1200, align 4, !tbaa !13
  %1201 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load435.7, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1202 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load436.7, <4 x float> %broadcast.splat438, <4 x float> %broadcast.splat440)
  %1203 = getelementptr inbounds i8, ptr %11, i64 3040
  %1204 = getelementptr inbounds i8, ptr %11, i64 3056
  %wide.load441.7 = load <4 x float>, ptr %1203, align 4, !tbaa !13
  %wide.load442.7 = load <4 x float>, ptr %1204, align 4, !tbaa !13
  %1205 = getelementptr inbounds i8, ptr %12, i64 3040
  %1206 = getelementptr inbounds i8, ptr %12, i64 3056
  %wide.load443.7 = load <4 x float>, ptr %1205, align 4, !tbaa !13
  %wide.load444.7 = load <4 x float>, ptr %1206, align 4, !tbaa !13
  %1207 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1201, <4 x float> %wide.load441.7, <4 x float> %wide.load443.7)
  %1208 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1202, <4 x float> %wide.load442.7, <4 x float> %wide.load444.7)
  %1209 = getelementptr inbounds i8, ptr %13, i64 180448
  %1210 = getelementptr inbounds i8, ptr %13, i64 180464
  store <4 x float> %1207, ptr %1209, align 4, !tbaa !13
  store <4 x float> %1208, ptr %1210, align 4, !tbaa !13
  %broadcast.splatinsert456 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat457 = shufflevector <4 x float> %broadcast.splatinsert456, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert454 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat455 = shufflevector <4 x float> %broadcast.splatinsert454, <4 x float> poison, <4 x i32> zeroinitializer
  %1211 = getelementptr inbounds i8, ptr %8, i64 196608
  %1212 = getelementptr inbounds i8, ptr %8, i64 196624
  %wide.load452 = load <4 x float>, ptr %1211, align 4, !tbaa !13
  %wide.load453 = load <4 x float>, ptr %1212, align 4, !tbaa !13
  %1213 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load452, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1214 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load453, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1215 = getelementptr inbounds i8, ptr %11, i64 3072
  %1216 = getelementptr inbounds i8, ptr %11, i64 3088
  %wide.load458 = load <4 x float>, ptr %1215, align 4, !tbaa !13
  %wide.load459 = load <4 x float>, ptr %1216, align 4, !tbaa !13
  %1217 = getelementptr inbounds i8, ptr %12, i64 3072
  %1218 = getelementptr inbounds i8, ptr %12, i64 3088
  %wide.load460 = load <4 x float>, ptr %1217, align 4, !tbaa !13
  %wide.load461 = load <4 x float>, ptr %1218, align 4, !tbaa !13
  %1219 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1213, <4 x float> %wide.load458, <4 x float> %wide.load460)
  %1220 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1214, <4 x float> %wide.load459, <4 x float> %wide.load461)
  %1221 = getelementptr inbounds i8, ptr %13, i64 196608
  %1222 = getelementptr inbounds i8, ptr %13, i64 196624
  store <4 x float> %1219, ptr %1221, align 4, !tbaa !13
  store <4 x float> %1220, ptr %1222, align 4, !tbaa !13
  %1223 = getelementptr inbounds i8, ptr %8, i64 196640
  %1224 = getelementptr inbounds i8, ptr %8, i64 196656
  %wide.load452.1 = load <4 x float>, ptr %1223, align 4, !tbaa !13
  %wide.load453.1 = load <4 x float>, ptr %1224, align 4, !tbaa !13
  %1225 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load452.1, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1226 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load453.1, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1227 = getelementptr inbounds i8, ptr %11, i64 3104
  %1228 = getelementptr inbounds i8, ptr %11, i64 3120
  %wide.load458.1 = load <4 x float>, ptr %1227, align 4, !tbaa !13
  %wide.load459.1 = load <4 x float>, ptr %1228, align 4, !tbaa !13
  %1229 = getelementptr inbounds i8, ptr %12, i64 3104
  %1230 = getelementptr inbounds i8, ptr %12, i64 3120
  %wide.load460.1 = load <4 x float>, ptr %1229, align 4, !tbaa !13
  %wide.load461.1 = load <4 x float>, ptr %1230, align 4, !tbaa !13
  %1231 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1225, <4 x float> %wide.load458.1, <4 x float> %wide.load460.1)
  %1232 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1226, <4 x float> %wide.load459.1, <4 x float> %wide.load461.1)
  %1233 = getelementptr inbounds i8, ptr %13, i64 196640
  %1234 = getelementptr inbounds i8, ptr %13, i64 196656
  store <4 x float> %1231, ptr %1233, align 4, !tbaa !13
  store <4 x float> %1232, ptr %1234, align 4, !tbaa !13
  %1235 = getelementptr inbounds i8, ptr %8, i64 196672
  %1236 = getelementptr inbounds i8, ptr %8, i64 196688
  %wide.load452.2 = load <4 x float>, ptr %1235, align 4, !tbaa !13
  %wide.load453.2 = load <4 x float>, ptr %1236, align 4, !tbaa !13
  %1237 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load452.2, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1238 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load453.2, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1239 = getelementptr inbounds i8, ptr %11, i64 3136
  %1240 = getelementptr inbounds i8, ptr %11, i64 3152
  %wide.load458.2 = load <4 x float>, ptr %1239, align 4, !tbaa !13
  %wide.load459.2 = load <4 x float>, ptr %1240, align 4, !tbaa !13
  %1241 = getelementptr inbounds i8, ptr %12, i64 3136
  %1242 = getelementptr inbounds i8, ptr %12, i64 3152
  %wide.load460.2 = load <4 x float>, ptr %1241, align 4, !tbaa !13
  %wide.load461.2 = load <4 x float>, ptr %1242, align 4, !tbaa !13
  %1243 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1237, <4 x float> %wide.load458.2, <4 x float> %wide.load460.2)
  %1244 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1238, <4 x float> %wide.load459.2, <4 x float> %wide.load461.2)
  %1245 = getelementptr inbounds i8, ptr %13, i64 196672
  %1246 = getelementptr inbounds i8, ptr %13, i64 196688
  store <4 x float> %1243, ptr %1245, align 4, !tbaa !13
  store <4 x float> %1244, ptr %1246, align 4, !tbaa !13
  %1247 = getelementptr inbounds i8, ptr %8, i64 196704
  %1248 = getelementptr inbounds i8, ptr %8, i64 196720
  %wide.load452.3 = load <4 x float>, ptr %1247, align 4, !tbaa !13
  %wide.load453.3 = load <4 x float>, ptr %1248, align 4, !tbaa !13
  %1249 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load452.3, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1250 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load453.3, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1251 = getelementptr inbounds i8, ptr %11, i64 3168
  %1252 = getelementptr inbounds i8, ptr %11, i64 3184
  %wide.load458.3 = load <4 x float>, ptr %1251, align 4, !tbaa !13
  %wide.load459.3 = load <4 x float>, ptr %1252, align 4, !tbaa !13
  %1253 = getelementptr inbounds i8, ptr %12, i64 3168
  %1254 = getelementptr inbounds i8, ptr %12, i64 3184
  %wide.load460.3 = load <4 x float>, ptr %1253, align 4, !tbaa !13
  %wide.load461.3 = load <4 x float>, ptr %1254, align 4, !tbaa !13
  %1255 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1249, <4 x float> %wide.load458.3, <4 x float> %wide.load460.3)
  %1256 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1250, <4 x float> %wide.load459.3, <4 x float> %wide.load461.3)
  %1257 = getelementptr inbounds i8, ptr %13, i64 196704
  %1258 = getelementptr inbounds i8, ptr %13, i64 196720
  store <4 x float> %1255, ptr %1257, align 4, !tbaa !13
  store <4 x float> %1256, ptr %1258, align 4, !tbaa !13
  %1259 = getelementptr inbounds i8, ptr %8, i64 196736
  %1260 = getelementptr inbounds i8, ptr %8, i64 196752
  %wide.load452.4 = load <4 x float>, ptr %1259, align 4, !tbaa !13
  %wide.load453.4 = load <4 x float>, ptr %1260, align 4, !tbaa !13
  %1261 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load452.4, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1262 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load453.4, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1263 = getelementptr inbounds i8, ptr %11, i64 3200
  %1264 = getelementptr inbounds i8, ptr %11, i64 3216
  %wide.load458.4 = load <4 x float>, ptr %1263, align 4, !tbaa !13
  %wide.load459.4 = load <4 x float>, ptr %1264, align 4, !tbaa !13
  %1265 = getelementptr inbounds i8, ptr %12, i64 3200
  %1266 = getelementptr inbounds i8, ptr %12, i64 3216
  %wide.load460.4 = load <4 x float>, ptr %1265, align 4, !tbaa !13
  %wide.load461.4 = load <4 x float>, ptr %1266, align 4, !tbaa !13
  %1267 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1261, <4 x float> %wide.load458.4, <4 x float> %wide.load460.4)
  %1268 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1262, <4 x float> %wide.load459.4, <4 x float> %wide.load461.4)
  %1269 = getelementptr inbounds i8, ptr %13, i64 196736
  %1270 = getelementptr inbounds i8, ptr %13, i64 196752
  store <4 x float> %1267, ptr %1269, align 4, !tbaa !13
  store <4 x float> %1268, ptr %1270, align 4, !tbaa !13
  %1271 = getelementptr inbounds i8, ptr %8, i64 196768
  %1272 = getelementptr inbounds i8, ptr %8, i64 196784
  %wide.load452.5 = load <4 x float>, ptr %1271, align 4, !tbaa !13
  %wide.load453.5 = load <4 x float>, ptr %1272, align 4, !tbaa !13
  %1273 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load452.5, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1274 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load453.5, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1275 = getelementptr inbounds i8, ptr %11, i64 3232
  %1276 = getelementptr inbounds i8, ptr %11, i64 3248
  %wide.load458.5 = load <4 x float>, ptr %1275, align 4, !tbaa !13
  %wide.load459.5 = load <4 x float>, ptr %1276, align 4, !tbaa !13
  %1277 = getelementptr inbounds i8, ptr %12, i64 3232
  %1278 = getelementptr inbounds i8, ptr %12, i64 3248
  %wide.load460.5 = load <4 x float>, ptr %1277, align 4, !tbaa !13
  %wide.load461.5 = load <4 x float>, ptr %1278, align 4, !tbaa !13
  %1279 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1273, <4 x float> %wide.load458.5, <4 x float> %wide.load460.5)
  %1280 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1274, <4 x float> %wide.load459.5, <4 x float> %wide.load461.5)
  %1281 = getelementptr inbounds i8, ptr %13, i64 196768
  %1282 = getelementptr inbounds i8, ptr %13, i64 196784
  store <4 x float> %1279, ptr %1281, align 4, !tbaa !13
  store <4 x float> %1280, ptr %1282, align 4, !tbaa !13
  %1283 = getelementptr inbounds i8, ptr %8, i64 196800
  %1284 = getelementptr inbounds i8, ptr %8, i64 196816
  %wide.load452.6 = load <4 x float>, ptr %1283, align 4, !tbaa !13
  %wide.load453.6 = load <4 x float>, ptr %1284, align 4, !tbaa !13
  %1285 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load452.6, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1286 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load453.6, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1287 = getelementptr inbounds i8, ptr %11, i64 3264
  %1288 = getelementptr inbounds i8, ptr %11, i64 3280
  %wide.load458.6 = load <4 x float>, ptr %1287, align 4, !tbaa !13
  %wide.load459.6 = load <4 x float>, ptr %1288, align 4, !tbaa !13
  %1289 = getelementptr inbounds i8, ptr %12, i64 3264
  %1290 = getelementptr inbounds i8, ptr %12, i64 3280
  %wide.load460.6 = load <4 x float>, ptr %1289, align 4, !tbaa !13
  %wide.load461.6 = load <4 x float>, ptr %1290, align 4, !tbaa !13
  %1291 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1285, <4 x float> %wide.load458.6, <4 x float> %wide.load460.6)
  %1292 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1286, <4 x float> %wide.load459.6, <4 x float> %wide.load461.6)
  %1293 = getelementptr inbounds i8, ptr %13, i64 196800
  %1294 = getelementptr inbounds i8, ptr %13, i64 196816
  store <4 x float> %1291, ptr %1293, align 4, !tbaa !13
  store <4 x float> %1292, ptr %1294, align 4, !tbaa !13
  %1295 = getelementptr inbounds i8, ptr %8, i64 196832
  %1296 = getelementptr inbounds i8, ptr %8, i64 196848
  %wide.load452.7 = load <4 x float>, ptr %1295, align 4, !tbaa !13
  %wide.load453.7 = load <4 x float>, ptr %1296, align 4, !tbaa !13
  %1297 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load452.7, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1298 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load453.7, <4 x float> %broadcast.splat455, <4 x float> %broadcast.splat457)
  %1299 = getelementptr inbounds i8, ptr %11, i64 3296
  %1300 = getelementptr inbounds i8, ptr %11, i64 3312
  %wide.load458.7 = load <4 x float>, ptr %1299, align 4, !tbaa !13
  %wide.load459.7 = load <4 x float>, ptr %1300, align 4, !tbaa !13
  %1301 = getelementptr inbounds i8, ptr %12, i64 3296
  %1302 = getelementptr inbounds i8, ptr %12, i64 3312
  %wide.load460.7 = load <4 x float>, ptr %1301, align 4, !tbaa !13
  %wide.load461.7 = load <4 x float>, ptr %1302, align 4, !tbaa !13
  %1303 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1297, <4 x float> %wide.load458.7, <4 x float> %wide.load460.7)
  %1304 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1298, <4 x float> %wide.load459.7, <4 x float> %wide.load461.7)
  %1305 = getelementptr inbounds i8, ptr %13, i64 196832
  %1306 = getelementptr inbounds i8, ptr %13, i64 196848
  store <4 x float> %1303, ptr %1305, align 4, !tbaa !13
  store <4 x float> %1304, ptr %1306, align 4, !tbaa !13
  %broadcast.splatinsert473 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat474 = shufflevector <4 x float> %broadcast.splatinsert473, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert471 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat472 = shufflevector <4 x float> %broadcast.splatinsert471, <4 x float> poison, <4 x i32> zeroinitializer
  %1307 = getelementptr inbounds i8, ptr %8, i64 212992
  %1308 = getelementptr inbounds i8, ptr %8, i64 213008
  %wide.load469 = load <4 x float>, ptr %1307, align 4, !tbaa !13
  %wide.load470 = load <4 x float>, ptr %1308, align 4, !tbaa !13
  %1309 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load469, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1310 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load470, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1311 = getelementptr inbounds i8, ptr %11, i64 3328
  %1312 = getelementptr inbounds i8, ptr %11, i64 3344
  %wide.load475 = load <4 x float>, ptr %1311, align 4, !tbaa !13
  %wide.load476 = load <4 x float>, ptr %1312, align 4, !tbaa !13
  %1313 = getelementptr inbounds i8, ptr %12, i64 3328
  %1314 = getelementptr inbounds i8, ptr %12, i64 3344
  %wide.load477 = load <4 x float>, ptr %1313, align 4, !tbaa !13
  %wide.load478 = load <4 x float>, ptr %1314, align 4, !tbaa !13
  %1315 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1309, <4 x float> %wide.load475, <4 x float> %wide.load477)
  %1316 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1310, <4 x float> %wide.load476, <4 x float> %wide.load478)
  %1317 = getelementptr inbounds i8, ptr %13, i64 212992
  %1318 = getelementptr inbounds i8, ptr %13, i64 213008
  store <4 x float> %1315, ptr %1317, align 4, !tbaa !13
  store <4 x float> %1316, ptr %1318, align 4, !tbaa !13
  %1319 = getelementptr inbounds i8, ptr %8, i64 213024
  %1320 = getelementptr inbounds i8, ptr %8, i64 213040
  %wide.load469.1 = load <4 x float>, ptr %1319, align 4, !tbaa !13
  %wide.load470.1 = load <4 x float>, ptr %1320, align 4, !tbaa !13
  %1321 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load469.1, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1322 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load470.1, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1323 = getelementptr inbounds i8, ptr %11, i64 3360
  %1324 = getelementptr inbounds i8, ptr %11, i64 3376
  %wide.load475.1 = load <4 x float>, ptr %1323, align 4, !tbaa !13
  %wide.load476.1 = load <4 x float>, ptr %1324, align 4, !tbaa !13
  %1325 = getelementptr inbounds i8, ptr %12, i64 3360
  %1326 = getelementptr inbounds i8, ptr %12, i64 3376
  %wide.load477.1 = load <4 x float>, ptr %1325, align 4, !tbaa !13
  %wide.load478.1 = load <4 x float>, ptr %1326, align 4, !tbaa !13
  %1327 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1321, <4 x float> %wide.load475.1, <4 x float> %wide.load477.1)
  %1328 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1322, <4 x float> %wide.load476.1, <4 x float> %wide.load478.1)
  %1329 = getelementptr inbounds i8, ptr %13, i64 213024
  %1330 = getelementptr inbounds i8, ptr %13, i64 213040
  store <4 x float> %1327, ptr %1329, align 4, !tbaa !13
  store <4 x float> %1328, ptr %1330, align 4, !tbaa !13
  %1331 = getelementptr inbounds i8, ptr %8, i64 213056
  %1332 = getelementptr inbounds i8, ptr %8, i64 213072
  %wide.load469.2 = load <4 x float>, ptr %1331, align 4, !tbaa !13
  %wide.load470.2 = load <4 x float>, ptr %1332, align 4, !tbaa !13
  %1333 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load469.2, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1334 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load470.2, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1335 = getelementptr inbounds i8, ptr %11, i64 3392
  %1336 = getelementptr inbounds i8, ptr %11, i64 3408
  %wide.load475.2 = load <4 x float>, ptr %1335, align 4, !tbaa !13
  %wide.load476.2 = load <4 x float>, ptr %1336, align 4, !tbaa !13
  %1337 = getelementptr inbounds i8, ptr %12, i64 3392
  %1338 = getelementptr inbounds i8, ptr %12, i64 3408
  %wide.load477.2 = load <4 x float>, ptr %1337, align 4, !tbaa !13
  %wide.load478.2 = load <4 x float>, ptr %1338, align 4, !tbaa !13
  %1339 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1333, <4 x float> %wide.load475.2, <4 x float> %wide.load477.2)
  %1340 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1334, <4 x float> %wide.load476.2, <4 x float> %wide.load478.2)
  %1341 = getelementptr inbounds i8, ptr %13, i64 213056
  %1342 = getelementptr inbounds i8, ptr %13, i64 213072
  store <4 x float> %1339, ptr %1341, align 4, !tbaa !13
  store <4 x float> %1340, ptr %1342, align 4, !tbaa !13
  %1343 = getelementptr inbounds i8, ptr %8, i64 213088
  %1344 = getelementptr inbounds i8, ptr %8, i64 213104
  %wide.load469.3 = load <4 x float>, ptr %1343, align 4, !tbaa !13
  %wide.load470.3 = load <4 x float>, ptr %1344, align 4, !tbaa !13
  %1345 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load469.3, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1346 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load470.3, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1347 = getelementptr inbounds i8, ptr %11, i64 3424
  %1348 = getelementptr inbounds i8, ptr %11, i64 3440
  %wide.load475.3 = load <4 x float>, ptr %1347, align 4, !tbaa !13
  %wide.load476.3 = load <4 x float>, ptr %1348, align 4, !tbaa !13
  %1349 = getelementptr inbounds i8, ptr %12, i64 3424
  %1350 = getelementptr inbounds i8, ptr %12, i64 3440
  %wide.load477.3 = load <4 x float>, ptr %1349, align 4, !tbaa !13
  %wide.load478.3 = load <4 x float>, ptr %1350, align 4, !tbaa !13
  %1351 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1345, <4 x float> %wide.load475.3, <4 x float> %wide.load477.3)
  %1352 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1346, <4 x float> %wide.load476.3, <4 x float> %wide.load478.3)
  %1353 = getelementptr inbounds i8, ptr %13, i64 213088
  %1354 = getelementptr inbounds i8, ptr %13, i64 213104
  store <4 x float> %1351, ptr %1353, align 4, !tbaa !13
  store <4 x float> %1352, ptr %1354, align 4, !tbaa !13
  %1355 = getelementptr inbounds i8, ptr %8, i64 213120
  %1356 = getelementptr inbounds i8, ptr %8, i64 213136
  %wide.load469.4 = load <4 x float>, ptr %1355, align 4, !tbaa !13
  %wide.load470.4 = load <4 x float>, ptr %1356, align 4, !tbaa !13
  %1357 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load469.4, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1358 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load470.4, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1359 = getelementptr inbounds i8, ptr %11, i64 3456
  %1360 = getelementptr inbounds i8, ptr %11, i64 3472
  %wide.load475.4 = load <4 x float>, ptr %1359, align 4, !tbaa !13
  %wide.load476.4 = load <4 x float>, ptr %1360, align 4, !tbaa !13
  %1361 = getelementptr inbounds i8, ptr %12, i64 3456
  %1362 = getelementptr inbounds i8, ptr %12, i64 3472
  %wide.load477.4 = load <4 x float>, ptr %1361, align 4, !tbaa !13
  %wide.load478.4 = load <4 x float>, ptr %1362, align 4, !tbaa !13
  %1363 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1357, <4 x float> %wide.load475.4, <4 x float> %wide.load477.4)
  %1364 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1358, <4 x float> %wide.load476.4, <4 x float> %wide.load478.4)
  %1365 = getelementptr inbounds i8, ptr %13, i64 213120
  %1366 = getelementptr inbounds i8, ptr %13, i64 213136
  store <4 x float> %1363, ptr %1365, align 4, !tbaa !13
  store <4 x float> %1364, ptr %1366, align 4, !tbaa !13
  %1367 = getelementptr inbounds i8, ptr %8, i64 213152
  %1368 = getelementptr inbounds i8, ptr %8, i64 213168
  %wide.load469.5 = load <4 x float>, ptr %1367, align 4, !tbaa !13
  %wide.load470.5 = load <4 x float>, ptr %1368, align 4, !tbaa !13
  %1369 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load469.5, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1370 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load470.5, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1371 = getelementptr inbounds i8, ptr %11, i64 3488
  %1372 = getelementptr inbounds i8, ptr %11, i64 3504
  %wide.load475.5 = load <4 x float>, ptr %1371, align 4, !tbaa !13
  %wide.load476.5 = load <4 x float>, ptr %1372, align 4, !tbaa !13
  %1373 = getelementptr inbounds i8, ptr %12, i64 3488
  %1374 = getelementptr inbounds i8, ptr %12, i64 3504
  %wide.load477.5 = load <4 x float>, ptr %1373, align 4, !tbaa !13
  %wide.load478.5 = load <4 x float>, ptr %1374, align 4, !tbaa !13
  %1375 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1369, <4 x float> %wide.load475.5, <4 x float> %wide.load477.5)
  %1376 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1370, <4 x float> %wide.load476.5, <4 x float> %wide.load478.5)
  %1377 = getelementptr inbounds i8, ptr %13, i64 213152
  %1378 = getelementptr inbounds i8, ptr %13, i64 213168
  store <4 x float> %1375, ptr %1377, align 4, !tbaa !13
  store <4 x float> %1376, ptr %1378, align 4, !tbaa !13
  %1379 = getelementptr inbounds i8, ptr %8, i64 213184
  %1380 = getelementptr inbounds i8, ptr %8, i64 213200
  %wide.load469.6 = load <4 x float>, ptr %1379, align 4, !tbaa !13
  %wide.load470.6 = load <4 x float>, ptr %1380, align 4, !tbaa !13
  %1381 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load469.6, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1382 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load470.6, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1383 = getelementptr inbounds i8, ptr %11, i64 3520
  %1384 = getelementptr inbounds i8, ptr %11, i64 3536
  %wide.load475.6 = load <4 x float>, ptr %1383, align 4, !tbaa !13
  %wide.load476.6 = load <4 x float>, ptr %1384, align 4, !tbaa !13
  %1385 = getelementptr inbounds i8, ptr %12, i64 3520
  %1386 = getelementptr inbounds i8, ptr %12, i64 3536
  %wide.load477.6 = load <4 x float>, ptr %1385, align 4, !tbaa !13
  %wide.load478.6 = load <4 x float>, ptr %1386, align 4, !tbaa !13
  %1387 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1381, <4 x float> %wide.load475.6, <4 x float> %wide.load477.6)
  %1388 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1382, <4 x float> %wide.load476.6, <4 x float> %wide.load478.6)
  %1389 = getelementptr inbounds i8, ptr %13, i64 213184
  %1390 = getelementptr inbounds i8, ptr %13, i64 213200
  store <4 x float> %1387, ptr %1389, align 4, !tbaa !13
  store <4 x float> %1388, ptr %1390, align 4, !tbaa !13
  %1391 = getelementptr inbounds i8, ptr %8, i64 213216
  %1392 = getelementptr inbounds i8, ptr %8, i64 213232
  %wide.load469.7 = load <4 x float>, ptr %1391, align 4, !tbaa !13
  %wide.load470.7 = load <4 x float>, ptr %1392, align 4, !tbaa !13
  %1393 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load469.7, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1394 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load470.7, <4 x float> %broadcast.splat472, <4 x float> %broadcast.splat474)
  %1395 = getelementptr inbounds i8, ptr %11, i64 3552
  %1396 = getelementptr inbounds i8, ptr %11, i64 3568
  %wide.load475.7 = load <4 x float>, ptr %1395, align 4, !tbaa !13
  %wide.load476.7 = load <4 x float>, ptr %1396, align 4, !tbaa !13
  %1397 = getelementptr inbounds i8, ptr %12, i64 3552
  %1398 = getelementptr inbounds i8, ptr %12, i64 3568
  %wide.load477.7 = load <4 x float>, ptr %1397, align 4, !tbaa !13
  %wide.load478.7 = load <4 x float>, ptr %1398, align 4, !tbaa !13
  %1399 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1393, <4 x float> %wide.load475.7, <4 x float> %wide.load477.7)
  %1400 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1394, <4 x float> %wide.load476.7, <4 x float> %wide.load478.7)
  %1401 = getelementptr inbounds i8, ptr %13, i64 213216
  %1402 = getelementptr inbounds i8, ptr %13, i64 213232
  store <4 x float> %1399, ptr %1401, align 4, !tbaa !13
  store <4 x float> %1400, ptr %1402, align 4, !tbaa !13
  %broadcast.splatinsert490 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat491 = shufflevector <4 x float> %broadcast.splatinsert490, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert488 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat489 = shufflevector <4 x float> %broadcast.splatinsert488, <4 x float> poison, <4 x i32> zeroinitializer
  %1403 = getelementptr inbounds i8, ptr %8, i64 229376
  %1404 = getelementptr inbounds i8, ptr %8, i64 229392
  %wide.load486 = load <4 x float>, ptr %1403, align 4, !tbaa !13
  %wide.load487 = load <4 x float>, ptr %1404, align 4, !tbaa !13
  %1405 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load486, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1406 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load487, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1407 = getelementptr inbounds i8, ptr %11, i64 3584
  %1408 = getelementptr inbounds i8, ptr %11, i64 3600
  %wide.load492 = load <4 x float>, ptr %1407, align 4, !tbaa !13
  %wide.load493 = load <4 x float>, ptr %1408, align 4, !tbaa !13
  %1409 = getelementptr inbounds i8, ptr %12, i64 3584
  %1410 = getelementptr inbounds i8, ptr %12, i64 3600
  %wide.load494 = load <4 x float>, ptr %1409, align 4, !tbaa !13
  %wide.load495 = load <4 x float>, ptr %1410, align 4, !tbaa !13
  %1411 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1405, <4 x float> %wide.load492, <4 x float> %wide.load494)
  %1412 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1406, <4 x float> %wide.load493, <4 x float> %wide.load495)
  %1413 = getelementptr inbounds i8, ptr %13, i64 229376
  %1414 = getelementptr inbounds i8, ptr %13, i64 229392
  store <4 x float> %1411, ptr %1413, align 4, !tbaa !13
  store <4 x float> %1412, ptr %1414, align 4, !tbaa !13
  %1415 = getelementptr inbounds i8, ptr %8, i64 229408
  %1416 = getelementptr inbounds i8, ptr %8, i64 229424
  %wide.load486.1 = load <4 x float>, ptr %1415, align 4, !tbaa !13
  %wide.load487.1 = load <4 x float>, ptr %1416, align 4, !tbaa !13
  %1417 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load486.1, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1418 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load487.1, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1419 = getelementptr inbounds i8, ptr %11, i64 3616
  %1420 = getelementptr inbounds i8, ptr %11, i64 3632
  %wide.load492.1 = load <4 x float>, ptr %1419, align 4, !tbaa !13
  %wide.load493.1 = load <4 x float>, ptr %1420, align 4, !tbaa !13
  %1421 = getelementptr inbounds i8, ptr %12, i64 3616
  %1422 = getelementptr inbounds i8, ptr %12, i64 3632
  %wide.load494.1 = load <4 x float>, ptr %1421, align 4, !tbaa !13
  %wide.load495.1 = load <4 x float>, ptr %1422, align 4, !tbaa !13
  %1423 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1417, <4 x float> %wide.load492.1, <4 x float> %wide.load494.1)
  %1424 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1418, <4 x float> %wide.load493.1, <4 x float> %wide.load495.1)
  %1425 = getelementptr inbounds i8, ptr %13, i64 229408
  %1426 = getelementptr inbounds i8, ptr %13, i64 229424
  store <4 x float> %1423, ptr %1425, align 4, !tbaa !13
  store <4 x float> %1424, ptr %1426, align 4, !tbaa !13
  %1427 = getelementptr inbounds i8, ptr %8, i64 229440
  %1428 = getelementptr inbounds i8, ptr %8, i64 229456
  %wide.load486.2 = load <4 x float>, ptr %1427, align 4, !tbaa !13
  %wide.load487.2 = load <4 x float>, ptr %1428, align 4, !tbaa !13
  %1429 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load486.2, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1430 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load487.2, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1431 = getelementptr inbounds i8, ptr %11, i64 3648
  %1432 = getelementptr inbounds i8, ptr %11, i64 3664
  %wide.load492.2 = load <4 x float>, ptr %1431, align 4, !tbaa !13
  %wide.load493.2 = load <4 x float>, ptr %1432, align 4, !tbaa !13
  %1433 = getelementptr inbounds i8, ptr %12, i64 3648
  %1434 = getelementptr inbounds i8, ptr %12, i64 3664
  %wide.load494.2 = load <4 x float>, ptr %1433, align 4, !tbaa !13
  %wide.load495.2 = load <4 x float>, ptr %1434, align 4, !tbaa !13
  %1435 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1429, <4 x float> %wide.load492.2, <4 x float> %wide.load494.2)
  %1436 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1430, <4 x float> %wide.load493.2, <4 x float> %wide.load495.2)
  %1437 = getelementptr inbounds i8, ptr %13, i64 229440
  %1438 = getelementptr inbounds i8, ptr %13, i64 229456
  store <4 x float> %1435, ptr %1437, align 4, !tbaa !13
  store <4 x float> %1436, ptr %1438, align 4, !tbaa !13
  %1439 = getelementptr inbounds i8, ptr %8, i64 229472
  %1440 = getelementptr inbounds i8, ptr %8, i64 229488
  %wide.load486.3 = load <4 x float>, ptr %1439, align 4, !tbaa !13
  %wide.load487.3 = load <4 x float>, ptr %1440, align 4, !tbaa !13
  %1441 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load486.3, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1442 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load487.3, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1443 = getelementptr inbounds i8, ptr %11, i64 3680
  %1444 = getelementptr inbounds i8, ptr %11, i64 3696
  %wide.load492.3 = load <4 x float>, ptr %1443, align 4, !tbaa !13
  %wide.load493.3 = load <4 x float>, ptr %1444, align 4, !tbaa !13
  %1445 = getelementptr inbounds i8, ptr %12, i64 3680
  %1446 = getelementptr inbounds i8, ptr %12, i64 3696
  %wide.load494.3 = load <4 x float>, ptr %1445, align 4, !tbaa !13
  %wide.load495.3 = load <4 x float>, ptr %1446, align 4, !tbaa !13
  %1447 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1441, <4 x float> %wide.load492.3, <4 x float> %wide.load494.3)
  %1448 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1442, <4 x float> %wide.load493.3, <4 x float> %wide.load495.3)
  %1449 = getelementptr inbounds i8, ptr %13, i64 229472
  %1450 = getelementptr inbounds i8, ptr %13, i64 229488
  store <4 x float> %1447, ptr %1449, align 4, !tbaa !13
  store <4 x float> %1448, ptr %1450, align 4, !tbaa !13
  %1451 = getelementptr inbounds i8, ptr %8, i64 229504
  %1452 = getelementptr inbounds i8, ptr %8, i64 229520
  %wide.load486.4 = load <4 x float>, ptr %1451, align 4, !tbaa !13
  %wide.load487.4 = load <4 x float>, ptr %1452, align 4, !tbaa !13
  %1453 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load486.4, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1454 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load487.4, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1455 = getelementptr inbounds i8, ptr %11, i64 3712
  %1456 = getelementptr inbounds i8, ptr %11, i64 3728
  %wide.load492.4 = load <4 x float>, ptr %1455, align 4, !tbaa !13
  %wide.load493.4 = load <4 x float>, ptr %1456, align 4, !tbaa !13
  %1457 = getelementptr inbounds i8, ptr %12, i64 3712
  %1458 = getelementptr inbounds i8, ptr %12, i64 3728
  %wide.load494.4 = load <4 x float>, ptr %1457, align 4, !tbaa !13
  %wide.load495.4 = load <4 x float>, ptr %1458, align 4, !tbaa !13
  %1459 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1453, <4 x float> %wide.load492.4, <4 x float> %wide.load494.4)
  %1460 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1454, <4 x float> %wide.load493.4, <4 x float> %wide.load495.4)
  %1461 = getelementptr inbounds i8, ptr %13, i64 229504
  %1462 = getelementptr inbounds i8, ptr %13, i64 229520
  store <4 x float> %1459, ptr %1461, align 4, !tbaa !13
  store <4 x float> %1460, ptr %1462, align 4, !tbaa !13
  %1463 = getelementptr inbounds i8, ptr %8, i64 229536
  %1464 = getelementptr inbounds i8, ptr %8, i64 229552
  %wide.load486.5 = load <4 x float>, ptr %1463, align 4, !tbaa !13
  %wide.load487.5 = load <4 x float>, ptr %1464, align 4, !tbaa !13
  %1465 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load486.5, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1466 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load487.5, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1467 = getelementptr inbounds i8, ptr %11, i64 3744
  %1468 = getelementptr inbounds i8, ptr %11, i64 3760
  %wide.load492.5 = load <4 x float>, ptr %1467, align 4, !tbaa !13
  %wide.load493.5 = load <4 x float>, ptr %1468, align 4, !tbaa !13
  %1469 = getelementptr inbounds i8, ptr %12, i64 3744
  %1470 = getelementptr inbounds i8, ptr %12, i64 3760
  %wide.load494.5 = load <4 x float>, ptr %1469, align 4, !tbaa !13
  %wide.load495.5 = load <4 x float>, ptr %1470, align 4, !tbaa !13
  %1471 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1465, <4 x float> %wide.load492.5, <4 x float> %wide.load494.5)
  %1472 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1466, <4 x float> %wide.load493.5, <4 x float> %wide.load495.5)
  %1473 = getelementptr inbounds i8, ptr %13, i64 229536
  %1474 = getelementptr inbounds i8, ptr %13, i64 229552
  store <4 x float> %1471, ptr %1473, align 4, !tbaa !13
  store <4 x float> %1472, ptr %1474, align 4, !tbaa !13
  %1475 = getelementptr inbounds i8, ptr %8, i64 229568
  %1476 = getelementptr inbounds i8, ptr %8, i64 229584
  %wide.load486.6 = load <4 x float>, ptr %1475, align 4, !tbaa !13
  %wide.load487.6 = load <4 x float>, ptr %1476, align 4, !tbaa !13
  %1477 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load486.6, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1478 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load487.6, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1479 = getelementptr inbounds i8, ptr %11, i64 3776
  %1480 = getelementptr inbounds i8, ptr %11, i64 3792
  %wide.load492.6 = load <4 x float>, ptr %1479, align 4, !tbaa !13
  %wide.load493.6 = load <4 x float>, ptr %1480, align 4, !tbaa !13
  %1481 = getelementptr inbounds i8, ptr %12, i64 3776
  %1482 = getelementptr inbounds i8, ptr %12, i64 3792
  %wide.load494.6 = load <4 x float>, ptr %1481, align 4, !tbaa !13
  %wide.load495.6 = load <4 x float>, ptr %1482, align 4, !tbaa !13
  %1483 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1477, <4 x float> %wide.load492.6, <4 x float> %wide.load494.6)
  %1484 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1478, <4 x float> %wide.load493.6, <4 x float> %wide.load495.6)
  %1485 = getelementptr inbounds i8, ptr %13, i64 229568
  %1486 = getelementptr inbounds i8, ptr %13, i64 229584
  store <4 x float> %1483, ptr %1485, align 4, !tbaa !13
  store <4 x float> %1484, ptr %1486, align 4, !tbaa !13
  %1487 = getelementptr inbounds i8, ptr %8, i64 229600
  %1488 = getelementptr inbounds i8, ptr %8, i64 229616
  %wide.load486.7 = load <4 x float>, ptr %1487, align 4, !tbaa !13
  %wide.load487.7 = load <4 x float>, ptr %1488, align 4, !tbaa !13
  %1489 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load486.7, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1490 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load487.7, <4 x float> %broadcast.splat489, <4 x float> %broadcast.splat491)
  %1491 = getelementptr inbounds i8, ptr %11, i64 3808
  %1492 = getelementptr inbounds i8, ptr %11, i64 3824
  %wide.load492.7 = load <4 x float>, ptr %1491, align 4, !tbaa !13
  %wide.load493.7 = load <4 x float>, ptr %1492, align 4, !tbaa !13
  %1493 = getelementptr inbounds i8, ptr %12, i64 3808
  %1494 = getelementptr inbounds i8, ptr %12, i64 3824
  %wide.load494.7 = load <4 x float>, ptr %1493, align 4, !tbaa !13
  %wide.load495.7 = load <4 x float>, ptr %1494, align 4, !tbaa !13
  %1495 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1489, <4 x float> %wide.load492.7, <4 x float> %wide.load494.7)
  %1496 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1490, <4 x float> %wide.load493.7, <4 x float> %wide.load495.7)
  %1497 = getelementptr inbounds i8, ptr %13, i64 229600
  %1498 = getelementptr inbounds i8, ptr %13, i64 229616
  store <4 x float> %1495, ptr %1497, align 4, !tbaa !13
  store <4 x float> %1496, ptr %1498, align 4, !tbaa !13
  %broadcast.splatinsert507 = insertelement <4 x float> poison, float %62, i64 0
  %broadcast.splat508 = shufflevector <4 x float> %broadcast.splatinsert507, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert505 = insertelement <4 x float> poison, float %61, i64 0
  %broadcast.splat506 = shufflevector <4 x float> %broadcast.splatinsert505, <4 x float> poison, <4 x i32> zeroinitializer
  %1499 = getelementptr inbounds i8, ptr %8, i64 245760
  %1500 = getelementptr inbounds i8, ptr %8, i64 245776
  %wide.load503 = load <4 x float>, ptr %1499, align 4, !tbaa !13
  %wide.load504 = load <4 x float>, ptr %1500, align 4, !tbaa !13
  %1501 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load503, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1502 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load504, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1503 = getelementptr inbounds i8, ptr %11, i64 3840
  %1504 = getelementptr inbounds i8, ptr %11, i64 3856
  %wide.load509 = load <4 x float>, ptr %1503, align 4, !tbaa !13
  %wide.load510 = load <4 x float>, ptr %1504, align 4, !tbaa !13
  %1505 = getelementptr inbounds i8, ptr %12, i64 3840
  %1506 = getelementptr inbounds i8, ptr %12, i64 3856
  %wide.load511 = load <4 x float>, ptr %1505, align 4, !tbaa !13
  %wide.load512 = load <4 x float>, ptr %1506, align 4, !tbaa !13
  %1507 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1501, <4 x float> %wide.load509, <4 x float> %wide.load511)
  %1508 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1502, <4 x float> %wide.load510, <4 x float> %wide.load512)
  %1509 = getelementptr inbounds i8, ptr %13, i64 245760
  %1510 = getelementptr inbounds i8, ptr %13, i64 245776
  store <4 x float> %1507, ptr %1509, align 4, !tbaa !13
  store <4 x float> %1508, ptr %1510, align 4, !tbaa !13
  %1511 = getelementptr inbounds i8, ptr %8, i64 245792
  %1512 = getelementptr inbounds i8, ptr %8, i64 245808
  %wide.load503.1 = load <4 x float>, ptr %1511, align 4, !tbaa !13
  %wide.load504.1 = load <4 x float>, ptr %1512, align 4, !tbaa !13
  %1513 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load503.1, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1514 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load504.1, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1515 = getelementptr inbounds i8, ptr %11, i64 3872
  %1516 = getelementptr inbounds i8, ptr %11, i64 3888
  %wide.load509.1 = load <4 x float>, ptr %1515, align 4, !tbaa !13
  %wide.load510.1 = load <4 x float>, ptr %1516, align 4, !tbaa !13
  %1517 = getelementptr inbounds i8, ptr %12, i64 3872
  %1518 = getelementptr inbounds i8, ptr %12, i64 3888
  %wide.load511.1 = load <4 x float>, ptr %1517, align 4, !tbaa !13
  %wide.load512.1 = load <4 x float>, ptr %1518, align 4, !tbaa !13
  %1519 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1513, <4 x float> %wide.load509.1, <4 x float> %wide.load511.1)
  %1520 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1514, <4 x float> %wide.load510.1, <4 x float> %wide.load512.1)
  %1521 = getelementptr inbounds i8, ptr %13, i64 245792
  %1522 = getelementptr inbounds i8, ptr %13, i64 245808
  store <4 x float> %1519, ptr %1521, align 4, !tbaa !13
  store <4 x float> %1520, ptr %1522, align 4, !tbaa !13
  %1523 = getelementptr inbounds i8, ptr %8, i64 245824
  %1524 = getelementptr inbounds i8, ptr %8, i64 245840
  %wide.load503.2 = load <4 x float>, ptr %1523, align 4, !tbaa !13
  %wide.load504.2 = load <4 x float>, ptr %1524, align 4, !tbaa !13
  %1525 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load503.2, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1526 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load504.2, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1527 = getelementptr inbounds i8, ptr %11, i64 3904
  %1528 = getelementptr inbounds i8, ptr %11, i64 3920
  %wide.load509.2 = load <4 x float>, ptr %1527, align 4, !tbaa !13
  %wide.load510.2 = load <4 x float>, ptr %1528, align 4, !tbaa !13
  %1529 = getelementptr inbounds i8, ptr %12, i64 3904
  %1530 = getelementptr inbounds i8, ptr %12, i64 3920
  %wide.load511.2 = load <4 x float>, ptr %1529, align 4, !tbaa !13
  %wide.load512.2 = load <4 x float>, ptr %1530, align 4, !tbaa !13
  %1531 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1525, <4 x float> %wide.load509.2, <4 x float> %wide.load511.2)
  %1532 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1526, <4 x float> %wide.load510.2, <4 x float> %wide.load512.2)
  %1533 = getelementptr inbounds i8, ptr %13, i64 245824
  %1534 = getelementptr inbounds i8, ptr %13, i64 245840
  store <4 x float> %1531, ptr %1533, align 4, !tbaa !13
  store <4 x float> %1532, ptr %1534, align 4, !tbaa !13
  %1535 = getelementptr inbounds i8, ptr %8, i64 245856
  %1536 = getelementptr inbounds i8, ptr %8, i64 245872
  %wide.load503.3 = load <4 x float>, ptr %1535, align 4, !tbaa !13
  %wide.load504.3 = load <4 x float>, ptr %1536, align 4, !tbaa !13
  %1537 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load503.3, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1538 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load504.3, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1539 = getelementptr inbounds i8, ptr %11, i64 3936
  %1540 = getelementptr inbounds i8, ptr %11, i64 3952
  %wide.load509.3 = load <4 x float>, ptr %1539, align 4, !tbaa !13
  %wide.load510.3 = load <4 x float>, ptr %1540, align 4, !tbaa !13
  %1541 = getelementptr inbounds i8, ptr %12, i64 3936
  %1542 = getelementptr inbounds i8, ptr %12, i64 3952
  %wide.load511.3 = load <4 x float>, ptr %1541, align 4, !tbaa !13
  %wide.load512.3 = load <4 x float>, ptr %1542, align 4, !tbaa !13
  %1543 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1537, <4 x float> %wide.load509.3, <4 x float> %wide.load511.3)
  %1544 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1538, <4 x float> %wide.load510.3, <4 x float> %wide.load512.3)
  %1545 = getelementptr inbounds i8, ptr %13, i64 245856
  %1546 = getelementptr inbounds i8, ptr %13, i64 245872
  store <4 x float> %1543, ptr %1545, align 4, !tbaa !13
  store <4 x float> %1544, ptr %1546, align 4, !tbaa !13
  %1547 = getelementptr inbounds i8, ptr %8, i64 245888
  %1548 = getelementptr inbounds i8, ptr %8, i64 245904
  %wide.load503.4 = load <4 x float>, ptr %1547, align 4, !tbaa !13
  %wide.load504.4 = load <4 x float>, ptr %1548, align 4, !tbaa !13
  %1549 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load503.4, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1550 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load504.4, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1551 = getelementptr inbounds i8, ptr %11, i64 3968
  %1552 = getelementptr inbounds i8, ptr %11, i64 3984
  %wide.load509.4 = load <4 x float>, ptr %1551, align 4, !tbaa !13
  %wide.load510.4 = load <4 x float>, ptr %1552, align 4, !tbaa !13
  %1553 = getelementptr inbounds i8, ptr %12, i64 3968
  %1554 = getelementptr inbounds i8, ptr %12, i64 3984
  %wide.load511.4 = load <4 x float>, ptr %1553, align 4, !tbaa !13
  %wide.load512.4 = load <4 x float>, ptr %1554, align 4, !tbaa !13
  %1555 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1549, <4 x float> %wide.load509.4, <4 x float> %wide.load511.4)
  %1556 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1550, <4 x float> %wide.load510.4, <4 x float> %wide.load512.4)
  %1557 = getelementptr inbounds i8, ptr %13, i64 245888
  %1558 = getelementptr inbounds i8, ptr %13, i64 245904
  store <4 x float> %1555, ptr %1557, align 4, !tbaa !13
  store <4 x float> %1556, ptr %1558, align 4, !tbaa !13
  %1559 = getelementptr inbounds i8, ptr %8, i64 245920
  %1560 = getelementptr inbounds i8, ptr %8, i64 245936
  %wide.load503.5 = load <4 x float>, ptr %1559, align 4, !tbaa !13
  %wide.load504.5 = load <4 x float>, ptr %1560, align 4, !tbaa !13
  %1561 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load503.5, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1562 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load504.5, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1563 = getelementptr inbounds i8, ptr %11, i64 4000
  %1564 = getelementptr inbounds i8, ptr %11, i64 4016
  %wide.load509.5 = load <4 x float>, ptr %1563, align 4, !tbaa !13
  %wide.load510.5 = load <4 x float>, ptr %1564, align 4, !tbaa !13
  %1565 = getelementptr inbounds i8, ptr %12, i64 4000
  %1566 = getelementptr inbounds i8, ptr %12, i64 4016
  %wide.load511.5 = load <4 x float>, ptr %1565, align 4, !tbaa !13
  %wide.load512.5 = load <4 x float>, ptr %1566, align 4, !tbaa !13
  %1567 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1561, <4 x float> %wide.load509.5, <4 x float> %wide.load511.5)
  %1568 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1562, <4 x float> %wide.load510.5, <4 x float> %wide.load512.5)
  %1569 = getelementptr inbounds i8, ptr %13, i64 245920
  %1570 = getelementptr inbounds i8, ptr %13, i64 245936
  store <4 x float> %1567, ptr %1569, align 4, !tbaa !13
  store <4 x float> %1568, ptr %1570, align 4, !tbaa !13
  %1571 = getelementptr inbounds i8, ptr %8, i64 245952
  %1572 = getelementptr inbounds i8, ptr %8, i64 245968
  %wide.load503.6 = load <4 x float>, ptr %1571, align 4, !tbaa !13
  %wide.load504.6 = load <4 x float>, ptr %1572, align 4, !tbaa !13
  %1573 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load503.6, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1574 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load504.6, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1575 = getelementptr inbounds i8, ptr %11, i64 4032
  %1576 = getelementptr inbounds i8, ptr %11, i64 4048
  %wide.load509.6 = load <4 x float>, ptr %1575, align 4, !tbaa !13
  %wide.load510.6 = load <4 x float>, ptr %1576, align 4, !tbaa !13
  %1577 = getelementptr inbounds i8, ptr %12, i64 4032
  %1578 = getelementptr inbounds i8, ptr %12, i64 4048
  %wide.load511.6 = load <4 x float>, ptr %1577, align 4, !tbaa !13
  %wide.load512.6 = load <4 x float>, ptr %1578, align 4, !tbaa !13
  %1579 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1573, <4 x float> %wide.load509.6, <4 x float> %wide.load511.6)
  %1580 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1574, <4 x float> %wide.load510.6, <4 x float> %wide.load512.6)
  %1581 = getelementptr inbounds i8, ptr %13, i64 245952
  %1582 = getelementptr inbounds i8, ptr %13, i64 245968
  store <4 x float> %1579, ptr %1581, align 4, !tbaa !13
  store <4 x float> %1580, ptr %1582, align 4, !tbaa !13
  %1583 = getelementptr inbounds i8, ptr %8, i64 245984
  %1584 = getelementptr inbounds i8, ptr %8, i64 246000
  %wide.load503.7 = load <4 x float>, ptr %1583, align 4, !tbaa !13
  %wide.load504.7 = load <4 x float>, ptr %1584, align 4, !tbaa !13
  %1585 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load503.7, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1586 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load504.7, <4 x float> %broadcast.splat506, <4 x float> %broadcast.splat508)
  %1587 = getelementptr inbounds i8, ptr %11, i64 4064
  %1588 = getelementptr inbounds i8, ptr %11, i64 4080
  %wide.load509.7 = load <4 x float>, ptr %1587, align 4, !tbaa !13
  %wide.load510.7 = load <4 x float>, ptr %1588, align 4, !tbaa !13
  %1589 = getelementptr inbounds i8, ptr %12, i64 4064
  %1590 = getelementptr inbounds i8, ptr %12, i64 4080
  %wide.load511.7 = load <4 x float>, ptr %1589, align 4, !tbaa !13
  %wide.load512.7 = load <4 x float>, ptr %1590, align 4, !tbaa !13
  %1591 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1585, <4 x float> %wide.load509.7, <4 x float> %wide.load511.7)
  %1592 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1586, <4 x float> %wide.load510.7, <4 x float> %wide.load512.7)
  %1593 = getelementptr inbounds i8, ptr %13, i64 245984
  %1594 = getelementptr inbounds i8, ptr %13, i64 246000
  store <4 x float> %1591, ptr %1593, align 4, !tbaa !13
  store <4 x float> %1592, ptr %1594, align 4, !tbaa !13
  call void @libxsmm_rne_convert_fp32_bf8(ptr noundef nonnull %13, ptr noundef %20, i64 noundef 65536) #6
  br label %vector.body518

vector.body518:                                   ; preds = %vector.body518, %.preheader232
  %index519 = phi i64 [ 0, %.preheader232 ], [ %index.next525.1, %vector.body518 ]
  %vec.phi = phi <4 x i1> [ zeroinitializer, %.preheader232 ], [ %1609, %vector.body518 ]
  %vec.phi520 = phi <4 x i1> [ zeroinitializer, %.preheader232 ], [ %1610, %vector.body518 ]
  %1595 = getelementptr inbounds i8, ptr %20, i64 %index519
  %1596 = getelementptr inbounds i8, ptr %1595, i64 4
  %wide.load521 = load <4 x i8>, ptr %1595, align 1, !tbaa !15
  %wide.load522 = load <4 x i8>, ptr %1596, align 1, !tbaa !15
  %1597 = getelementptr inbounds i8, ptr %21, i64 %index519
  %1598 = getelementptr inbounds i8, ptr %1597, i64 4
  %wide.load523 = load <4 x i8>, ptr %1597, align 1, !tbaa !15
  %wide.load524 = load <4 x i8>, ptr %1598, align 1, !tbaa !15
  %1599 = icmp ne <4 x i8> %wide.load521, %wide.load523
  %1600 = icmp ne <4 x i8> %wide.load522, %wide.load524
  %1601 = or <4 x i1> %vec.phi, %1599
  %1602 = or <4 x i1> %vec.phi520, %1600
  %index.next525 = or disjoint i64 %index519, 8
  %1603 = getelementptr inbounds i8, ptr %20, i64 %index.next525
  %1604 = getelementptr inbounds i8, ptr %1603, i64 4
  %wide.load521.1 = load <4 x i8>, ptr %1603, align 1, !tbaa !15
  %wide.load522.1 = load <4 x i8>, ptr %1604, align 1, !tbaa !15
  %1605 = getelementptr inbounds i8, ptr %21, i64 %index.next525
  %1606 = getelementptr inbounds i8, ptr %1605, i64 4
  %wide.load523.1 = load <4 x i8>, ptr %1605, align 1, !tbaa !15
  %wide.load524.1 = load <4 x i8>, ptr %1606, align 1, !tbaa !15
  %1607 = icmp ne <4 x i8> %wide.load521.1, %wide.load523.1
  %1608 = icmp ne <4 x i8> %wide.load522.1, %wide.load524.1
  %1609 = or <4 x i1> %1601, %1607
  %1610 = or <4 x i1> %1602, %1608
  %index.next525.1 = add nuw nsw i64 %index519, 16
  %1611 = icmp eq i64 %index.next525.1, 4096
  br i1 %1611, label %middle.block514, label %vector.body518, !llvm.loop !16

middle.block514:                                  ; preds = %vector.body518
  %bin.rdx = or <4 x i1> %1610, %1609
  %bin.rdx.fr = freeze <4 x i1> %bin.rdx
  br label %vector.body530

vector.body530:                                   ; preds = %vector.body530, %middle.block514
  %index531 = phi i64 [ 0, %middle.block514 ], [ %index.next538.1, %vector.body530 ]
  %vec.phi532 = phi <4 x i1> [ zeroinitializer, %middle.block514 ], [ %1628, %vector.body530 ]
  %vec.phi533 = phi <4 x i1> [ zeroinitializer, %middle.block514 ], [ %1629, %vector.body530 ]
  %1612 = add nuw nsw i64 %index531, 4096
  %1613 = getelementptr inbounds i8, ptr %20, i64 %1612
  %1614 = getelementptr inbounds i8, ptr %1613, i64 4
  %wide.load534 = load <4 x i8>, ptr %1613, align 1, !tbaa !15
  %wide.load535 = load <4 x i8>, ptr %1614, align 1, !tbaa !15
  %1615 = getelementptr inbounds i8, ptr %21, i64 %1612
  %1616 = getelementptr inbounds i8, ptr %1615, i64 4
  %wide.load536 = load <4 x i8>, ptr %1615, align 1, !tbaa !15
  %wide.load537 = load <4 x i8>, ptr %1616, align 1, !tbaa !15
  %1617 = icmp ne <4 x i8> %wide.load534, %wide.load536
  %1618 = icmp ne <4 x i8> %wide.load535, %wide.load537
  %1619 = or <4 x i1> %vec.phi532, %1617
  %1620 = or <4 x i1> %vec.phi533, %1618
  %1621 = add nuw nsw i64 %index531, 4104
  %1622 = getelementptr inbounds i8, ptr %20, i64 %1621
  %1623 = getelementptr inbounds i8, ptr %1622, i64 4
  %wide.load534.1 = load <4 x i8>, ptr %1622, align 1, !tbaa !15
  %wide.load535.1 = load <4 x i8>, ptr %1623, align 1, !tbaa !15
  %1624 = getelementptr inbounds i8, ptr %21, i64 %1621
  %1625 = getelementptr inbounds i8, ptr %1624, i64 4
  %wide.load536.1 = load <4 x i8>, ptr %1624, align 1, !tbaa !15
  %wide.load537.1 = load <4 x i8>, ptr %1625, align 1, !tbaa !15
  %1626 = icmp ne <4 x i8> %wide.load534.1, %wide.load536.1
  %1627 = icmp ne <4 x i8> %wide.load535.1, %wide.load537.1
  %1628 = or <4 x i1> %1619, %1626
  %1629 = or <4 x i1> %1620, %1627
  %index.next538.1 = add nuw nsw i64 %index531, 16
  %1630 = icmp eq i64 %index.next538.1, 4096
  br i1 %1630, label %middle.block526, label %vector.body530, !llvm.loop !20

middle.block526:                                  ; preds = %vector.body530
  %bin.rdx539 = or <4 x i1> %1629, %1628
  %bin.rdx539.fr = freeze <4 x i1> %bin.rdx539
  %1631 = or <4 x i1> %bin.rdx539.fr, %bin.rdx.fr
  br label %vector.body546

vector.body546:                                   ; preds = %vector.body546, %middle.block526
  %index547 = phi i64 [ 0, %middle.block526 ], [ %index.next554.1, %vector.body546 ]
  %vec.phi548 = phi <4 x i1> [ zeroinitializer, %middle.block526 ], [ %1648, %vector.body546 ]
  %vec.phi549 = phi <4 x i1> [ zeroinitializer, %middle.block526 ], [ %1649, %vector.body546 ]
  %1632 = add nuw nsw i64 %index547, 8192
  %1633 = getelementptr inbounds i8, ptr %20, i64 %1632
  %1634 = getelementptr inbounds i8, ptr %1633, i64 4
  %wide.load550 = load <4 x i8>, ptr %1633, align 1, !tbaa !15
  %wide.load551 = load <4 x i8>, ptr %1634, align 1, !tbaa !15
  %1635 = getelementptr inbounds i8, ptr %21, i64 %1632
  %1636 = getelementptr inbounds i8, ptr %1635, i64 4
  %wide.load552 = load <4 x i8>, ptr %1635, align 1, !tbaa !15
  %wide.load553 = load <4 x i8>, ptr %1636, align 1, !tbaa !15
  %1637 = icmp ne <4 x i8> %wide.load550, %wide.load552
  %1638 = icmp ne <4 x i8> %wide.load551, %wide.load553
  %1639 = or <4 x i1> %vec.phi548, %1637
  %1640 = or <4 x i1> %vec.phi549, %1638
  %1641 = add nuw nsw i64 %index547, 8200
  %1642 = getelementptr inbounds i8, ptr %20, i64 %1641
  %1643 = getelementptr inbounds i8, ptr %1642, i64 4
  %wide.load550.1 = load <4 x i8>, ptr %1642, align 1, !tbaa !15
  %wide.load551.1 = load <4 x i8>, ptr %1643, align 1, !tbaa !15
  %1644 = getelementptr inbounds i8, ptr %21, i64 %1641
  %1645 = getelementptr inbounds i8, ptr %1644, i64 4
  %wide.load552.1 = load <4 x i8>, ptr %1644, align 1, !tbaa !15
  %wide.load553.1 = load <4 x i8>, ptr %1645, align 1, !tbaa !15
  %1646 = icmp ne <4 x i8> %wide.load550.1, %wide.load552.1
  %1647 = icmp ne <4 x i8> %wide.load551.1, %wide.load553.1
  %1648 = or <4 x i1> %1639, %1646
  %1649 = or <4 x i1> %1640, %1647
  %index.next554.1 = add nuw nsw i64 %index547, 16
  %1650 = icmp eq i64 %index.next554.1, 4096
  br i1 %1650, label %middle.block542, label %vector.body546, !llvm.loop !21

middle.block542:                                  ; preds = %vector.body546
  %bin.rdx555 = or <4 x i1> %1649, %1648
  %bin.rdx555.fr = freeze <4 x i1> %bin.rdx555
  %1651 = or <4 x i1> %bin.rdx555.fr, %1631
  br label %vector.body562

vector.body562:                                   ; preds = %vector.body562, %middle.block542
  %index563 = phi i64 [ 0, %middle.block542 ], [ %index.next570.1, %vector.body562 ]
  %vec.phi564 = phi <4 x i1> [ zeroinitializer, %middle.block542 ], [ %1668, %vector.body562 ]
  %vec.phi565 = phi <4 x i1> [ zeroinitializer, %middle.block542 ], [ %1669, %vector.body562 ]
  %1652 = add nuw nsw i64 %index563, 12288
  %1653 = getelementptr inbounds i8, ptr %20, i64 %1652
  %1654 = getelementptr inbounds i8, ptr %1653, i64 4
  %wide.load566 = load <4 x i8>, ptr %1653, align 1, !tbaa !15
  %wide.load567 = load <4 x i8>, ptr %1654, align 1, !tbaa !15
  %1655 = getelementptr inbounds i8, ptr %21, i64 %1652
  %1656 = getelementptr inbounds i8, ptr %1655, i64 4
  %wide.load568 = load <4 x i8>, ptr %1655, align 1, !tbaa !15
  %wide.load569 = load <4 x i8>, ptr %1656, align 1, !tbaa !15
  %1657 = icmp ne <4 x i8> %wide.load566, %wide.load568
  %1658 = icmp ne <4 x i8> %wide.load567, %wide.load569
  %1659 = or <4 x i1> %vec.phi564, %1657
  %1660 = or <4 x i1> %vec.phi565, %1658
  %1661 = add nuw nsw i64 %index563, 12296
  %1662 = getelementptr inbounds i8, ptr %20, i64 %1661
  %1663 = getelementptr inbounds i8, ptr %1662, i64 4
  %wide.load566.1 = load <4 x i8>, ptr %1662, align 1, !tbaa !15
  %wide.load567.1 = load <4 x i8>, ptr %1663, align 1, !tbaa !15
  %1664 = getelementptr inbounds i8, ptr %21, i64 %1661
  %1665 = getelementptr inbounds i8, ptr %1664, i64 4
  %wide.load568.1 = load <4 x i8>, ptr %1664, align 1, !tbaa !15
  %wide.load569.1 = load <4 x i8>, ptr %1665, align 1, !tbaa !15
  %1666 = icmp ne <4 x i8> %wide.load566.1, %wide.load568.1
  %1667 = icmp ne <4 x i8> %wide.load567.1, %wide.load569.1
  %1668 = or <4 x i1> %1659, %1666
  %1669 = or <4 x i1> %1660, %1667
  %index.next570.1 = add nuw nsw i64 %index563, 16
  %1670 = icmp eq i64 %index.next570.1, 4096
  br i1 %1670, label %middle.block558, label %vector.body562, !llvm.loop !22

middle.block558:                                  ; preds = %vector.body562
  %bin.rdx571 = or <4 x i1> %1669, %1668
  %bin.rdx571.fr = freeze <4 x i1> %bin.rdx571
  %1671 = or <4 x i1> %bin.rdx571.fr, %1651
  br label %vector.body578

vector.body578:                                   ; preds = %vector.body578, %middle.block558
  %index579 = phi i64 [ 0, %middle.block558 ], [ %index.next586.1, %vector.body578 ]
  %vec.phi580 = phi <4 x i1> [ zeroinitializer, %middle.block558 ], [ %1688, %vector.body578 ]
  %vec.phi581 = phi <4 x i1> [ zeroinitializer, %middle.block558 ], [ %1689, %vector.body578 ]
  %1672 = add nuw nsw i64 %index579, 16384
  %1673 = getelementptr inbounds i8, ptr %20, i64 %1672
  %1674 = getelementptr inbounds i8, ptr %1673, i64 4
  %wide.load582 = load <4 x i8>, ptr %1673, align 1, !tbaa !15
  %wide.load583 = load <4 x i8>, ptr %1674, align 1, !tbaa !15
  %1675 = getelementptr inbounds i8, ptr %21, i64 %1672
  %1676 = getelementptr inbounds i8, ptr %1675, i64 4
  %wide.load584 = load <4 x i8>, ptr %1675, align 1, !tbaa !15
  %wide.load585 = load <4 x i8>, ptr %1676, align 1, !tbaa !15
  %1677 = icmp ne <4 x i8> %wide.load582, %wide.load584
  %1678 = icmp ne <4 x i8> %wide.load583, %wide.load585
  %1679 = or <4 x i1> %vec.phi580, %1677
  %1680 = or <4 x i1> %vec.phi581, %1678
  %1681 = add nuw nsw i64 %index579, 16392
  %1682 = getelementptr inbounds i8, ptr %20, i64 %1681
  %1683 = getelementptr inbounds i8, ptr %1682, i64 4
  %wide.load582.1 = load <4 x i8>, ptr %1682, align 1, !tbaa !15
  %wide.load583.1 = load <4 x i8>, ptr %1683, align 1, !tbaa !15
  %1684 = getelementptr inbounds i8, ptr %21, i64 %1681
  %1685 = getelementptr inbounds i8, ptr %1684, i64 4
  %wide.load584.1 = load <4 x i8>, ptr %1684, align 1, !tbaa !15
  %wide.load585.1 = load <4 x i8>, ptr %1685, align 1, !tbaa !15
  %1686 = icmp ne <4 x i8> %wide.load582.1, %wide.load584.1
  %1687 = icmp ne <4 x i8> %wide.load583.1, %wide.load585.1
  %1688 = or <4 x i1> %1679, %1686
  %1689 = or <4 x i1> %1680, %1687
  %index.next586.1 = add nuw nsw i64 %index579, 16
  %1690 = icmp eq i64 %index.next586.1, 4096
  br i1 %1690, label %middle.block574, label %vector.body578, !llvm.loop !23

middle.block574:                                  ; preds = %vector.body578
  %bin.rdx587 = or <4 x i1> %1689, %1688
  %bin.rdx587.fr = freeze <4 x i1> %bin.rdx587
  %1691 = or <4 x i1> %bin.rdx587.fr, %1671
  br label %vector.body594

vector.body594:                                   ; preds = %vector.body594, %middle.block574
  %index595 = phi i64 [ 0, %middle.block574 ], [ %index.next602.1, %vector.body594 ]
  %vec.phi596 = phi <4 x i1> [ zeroinitializer, %middle.block574 ], [ %1708, %vector.body594 ]
  %vec.phi597 = phi <4 x i1> [ zeroinitializer, %middle.block574 ], [ %1709, %vector.body594 ]
  %1692 = add nuw nsw i64 %index595, 20480
  %1693 = getelementptr inbounds i8, ptr %20, i64 %1692
  %1694 = getelementptr inbounds i8, ptr %1693, i64 4
  %wide.load598 = load <4 x i8>, ptr %1693, align 1, !tbaa !15
  %wide.load599 = load <4 x i8>, ptr %1694, align 1, !tbaa !15
  %1695 = getelementptr inbounds i8, ptr %21, i64 %1692
  %1696 = getelementptr inbounds i8, ptr %1695, i64 4
  %wide.load600 = load <4 x i8>, ptr %1695, align 1, !tbaa !15
  %wide.load601 = load <4 x i8>, ptr %1696, align 1, !tbaa !15
  %1697 = icmp ne <4 x i8> %wide.load598, %wide.load600
  %1698 = icmp ne <4 x i8> %wide.load599, %wide.load601
  %1699 = or <4 x i1> %vec.phi596, %1697
  %1700 = or <4 x i1> %vec.phi597, %1698
  %1701 = add nuw nsw i64 %index595, 20488
  %1702 = getelementptr inbounds i8, ptr %20, i64 %1701
  %1703 = getelementptr inbounds i8, ptr %1702, i64 4
  %wide.load598.1 = load <4 x i8>, ptr %1702, align 1, !tbaa !15
  %wide.load599.1 = load <4 x i8>, ptr %1703, align 1, !tbaa !15
  %1704 = getelementptr inbounds i8, ptr %21, i64 %1701
  %1705 = getelementptr inbounds i8, ptr %1704, i64 4
  %wide.load600.1 = load <4 x i8>, ptr %1704, align 1, !tbaa !15
  %wide.load601.1 = load <4 x i8>, ptr %1705, align 1, !tbaa !15
  %1706 = icmp ne <4 x i8> %wide.load598.1, %wide.load600.1
  %1707 = icmp ne <4 x i8> %wide.load599.1, %wide.load601.1
  %1708 = or <4 x i1> %1699, %1706
  %1709 = or <4 x i1> %1700, %1707
  %index.next602.1 = add nuw nsw i64 %index595, 16
  %1710 = icmp eq i64 %index.next602.1, 4096
  br i1 %1710, label %middle.block590, label %vector.body594, !llvm.loop !24

middle.block590:                                  ; preds = %vector.body594
  %bin.rdx603 = or <4 x i1> %1709, %1708
  %bin.rdx603.fr = freeze <4 x i1> %bin.rdx603
  %1711 = or <4 x i1> %bin.rdx603.fr, %1691
  br label %vector.body610

vector.body610:                                   ; preds = %vector.body610, %middle.block590
  %index611 = phi i64 [ 0, %middle.block590 ], [ %index.next618.1, %vector.body610 ]
  %vec.phi612 = phi <4 x i1> [ zeroinitializer, %middle.block590 ], [ %1728, %vector.body610 ]
  %vec.phi613 = phi <4 x i1> [ zeroinitializer, %middle.block590 ], [ %1729, %vector.body610 ]
  %1712 = add nuw nsw i64 %index611, 24576
  %1713 = getelementptr inbounds i8, ptr %20, i64 %1712
  %1714 = getelementptr inbounds i8, ptr %1713, i64 4
  %wide.load614 = load <4 x i8>, ptr %1713, align 1, !tbaa !15
  %wide.load615 = load <4 x i8>, ptr %1714, align 1, !tbaa !15
  %1715 = getelementptr inbounds i8, ptr %21, i64 %1712
  %1716 = getelementptr inbounds i8, ptr %1715, i64 4
  %wide.load616 = load <4 x i8>, ptr %1715, align 1, !tbaa !15
  %wide.load617 = load <4 x i8>, ptr %1716, align 1, !tbaa !15
  %1717 = icmp ne <4 x i8> %wide.load614, %wide.load616
  %1718 = icmp ne <4 x i8> %wide.load615, %wide.load617
  %1719 = or <4 x i1> %vec.phi612, %1717
  %1720 = or <4 x i1> %vec.phi613, %1718
  %1721 = add nuw nsw i64 %index611, 24584
  %1722 = getelementptr inbounds i8, ptr %20, i64 %1721
  %1723 = getelementptr inbounds i8, ptr %1722, i64 4
  %wide.load614.1 = load <4 x i8>, ptr %1722, align 1, !tbaa !15
  %wide.load615.1 = load <4 x i8>, ptr %1723, align 1, !tbaa !15
  %1724 = getelementptr inbounds i8, ptr %21, i64 %1721
  %1725 = getelementptr inbounds i8, ptr %1724, i64 4
  %wide.load616.1 = load <4 x i8>, ptr %1724, align 1, !tbaa !15
  %wide.load617.1 = load <4 x i8>, ptr %1725, align 1, !tbaa !15
  %1726 = icmp ne <4 x i8> %wide.load614.1, %wide.load616.1
  %1727 = icmp ne <4 x i8> %wide.load615.1, %wide.load617.1
  %1728 = or <4 x i1> %1719, %1726
  %1729 = or <4 x i1> %1720, %1727
  %index.next618.1 = add nuw nsw i64 %index611, 16
  %1730 = icmp eq i64 %index.next618.1, 4096
  br i1 %1730, label %middle.block606, label %vector.body610, !llvm.loop !25

middle.block606:                                  ; preds = %vector.body610
  %bin.rdx619 = or <4 x i1> %1729, %1728
  %bin.rdx619.fr = freeze <4 x i1> %bin.rdx619
  %1731 = or <4 x i1> %bin.rdx619.fr, %1711
  %1732 = bitcast <4 x i1> %1731 to i4
  %narrow784 = icmp eq i4 %1732, 0
  br label %vector.body626

vector.body626:                                   ; preds = %vector.body626, %middle.block606
  %index627 = phi i64 [ 0, %middle.block606 ], [ %index.next634.1, %vector.body626 ]
  %vec.phi628 = phi <4 x i1> [ zeroinitializer, %middle.block606 ], [ %1749, %vector.body626 ]
  %vec.phi629 = phi <4 x i1> [ zeroinitializer, %middle.block606 ], [ %1750, %vector.body626 ]
  %1733 = add nuw nsw i64 %index627, 28672
  %1734 = getelementptr inbounds i8, ptr %20, i64 %1733
  %1735 = getelementptr inbounds i8, ptr %1734, i64 4
  %wide.load630 = load <4 x i8>, ptr %1734, align 1, !tbaa !15
  %wide.load631 = load <4 x i8>, ptr %1735, align 1, !tbaa !15
  %1736 = getelementptr inbounds i8, ptr %21, i64 %1733
  %1737 = getelementptr inbounds i8, ptr %1736, i64 4
  %wide.load632 = load <4 x i8>, ptr %1736, align 1, !tbaa !15
  %wide.load633 = load <4 x i8>, ptr %1737, align 1, !tbaa !15
  %1738 = icmp ne <4 x i8> %wide.load630, %wide.load632
  %1739 = icmp ne <4 x i8> %wide.load631, %wide.load633
  %1740 = or <4 x i1> %vec.phi628, %1738
  %1741 = or <4 x i1> %vec.phi629, %1739
  %1742 = add nuw nsw i64 %index627, 28680
  %1743 = getelementptr inbounds i8, ptr %20, i64 %1742
  %1744 = getelementptr inbounds i8, ptr %1743, i64 4
  %wide.load630.1 = load <4 x i8>, ptr %1743, align 1, !tbaa !15
  %wide.load631.1 = load <4 x i8>, ptr %1744, align 1, !tbaa !15
  %1745 = getelementptr inbounds i8, ptr %21, i64 %1742
  %1746 = getelementptr inbounds i8, ptr %1745, i64 4
  %wide.load632.1 = load <4 x i8>, ptr %1745, align 1, !tbaa !15
  %wide.load633.1 = load <4 x i8>, ptr %1746, align 1, !tbaa !15
  %1747 = icmp ne <4 x i8> %wide.load630.1, %wide.load632.1
  %1748 = icmp ne <4 x i8> %wide.load631.1, %wide.load633.1
  %1749 = or <4 x i1> %1740, %1747
  %1750 = or <4 x i1> %1741, %1748
  %index.next634.1 = add nuw nsw i64 %index627, 16
  %1751 = icmp eq i64 %index.next634.1, 4096
  br i1 %1751, label %middle.block622, label %vector.body626, !llvm.loop !26

middle.block622:                                  ; preds = %vector.body626
  %bin.rdx635 = or <4 x i1> %1750, %1749
  %bin.rdx635.fr = freeze <4 x i1> %bin.rdx635
  br label %vector.body642

vector.body642:                                   ; preds = %vector.body642, %middle.block622
  %index643 = phi i64 [ 0, %middle.block622 ], [ %index.next650.1, %vector.body642 ]
  %vec.phi644 = phi <4 x i1> [ zeroinitializer, %middle.block622 ], [ %1768, %vector.body642 ]
  %vec.phi645 = phi <4 x i1> [ zeroinitializer, %middle.block622 ], [ %1769, %vector.body642 ]
  %1752 = add nuw nsw i64 %index643, 32768
  %1753 = getelementptr inbounds i8, ptr %20, i64 %1752
  %1754 = getelementptr inbounds i8, ptr %1753, i64 4
  %wide.load646 = load <4 x i8>, ptr %1753, align 1, !tbaa !15
  %wide.load647 = load <4 x i8>, ptr %1754, align 1, !tbaa !15
  %1755 = getelementptr inbounds i8, ptr %21, i64 %1752
  %1756 = getelementptr inbounds i8, ptr %1755, i64 4
  %wide.load648 = load <4 x i8>, ptr %1755, align 1, !tbaa !15
  %wide.load649 = load <4 x i8>, ptr %1756, align 1, !tbaa !15
  %1757 = icmp ne <4 x i8> %wide.load646, %wide.load648
  %1758 = icmp ne <4 x i8> %wide.load647, %wide.load649
  %1759 = or <4 x i1> %vec.phi644, %1757
  %1760 = or <4 x i1> %vec.phi645, %1758
  %1761 = add nuw nsw i64 %index643, 32776
  %1762 = getelementptr inbounds i8, ptr %20, i64 %1761
  %1763 = getelementptr inbounds i8, ptr %1762, i64 4
  %wide.load646.1 = load <4 x i8>, ptr %1762, align 1, !tbaa !15
  %wide.load647.1 = load <4 x i8>, ptr %1763, align 1, !tbaa !15
  %1764 = getelementptr inbounds i8, ptr %21, i64 %1761
  %1765 = getelementptr inbounds i8, ptr %1764, i64 4
  %wide.load648.1 = load <4 x i8>, ptr %1764, align 1, !tbaa !15
  %wide.load649.1 = load <4 x i8>, ptr %1765, align 1, !tbaa !15
  %1766 = icmp ne <4 x i8> %wide.load646.1, %wide.load648.1
  %1767 = icmp ne <4 x i8> %wide.load647.1, %wide.load649.1
  %1768 = or <4 x i1> %1759, %1766
  %1769 = or <4 x i1> %1760, %1767
  %index.next650.1 = add nuw nsw i64 %index643, 16
  %1770 = icmp eq i64 %index.next650.1, 4096
  br i1 %1770, label %middle.block638, label %vector.body642, !llvm.loop !27

middle.block638:                                  ; preds = %vector.body642
  %bin.rdx651 = or <4 x i1> %1769, %1768
  %bin.rdx651.fr = freeze <4 x i1> %bin.rdx651
  %1771 = or <4 x i1> %bin.rdx651.fr, %bin.rdx635.fr
  br label %vector.body658

vector.body658:                                   ; preds = %vector.body658, %middle.block638
  %index659 = phi i64 [ 0, %middle.block638 ], [ %index.next666.1, %vector.body658 ]
  %vec.phi660 = phi <4 x i1> [ zeroinitializer, %middle.block638 ], [ %1788, %vector.body658 ]
  %vec.phi661 = phi <4 x i1> [ zeroinitializer, %middle.block638 ], [ %1789, %vector.body658 ]
  %1772 = add nuw nsw i64 %index659, 36864
  %1773 = getelementptr inbounds i8, ptr %20, i64 %1772
  %1774 = getelementptr inbounds i8, ptr %1773, i64 4
  %wide.load662 = load <4 x i8>, ptr %1773, align 1, !tbaa !15
  %wide.load663 = load <4 x i8>, ptr %1774, align 1, !tbaa !15
  %1775 = getelementptr inbounds i8, ptr %21, i64 %1772
  %1776 = getelementptr inbounds i8, ptr %1775, i64 4
  %wide.load664 = load <4 x i8>, ptr %1775, align 1, !tbaa !15
  %wide.load665 = load <4 x i8>, ptr %1776, align 1, !tbaa !15
  %1777 = icmp ne <4 x i8> %wide.load662, %wide.load664
  %1778 = icmp ne <4 x i8> %wide.load663, %wide.load665
  %1779 = or <4 x i1> %vec.phi660, %1777
  %1780 = or <4 x i1> %vec.phi661, %1778
  %1781 = add nuw nsw i64 %index659, 36872
  %1782 = getelementptr inbounds i8, ptr %20, i64 %1781
  %1783 = getelementptr inbounds i8, ptr %1782, i64 4
  %wide.load662.1 = load <4 x i8>, ptr %1782, align 1, !tbaa !15
  %wide.load663.1 = load <4 x i8>, ptr %1783, align 1, !tbaa !15
  %1784 = getelementptr inbounds i8, ptr %21, i64 %1781
  %1785 = getelementptr inbounds i8, ptr %1784, i64 4
  %wide.load664.1 = load <4 x i8>, ptr %1784, align 1, !tbaa !15
  %wide.load665.1 = load <4 x i8>, ptr %1785, align 1, !tbaa !15
  %1786 = icmp ne <4 x i8> %wide.load662.1, %wide.load664.1
  %1787 = icmp ne <4 x i8> %wide.load663.1, %wide.load665.1
  %1788 = or <4 x i1> %1779, %1786
  %1789 = or <4 x i1> %1780, %1787
  %index.next666.1 = add nuw nsw i64 %index659, 16
  %1790 = icmp eq i64 %index.next666.1, 4096
  br i1 %1790, label %middle.block654, label %vector.body658, !llvm.loop !28

middle.block654:                                  ; preds = %vector.body658
  %bin.rdx667 = or <4 x i1> %1789, %1788
  %bin.rdx667.fr = freeze <4 x i1> %bin.rdx667
  %1791 = or <4 x i1> %bin.rdx667.fr, %1771
  br label %vector.body674

vector.body674:                                   ; preds = %vector.body674, %middle.block654
  %index675 = phi i64 [ 0, %middle.block654 ], [ %index.next682.1, %vector.body674 ]
  %vec.phi676 = phi <4 x i1> [ zeroinitializer, %middle.block654 ], [ %1808, %vector.body674 ]
  %vec.phi677 = phi <4 x i1> [ zeroinitializer, %middle.block654 ], [ %1809, %vector.body674 ]
  %1792 = add nuw nsw i64 %index675, 40960
  %1793 = getelementptr inbounds i8, ptr %20, i64 %1792
  %1794 = getelementptr inbounds i8, ptr %1793, i64 4
  %wide.load678 = load <4 x i8>, ptr %1793, align 1, !tbaa !15
  %wide.load679 = load <4 x i8>, ptr %1794, align 1, !tbaa !15
  %1795 = getelementptr inbounds i8, ptr %21, i64 %1792
  %1796 = getelementptr inbounds i8, ptr %1795, i64 4
  %wide.load680 = load <4 x i8>, ptr %1795, align 1, !tbaa !15
  %wide.load681 = load <4 x i8>, ptr %1796, align 1, !tbaa !15
  %1797 = icmp ne <4 x i8> %wide.load678, %wide.load680
  %1798 = icmp ne <4 x i8> %wide.load679, %wide.load681
  %1799 = or <4 x i1> %vec.phi676, %1797
  %1800 = or <4 x i1> %vec.phi677, %1798
  %1801 = add nuw nsw i64 %index675, 40968
  %1802 = getelementptr inbounds i8, ptr %20, i64 %1801
  %1803 = getelementptr inbounds i8, ptr %1802, i64 4
  %wide.load678.1 = load <4 x i8>, ptr %1802, align 1, !tbaa !15
  %wide.load679.1 = load <4 x i8>, ptr %1803, align 1, !tbaa !15
  %1804 = getelementptr inbounds i8, ptr %21, i64 %1801
  %1805 = getelementptr inbounds i8, ptr %1804, i64 4
  %wide.load680.1 = load <4 x i8>, ptr %1804, align 1, !tbaa !15
  %wide.load681.1 = load <4 x i8>, ptr %1805, align 1, !tbaa !15
  %1806 = icmp ne <4 x i8> %wide.load678.1, %wide.load680.1
  %1807 = icmp ne <4 x i8> %wide.load679.1, %wide.load681.1
  %1808 = or <4 x i1> %1799, %1806
  %1809 = or <4 x i1> %1800, %1807
  %index.next682.1 = add nuw nsw i64 %index675, 16
  %1810 = icmp eq i64 %index.next682.1, 4096
  br i1 %1810, label %middle.block670, label %vector.body674, !llvm.loop !29

middle.block670:                                  ; preds = %vector.body674
  %bin.rdx683 = or <4 x i1> %1809, %1808
  %bin.rdx683.fr = freeze <4 x i1> %bin.rdx683
  %1811 = or <4 x i1> %bin.rdx683.fr, %1791
  br label %vector.body690

vector.body690:                                   ; preds = %vector.body690, %middle.block670
  %index691 = phi i64 [ 0, %middle.block670 ], [ %index.next698.1, %vector.body690 ]
  %vec.phi692 = phi <4 x i1> [ zeroinitializer, %middle.block670 ], [ %1828, %vector.body690 ]
  %vec.phi693 = phi <4 x i1> [ zeroinitializer, %middle.block670 ], [ %1829, %vector.body690 ]
  %1812 = add nuw nsw i64 %index691, 45056
  %1813 = getelementptr inbounds i8, ptr %20, i64 %1812
  %1814 = getelementptr inbounds i8, ptr %1813, i64 4
  %wide.load694 = load <4 x i8>, ptr %1813, align 1, !tbaa !15
  %wide.load695 = load <4 x i8>, ptr %1814, align 1, !tbaa !15
  %1815 = getelementptr inbounds i8, ptr %21, i64 %1812
  %1816 = getelementptr inbounds i8, ptr %1815, i64 4
  %wide.load696 = load <4 x i8>, ptr %1815, align 1, !tbaa !15
  %wide.load697 = load <4 x i8>, ptr %1816, align 1, !tbaa !15
  %1817 = icmp ne <4 x i8> %wide.load694, %wide.load696
  %1818 = icmp ne <4 x i8> %wide.load695, %wide.load697
  %1819 = or <4 x i1> %vec.phi692, %1817
  %1820 = or <4 x i1> %vec.phi693, %1818
  %1821 = add nuw nsw i64 %index691, 45064
  %1822 = getelementptr inbounds i8, ptr %20, i64 %1821
  %1823 = getelementptr inbounds i8, ptr %1822, i64 4
  %wide.load694.1 = load <4 x i8>, ptr %1822, align 1, !tbaa !15
  %wide.load695.1 = load <4 x i8>, ptr %1823, align 1, !tbaa !15
  %1824 = getelementptr inbounds i8, ptr %21, i64 %1821
  %1825 = getelementptr inbounds i8, ptr %1824, i64 4
  %wide.load696.1 = load <4 x i8>, ptr %1824, align 1, !tbaa !15
  %wide.load697.1 = load <4 x i8>, ptr %1825, align 1, !tbaa !15
  %1826 = icmp ne <4 x i8> %wide.load694.1, %wide.load696.1
  %1827 = icmp ne <4 x i8> %wide.load695.1, %wide.load697.1
  %1828 = or <4 x i1> %1819, %1826
  %1829 = or <4 x i1> %1820, %1827
  %index.next698.1 = add nuw nsw i64 %index691, 16
  %1830 = icmp eq i64 %index.next698.1, 4096
  br i1 %1830, label %middle.block686, label %vector.body690, !llvm.loop !30

middle.block686:                                  ; preds = %vector.body690
  %bin.rdx699 = or <4 x i1> %1829, %1828
  %bin.rdx699.fr = freeze <4 x i1> %bin.rdx699
  %1831 = or <4 x i1> %bin.rdx699.fr, %1811
  br label %vector.body706

vector.body706:                                   ; preds = %vector.body706, %middle.block686
  %index707 = phi i64 [ 0, %middle.block686 ], [ %index.next714.1, %vector.body706 ]
  %vec.phi708 = phi <4 x i1> [ zeroinitializer, %middle.block686 ], [ %1848, %vector.body706 ]
  %vec.phi709 = phi <4 x i1> [ zeroinitializer, %middle.block686 ], [ %1849, %vector.body706 ]
  %1832 = add nuw nsw i64 %index707, 49152
  %1833 = getelementptr inbounds i8, ptr %20, i64 %1832
  %1834 = getelementptr inbounds i8, ptr %1833, i64 4
  %wide.load710 = load <4 x i8>, ptr %1833, align 1, !tbaa !15
  %wide.load711 = load <4 x i8>, ptr %1834, align 1, !tbaa !15
  %1835 = getelementptr inbounds i8, ptr %21, i64 %1832
  %1836 = getelementptr inbounds i8, ptr %1835, i64 4
  %wide.load712 = load <4 x i8>, ptr %1835, align 1, !tbaa !15
  %wide.load713 = load <4 x i8>, ptr %1836, align 1, !tbaa !15
  %1837 = icmp ne <4 x i8> %wide.load710, %wide.load712
  %1838 = icmp ne <4 x i8> %wide.load711, %wide.load713
  %1839 = or <4 x i1> %vec.phi708, %1837
  %1840 = or <4 x i1> %vec.phi709, %1838
  %1841 = add nuw nsw i64 %index707, 49160
  %1842 = getelementptr inbounds i8, ptr %20, i64 %1841
  %1843 = getelementptr inbounds i8, ptr %1842, i64 4
  %wide.load710.1 = load <4 x i8>, ptr %1842, align 1, !tbaa !15
  %wide.load711.1 = load <4 x i8>, ptr %1843, align 1, !tbaa !15
  %1844 = getelementptr inbounds i8, ptr %21, i64 %1841
  %1845 = getelementptr inbounds i8, ptr %1844, i64 4
  %wide.load712.1 = load <4 x i8>, ptr %1844, align 1, !tbaa !15
  %wide.load713.1 = load <4 x i8>, ptr %1845, align 1, !tbaa !15
  %1846 = icmp ne <4 x i8> %wide.load710.1, %wide.load712.1
  %1847 = icmp ne <4 x i8> %wide.load711.1, %wide.load713.1
  %1848 = or <4 x i1> %1839, %1846
  %1849 = or <4 x i1> %1840, %1847
  %index.next714.1 = add nuw nsw i64 %index707, 16
  %1850 = icmp eq i64 %index.next714.1, 4096
  br i1 %1850, label %middle.block702, label %vector.body706, !llvm.loop !31

middle.block702:                                  ; preds = %vector.body706
  %bin.rdx715 = or <4 x i1> %1849, %1848
  %bin.rdx715.fr = freeze <4 x i1> %bin.rdx715
  %1851 = or <4 x i1> %bin.rdx715.fr, %1831
  br label %vector.body722

vector.body722:                                   ; preds = %vector.body722, %middle.block702
  %index723 = phi i64 [ 0, %middle.block702 ], [ %index.next730.1, %vector.body722 ]
  %vec.phi724 = phi <4 x i1> [ zeroinitializer, %middle.block702 ], [ %1868, %vector.body722 ]
  %vec.phi725 = phi <4 x i1> [ zeroinitializer, %middle.block702 ], [ %1869, %vector.body722 ]
  %1852 = add nuw nsw i64 %index723, 53248
  %1853 = getelementptr inbounds i8, ptr %20, i64 %1852
  %1854 = getelementptr inbounds i8, ptr %1853, i64 4
  %wide.load726 = load <4 x i8>, ptr %1853, align 1, !tbaa !15
  %wide.load727 = load <4 x i8>, ptr %1854, align 1, !tbaa !15
  %1855 = getelementptr inbounds i8, ptr %21, i64 %1852
  %1856 = getelementptr inbounds i8, ptr %1855, i64 4
  %wide.load728 = load <4 x i8>, ptr %1855, align 1, !tbaa !15
  %wide.load729 = load <4 x i8>, ptr %1856, align 1, !tbaa !15
  %1857 = icmp ne <4 x i8> %wide.load726, %wide.load728
  %1858 = icmp ne <4 x i8> %wide.load727, %wide.load729
  %1859 = or <4 x i1> %vec.phi724, %1857
  %1860 = or <4 x i1> %vec.phi725, %1858
  %1861 = add nuw nsw i64 %index723, 53256
  %1862 = getelementptr inbounds i8, ptr %20, i64 %1861
  %1863 = getelementptr inbounds i8, ptr %1862, i64 4
  %wide.load726.1 = load <4 x i8>, ptr %1862, align 1, !tbaa !15
  %wide.load727.1 = load <4 x i8>, ptr %1863, align 1, !tbaa !15
  %1864 = getelementptr inbounds i8, ptr %21, i64 %1861
  %1865 = getelementptr inbounds i8, ptr %1864, i64 4
  %wide.load728.1 = load <4 x i8>, ptr %1864, align 1, !tbaa !15
  %wide.load729.1 = load <4 x i8>, ptr %1865, align 1, !tbaa !15
  %1866 = icmp ne <4 x i8> %wide.load726.1, %wide.load728.1
  %1867 = icmp ne <4 x i8> %wide.load727.1, %wide.load729.1
  %1868 = or <4 x i1> %1859, %1866
  %1869 = or <4 x i1> %1860, %1867
  %index.next730.1 = add nuw nsw i64 %index723, 16
  %1870 = icmp eq i64 %index.next730.1, 4096
  br i1 %1870, label %middle.block718, label %vector.body722, !llvm.loop !32

middle.block718:                                  ; preds = %vector.body722
  %bin.rdx731 = or <4 x i1> %1869, %1868
  %bin.rdx731.fr = freeze <4 x i1> %bin.rdx731
  %1871 = or <4 x i1> %bin.rdx731.fr, %1851
  %1872 = bitcast <4 x i1> %1871 to i4
  %1873 = icmp eq i4 %1872, 0
  br label %vector.body738

vector.body738:                                   ; preds = %vector.body738, %middle.block718
  %index739 = phi i64 [ 0, %middle.block718 ], [ %index.next746.1, %vector.body738 ]
  %vec.phi740 = phi <4 x i1> [ zeroinitializer, %middle.block718 ], [ %1890, %vector.body738 ]
  %vec.phi741 = phi <4 x i1> [ zeroinitializer, %middle.block718 ], [ %1891, %vector.body738 ]
  %1874 = add nuw nsw i64 %index739, 57344
  %1875 = getelementptr inbounds i8, ptr %20, i64 %1874
  %1876 = getelementptr inbounds i8, ptr %1875, i64 4
  %wide.load742 = load <4 x i8>, ptr %1875, align 1, !tbaa !15
  %wide.load743 = load <4 x i8>, ptr %1876, align 1, !tbaa !15
  %1877 = getelementptr inbounds i8, ptr %21, i64 %1874
  %1878 = getelementptr inbounds i8, ptr %1877, i64 4
  %wide.load744 = load <4 x i8>, ptr %1877, align 1, !tbaa !15
  %wide.load745 = load <4 x i8>, ptr %1878, align 1, !tbaa !15
  %1879 = icmp ne <4 x i8> %wide.load742, %wide.load744
  %1880 = icmp ne <4 x i8> %wide.load743, %wide.load745
  %1881 = or <4 x i1> %vec.phi740, %1879
  %1882 = or <4 x i1> %vec.phi741, %1880
  %1883 = add nuw nsw i64 %index739, 57352
  %1884 = getelementptr inbounds i8, ptr %20, i64 %1883
  %1885 = getelementptr inbounds i8, ptr %1884, i64 4
  %wide.load742.1 = load <4 x i8>, ptr %1884, align 1, !tbaa !15
  %wide.load743.1 = load <4 x i8>, ptr %1885, align 1, !tbaa !15
  %1886 = getelementptr inbounds i8, ptr %21, i64 %1883
  %1887 = getelementptr inbounds i8, ptr %1886, i64 4
  %wide.load744.1 = load <4 x i8>, ptr %1886, align 1, !tbaa !15
  %wide.load745.1 = load <4 x i8>, ptr %1887, align 1, !tbaa !15
  %1888 = icmp ne <4 x i8> %wide.load742.1, %wide.load744.1
  %1889 = icmp ne <4 x i8> %wide.load743.1, %wide.load745.1
  %1890 = or <4 x i1> %1881, %1888
  %1891 = or <4 x i1> %1882, %1889
  %index.next746.1 = add nuw nsw i64 %index739, 16
  %1892 = icmp eq i64 %index.next746.1, 4096
  br i1 %1892, label %middle.block734, label %vector.body738, !llvm.loop !33

middle.block734:                                  ; preds = %vector.body738
  %bin.rdx747 = or <4 x i1> %1891, %1890
  %bin.rdx747.fr = freeze <4 x i1> %bin.rdx747
  br label %vector.body754

vector.body754:                                   ; preds = %vector.body754, %middle.block734
  %index755 = phi i64 [ 0, %middle.block734 ], [ %index.next762.1, %vector.body754 ]
  %vec.phi756 = phi <4 x i1> [ zeroinitializer, %middle.block734 ], [ %1909, %vector.body754 ]
  %vec.phi757 = phi <4 x i1> [ zeroinitializer, %middle.block734 ], [ %1910, %vector.body754 ]
  %1893 = add nuw nsw i64 %index755, 61440
  %1894 = getelementptr inbounds i8, ptr %20, i64 %1893
  %1895 = getelementptr inbounds i8, ptr %1894, i64 4
  %wide.load758 = load <4 x i8>, ptr %1894, align 1, !tbaa !15
  %wide.load759 = load <4 x i8>, ptr %1895, align 1, !tbaa !15
  %1896 = getelementptr inbounds i8, ptr %21, i64 %1893
  %1897 = getelementptr inbounds i8, ptr %1896, i64 4
  %wide.load760 = load <4 x i8>, ptr %1896, align 1, !tbaa !15
  %wide.load761 = load <4 x i8>, ptr %1897, align 1, !tbaa !15
  %1898 = icmp ne <4 x i8> %wide.load758, %wide.load760
  %1899 = icmp ne <4 x i8> %wide.load759, %wide.load761
  %1900 = or <4 x i1> %vec.phi756, %1898
  %1901 = or <4 x i1> %vec.phi757, %1899
  %1902 = add nuw nsw i64 %index755, 61448
  %1903 = getelementptr inbounds i8, ptr %20, i64 %1902
  %1904 = getelementptr inbounds i8, ptr %1903, i64 4
  %wide.load758.1 = load <4 x i8>, ptr %1903, align 1, !tbaa !15
  %wide.load759.1 = load <4 x i8>, ptr %1904, align 1, !tbaa !15
  %1905 = getelementptr inbounds i8, ptr %21, i64 %1902
  %1906 = getelementptr inbounds i8, ptr %1905, i64 4
  %wide.load760.1 = load <4 x i8>, ptr %1905, align 1, !tbaa !15
  %wide.load761.1 = load <4 x i8>, ptr %1906, align 1, !tbaa !15
  %1907 = icmp ne <4 x i8> %wide.load758.1, %wide.load760.1
  %1908 = icmp ne <4 x i8> %wide.load759.1, %wide.load761.1
  %1909 = or <4 x i1> %1900, %1907
  %1910 = or <4 x i1> %1901, %1908
  %index.next762.1 = add nuw nsw i64 %index755, 16
  %1911 = icmp eq i64 %index.next762.1, 4096
  br i1 %1911, label %middle.block750, label %vector.body754, !llvm.loop !34

middle.block750:                                  ; preds = %vector.body754
  %bin.rdx763 = or <4 x i1> %1910, %1909
  %bin.rdx763.fr = freeze <4 x i1> %bin.rdx763
  %1912 = or <4 x i1> %bin.rdx763.fr, %bin.rdx747.fr
  %1913 = bitcast <4 x i1> %1912 to i4
  %1914 = icmp eq i4 %1913, 0
  %1915 = select i1 %1914, i1 %1873, i1 false
  %narrow = select i1 %1915, i1 %narrow784, i1 false
  br i1 %narrow, label %1916, label %1918

1916:                                             ; preds = %middle.block750
  %1917 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str)
  br label %1923

1918:                                             ; preds = %middle.block750
  %1919 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1)
  br label %1923

1920:                                             ; preds = %2
  %1921 = load ptr, ptr @stderr, align 8, !tbaa !35
  %1922 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %1921, ptr noundef nonnull @.str.2) #7
  br label %1923

1923:                                             ; preds = %1916, %1918, %1920
  %.0229 = phi i32 [ 0, %1916 ], [ 0, %1918 ], [ -1, %1920 ]
  call void @libxsmm_free(ptr noundef %8) #6
  call void @libxsmm_free(ptr noundef %9) #6
  call void @libxsmm_free(ptr noundef %10) #6
  call void @libxsmm_free(ptr noundef %11) #6
  call void @libxsmm_free(ptr noundef %12) #6
  call void @libxsmm_free(ptr noundef %13) #6
  call void @libxsmm_free(ptr noundef %14) #6
  call void @libxsmm_free(ptr noundef %15) #6
  call void @libxsmm_free(ptr noundef %16) #6
  call void @libxsmm_free(ptr noundef %17) #6
  call void @libxsmm_free(ptr noundef %18) #6
  call void @libxsmm_free(ptr noundef %19) #6
  call void @libxsmm_free(ptr noundef %20) #6
  call void @libxsmm_free(ptr noundef %21) #6
  call void @llvm.lifetime.end.p0(i64 240, ptr nonnull %4) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %3) #6
  ret i32 %.0229
}

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

declare { i64, i64 } @libxsmm_create_matrix_arg_attributes(i32 noundef, i32 noundef, i32 noundef, i32 noundef) local_unnamed_addr #2

declare noalias ptr @libxsmm_aligned_malloc(i64 noundef, i64 noundef) local_unnamed_addr #2

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @init_random_matrix(i32 noundef, ptr noundef, i32 noundef, i32 noundef, i32 noundef, i32 noundef) local_unnamed_addr #3

declare void @libxsmm_rne_convert_fp32_bf8(ptr noundef, ptr noundef, i64 noundef) local_unnamed_addr #2

declare void @libxsmm_convert_bf8_f32(ptr noundef, ptr noundef, i64 noundef) local_unnamed_addr #2

declare i32 @libxsmm_meqn_create() local_unnamed_addr #2

declare i64 @libxsmm_create_meqn_op_metadata(i32 noundef, i32 noundef) local_unnamed_addr #2

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

declare i32 @libxsmm_meqn_push_back_ternary_op(i64, i32 noundef, i32 noundef, i32 noundef) local_unnamed_addr #2

declare { i64, i64 } @libxsmm_create_meqn_arg_shape(i32 noundef, i32 noundef, i32 noundef, i32 noundef) local_unnamed_addr #2

declare i64 @libxsmm_create_meqn_arg_metadata(i32 noundef, i32 noundef) local_unnamed_addr #2

declare i32 @libxsmm_meqn_push_back_arg(i64, i64, i64, i64, i64) local_unnamed_addr #2

declare ptr @libxsmm_dispatch_meqn(i32 noundef, i64, i64) local_unnamed_addr #2

; Function Attrs: nofree nounwind
declare noundef i32 @printf(ptr nocapture noundef readonly, ...) local_unnamed_addr #4

; Function Attrs: nofree nounwind
declare noundef i32 @fprintf(ptr nocapture noundef, ptr nocapture noundef readonly, ...) local_unnamed_addr #4

declare void @libxsmm_free(ptr noundef) local_unnamed_addr #2

; 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 = { 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 #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { 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 #4 = { nofree 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 #5 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #6 = { nounwind }
attributes #7 = { cold nounwind }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !7, i64 0}
!6 = !{!"libxsmm_matrix_arg", !7, i64 0, !7, i64 8, !7, i64 16, !7, i64 24, !7, i64 32, !7, i64 40}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!11, !7, i64 8}
!11 = !{!"libxsmm_meqn_param", !7, i64 0, !7, i64 8, !6, i64 16}
!12 = !{!11, !7, i64 16}
!13 = !{!14, !14, i64 0}
!14 = !{!"float", !8, i64 0}
!15 = !{!8, !8, i64 0}
!16 = distinct !{!16, !17, !18, !19}
!17 = !{!"llvm.loop.mustprogress"}
!18 = !{!"llvm.loop.isvectorized", i32 1}
!19 = !{!"llvm.loop.unroll.runtime.disable"}
!20 = distinct !{!20, !17, !18, !19}
!21 = distinct !{!21, !17, !18, !19}
!22 = distinct !{!22, !17, !18, !19}
!23 = distinct !{!23, !17, !18, !19}
!24 = distinct !{!24, !17, !18, !19}
!25 = distinct !{!25, !17, !18, !19}
!26 = distinct !{!26, !17, !18, !19}
!27 = distinct !{!27, !17, !18, !19}
!28 = distinct !{!28, !17, !18, !19}
!29 = distinct !{!29, !17, !18, !19}
!30 = distinct !{!30, !17, !18, !19}
!31 = distinct !{!31, !17, !18, !19}
!32 = distinct !{!32, !17, !18, !19}
!33 = distinct !{!33, !17, !18, !19}
!34 = distinct !{!34, !17, !18, !19}
!35 = !{!7, !7, i64 0}


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