Skip to content

Instantly share code, notes, and snippets.

@cheshire

cheshire/ir_with_opt_reverted_w_gemm Secret

Created February 6, 2020 23:53
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save cheshire/fb06443834735c2fa04fa0eacb288606 to your computer and use it in GitHub Desktop.
Save cheshire/fb06443834735c2fa04fa0eacb288606 to your computer and use it in GitHub Desktop.
Download ZIP
IR with optimizations, with bad commit reverted, with GEMM
Raw
ir_with_opt_reverted_w_gemm
; ModuleID = '__compute_module'
source_filename = "__compute_module"
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-grtev4-linux-gnu"
; Function Attrs: nofree nounwind uwtable
define void @EntryModule(i8* nocapture readnone %retval, i8* noalias nocapture readnone %run_options, i8** noalias nocapture readnone %params, i8** noalias nocapture readonly %buffer_table, i64* noalias nocapture readnone %prof_counters) local_unnamed_addr #0 {
entry:
%0 = getelementptr inbounds i8*, i8** %buffer_table, i64 9
%1 = bitcast i8** %0 to [1 x [3 x float]]**
%2 = load [1 x [3 x float]]*, [1 x [3 x float]]** %1, align 8, !invariant.load !0, !dereferenceable !1, !align !2
%3 = getelementptr inbounds i8*, i8** %buffer_table, i64 5
%4 = bitcast i8** %3 to [1 x [3 x double]]**
%5 = load [1 x [3 x double]]*, [1 x [3 x double]]** %4, align 8, !invariant.load !0, !dereferenceable !3, !align !2
%6 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
%7 = bitcast i8** %6 to [1 x [3 x [3 x double]]]**
%8 = load [1 x [3 x [3 x double]]]*, [1 x [3 x [3 x double]]]** %7, align 8, !invariant.load !0, !dereferenceable !4, !align !2
%9 = getelementptr inbounds i8*, i8** %buffer_table, i64 1
%10 = load i8*, i8** %9, align 8, !invariant.load !0, !dereferenceable !5, !align !2
%fusion.3 = bitcast i8* %10 to [3 x [3 x double]]*
%11 = getelementptr inbounds [1 x [3 x float]], [1 x [3 x float]]* %2, i64 0, i64 0, i64 0
%12 = load float, float* %11, align 8, !invariant.load !0, !noalias !6
%13 = fmul fast float %12, 2.000000e+00
%14 = fadd fast float %13, -1.000000e+00
%15 = fcmp fast one float %14, 0.000000e+00
%16 = uitofp i1 %15 to float
%17 = tail call fast float @llvm.copysign.f32(float %16, float %14)
%18 = fpext float %17 to double
%19 = getelementptr inbounds [1 x [3 x double]], [1 x [3 x double]]* %5, i64 0, i64 0, i64 0
%20 = load double, double* %19, align 8, !invariant.load !0, !noalias !6
%21 = fmul fast double %20, 0x3FDA827999FCEF34
%22 = fadd fast double %21, 1.000000e+00
%23 = fmul fast double %22, %18
%24 = bitcast i8* %10 to double*
store double %23, double* %24, align 8, !alias.scope !6, !noalias !9
%25 = getelementptr inbounds [1 x [3 x float]], [1 x [3 x float]]* %2, i64 0, i64 0, i64 1
%26 = load float, float* %25, align 4, !invariant.load !0, !noalias !6
%27 = fmul fast float %26, 2.000000e+00
%28 = fadd fast float %27, -1.000000e+00
%29 = fcmp fast one float %28, 0.000000e+00
%30 = uitofp i1 %29 to float
%31 = tail call fast float @llvm.copysign.f32(float %30, float %28)
%32 = fpext float %31 to double
%33 = getelementptr inbounds [1 x [3 x double]], [1 x [3 x double]]* %5, i64 0, i64 0, i64 1
%34 = load double, double* %33, align 8, !invariant.load !0, !noalias !6
%35 = fmul fast double %34, 0x3FDA827999FCEF34
%36 = fadd fast double %35, 1.000000e+00
%37 = fmul fast double %36, %32
%38 = getelementptr inbounds i8, i8* %10, i64 8
%39 = getelementptr inbounds [1 x [3 x float]], [1 x [3 x float]]* %2, i64 0, i64 0, i64 2
%40 = load float, float* %39, align 8, !invariant.load !0, !noalias !6
%41 = fmul fast float %40, 2.000000e+00
%42 = fadd fast float %41, -1.000000e+00
%43 = fcmp fast one float %42, 0.000000e+00
%44 = uitofp i1 %43 to float
%45 = tail call fast float @llvm.copysign.f32(float %44, float %42)
%46 = fpext float %45 to double
%47 = getelementptr inbounds [1 x [3 x double]], [1 x [3 x double]]* %5, i64 0, i64 0, i64 2
%48 = load double, double* %47, align 8, !invariant.load !0, !noalias !6
%49 = fmul fast double %48, 0x3FDA827999FCEF34
%50 = fadd fast double %49, 1.000000e+00
%51 = fmul fast double %50, %46
%52 = bitcast i8* %38 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %52, align 8, !alias.scope !6, !noalias !9
%53 = getelementptr inbounds [1 x [3 x [3 x double]]], [1 x [3 x [3 x double]]]* %8, i64 0, i64 0, i64 1, i64 0
%54 = load double, double* %53, align 8, !invariant.load !0, !noalias !6
%55 = getelementptr inbounds i8, i8* %10, i64 24
%56 = bitcast i8* %55 to double*
store double %54, double* %56, align 8, !alias.scope !6, !noalias !9
%57 = getelementptr inbounds i8, i8* %10, i64 32
%58 = bitcast i8* %57 to double*
store double %37, double* %58, align 8, !alias.scope !6, !noalias !9
%59 = getelementptr inbounds i8, i8* %10, i64 40
%60 = bitcast i8* %59 to double*
store double 0.000000e+00, double* %60, align 8, !alias.scope !6, !noalias !9
%61 = getelementptr inbounds [1 x [3 x [3 x double]]], [1 x [3 x [3 x double]]]* %8, i64 0, i64 0, i64 2, i64 0
%62 = load double, double* %61, align 8, !invariant.load !0, !noalias !6
%63 = getelementptr inbounds i8, i8* %10, i64 48
%64 = bitcast i8* %63 to double*
store double %62, double* %64, align 8, !alias.scope !6, !noalias !9
%65 = getelementptr inbounds [1 x [3 x [3 x double]]], [1 x [3 x [3 x double]]]* %8, i64 0, i64 0, i64 2, i64 1
%66 = bitcast double* %65 to i64*
%67 = load i64, i64* %66, align 8, !invariant.load !0, !noalias !6
%68 = getelementptr inbounds i8, i8* %10, i64 56
%69 = bitcast i8* %68 to i64*
store i64 %67, i64* %69, align 8, !alias.scope !6, !noalias !9
%70 = getelementptr inbounds i8, i8* %10, i64 64
%71 = bitcast i8* %70 to double*
store double %51, double* %71, align 8, !alias.scope !6, !noalias !9
%72 = load i8*, i8** %buffer_table, align 8, !invariant.load !0, !dereferenceable !5, !align !2
%73 = fmul fast double %23, %23
%74 = insertelement <2 x double> <double undef, double 0.000000e+00>, double %73, i32 0
br label %vector.body
vector.body: ; preds = %vector.body, %entry
%index = phi i64 [ 0, %entry ], [ %index.next, %vector.body ]
%vec.phi = phi <2 x double> [ %74, %entry ], [ %78, %vector.body ]
%offset.idx = or i64 %index, 1
%75 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 0, i64 %offset.idx
%76 = bitcast double* %75 to <2 x double>*
%wide.load = load <2 x double>, <2 x double>* %76, align 8, !alias.scope !6, !noalias !9
%77 = fmul fast <2 x double> %wide.load, %wide.load
%78 = fadd fast <2 x double> %77, %vec.phi
%index.next = add i64 %index, 2
%79 = icmp eq i64 %index, 0
br i1 %79, label %middle.block, label %vector.body, !llvm.loop !11
middle.block: ; preds = %vector.body
%rdx.shuf = shufflevector <2 x double> %78, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%bin.rdx = fadd fast <2 x double> %78, %rdx.shuf
%80 = extractelement <2 x double> %bin.rdx, i32 0
%81 = bitcast i8* %72 to double*
store double %80, double* %81, align 8, !alias.scope !9, !noalias !14
%82 = fmul fast double %54, %23
%83 = insertelement <2 x double> <double undef, double 0.000000e+00>, double %82, i32 0
br label %vector.body201
vector.body201: ; preds = %vector.body201, %middle.block
%index203 = phi i64 [ 0, %middle.block ], [ %index.next204, %vector.body201 ]
%vec.phi211 = phi <2 x double> [ %83, %middle.block ], [ %89, %vector.body201 ]
%offset.idx207 = or i64 %index203, 1
%84 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 0, i64 %offset.idx207
%85 = bitcast double* %84 to <2 x double>*
%wide.load212 = load <2 x double>, <2 x double>* %85, align 8, !alias.scope !6, !noalias !9
%86 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 1, i64 %offset.idx207
%87 = bitcast double* %86 to <2 x double>*
%wide.load213 = load <2 x double>, <2 x double>* %87, align 8, !alias.scope !6, !noalias !9
%88 = fmul fast <2 x double> %wide.load213, %wide.load212
%89 = fadd fast <2 x double> %88, %vec.phi211
%index.next204 = add i64 %index203, 2
%90 = icmp eq i64 %index203, 0
br i1 %90, label %middle.block199, label %vector.body201, !llvm.loop !18
middle.block199: ; preds = %vector.body201
%rdx.shuf214 = shufflevector <2 x double> %89, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%bin.rdx215 = fadd fast <2 x double> %89, %rdx.shuf214
%91 = extractelement <2 x double> %bin.rdx215, i32 0
%92 = getelementptr inbounds i8, i8* %72, i64 8
%93 = bitcast i8* %92 to double*
store double %91, double* %93, align 8, !alias.scope !9, !noalias !14
%94 = fmul fast double %62, %23
%95 = insertelement <2 x double> <double undef, double 0.000000e+00>, double %94, i32 0
br label %vector.body219
vector.body219: ; preds = %vector.body219, %middle.block199
%index221 = phi i64 [ 0, %middle.block199 ], [ %index.next222, %vector.body219 ]
%vec.phi229 = phi <2 x double> [ %95, %middle.block199 ], [ %101, %vector.body219 ]
%offset.idx225 = or i64 %index221, 1
%96 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 0, i64 %offset.idx225
%97 = bitcast double* %96 to <2 x double>*
%wide.load230 = load <2 x double>, <2 x double>* %97, align 8, !alias.scope !6, !noalias !9
%98 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 2, i64 %offset.idx225
%99 = bitcast double* %98 to <2 x double>*
%wide.load231 = load <2 x double>, <2 x double>* %99, align 8, !alias.scope !6, !noalias !9
%100 = fmul fast <2 x double> %wide.load231, %wide.load230
%101 = fadd fast <2 x double> %100, %vec.phi229
%index.next222 = add i64 %index221, 2
%102 = icmp eq i64 %index221, 0
br i1 %102, label %middle.block217, label %vector.body219, !llvm.loop !19
middle.block217: ; preds = %vector.body219
%rdx.shuf232 = shufflevector <2 x double> %101, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%bin.rdx233 = fadd fast <2 x double> %101, %rdx.shuf232
%103 = extractelement <2 x double> %bin.rdx233, i32 0
%104 = getelementptr inbounds i8, i8* %72, i64 16
%105 = bitcast i8* %104 to double*
store double %103, double* %105, align 8, !alias.scope !9, !noalias !14
%106 = fmul fast double %23, %54
%107 = insertelement <2 x double> <double undef, double 0.000000e+00>, double %106, i32 0
br label %vector.body237
vector.body237: ; preds = %vector.body237, %middle.block217
%index239 = phi i64 [ 0, %middle.block217 ], [ %index.next240, %vector.body237 ]
%vec.phi247 = phi <2 x double> [ %107, %middle.block217 ], [ %113, %vector.body237 ]
%offset.idx243 = or i64 %index239, 1
%108 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 1, i64 %offset.idx243
%109 = bitcast double* %108 to <2 x double>*
%wide.load248 = load <2 x double>, <2 x double>* %109, align 8, !alias.scope !6, !noalias !9
%110 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 0, i64 %offset.idx243
%111 = bitcast double* %110 to <2 x double>*
%wide.load249 = load <2 x double>, <2 x double>* %111, align 8, !alias.scope !6, !noalias !9
%112 = fmul fast <2 x double> %wide.load249, %wide.load248
%113 = fadd fast <2 x double> %112, %vec.phi247
%index.next240 = add i64 %index239, 2
%114 = icmp eq i64 %index239, 0
br i1 %114, label %middle.block235, label %vector.body237, !llvm.loop !20
middle.block235: ; preds = %vector.body237
%rdx.shuf250 = shufflevector <2 x double> %113, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%bin.rdx251 = fadd fast <2 x double> %113, %rdx.shuf250
%115 = extractelement <2 x double> %bin.rdx251, i32 0
%116 = getelementptr inbounds i8, i8* %72, i64 24
%117 = bitcast i8* %116 to double*
store double %115, double* %117, align 8, !alias.scope !9, !noalias !14
%118 = fmul fast double %54, %54
%119 = insertelement <2 x double> <double undef, double 0.000000e+00>, double %118, i32 0
br label %vector.body255
vector.body255: ; preds = %vector.body255, %middle.block235
%index257 = phi i64 [ 0, %middle.block235 ], [ %index.next258, %vector.body255 ]
%vec.phi265 = phi <2 x double> [ %119, %middle.block235 ], [ %123, %vector.body255 ]
%offset.idx261 = or i64 %index257, 1
%120 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 1, i64 %offset.idx261
%121 = bitcast double* %120 to <2 x double>*
%wide.load266 = load <2 x double>, <2 x double>* %121, align 8, !alias.scope !6, !noalias !9
%122 = fmul fast <2 x double> %wide.load266, %wide.load266
%123 = fadd fast <2 x double> %122, %vec.phi265
%index.next258 = add i64 %index257, 2
%124 = icmp eq i64 %index257, 0
br i1 %124, label %middle.block253, label %vector.body255, !llvm.loop !21
middle.block253: ; preds = %vector.body255
%rdx.shuf267 = shufflevector <2 x double> %123, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%bin.rdx268 = fadd fast <2 x double> %123, %rdx.shuf267
%125 = extractelement <2 x double> %bin.rdx268, i32 0
%126 = getelementptr inbounds i8, i8* %72, i64 32
%127 = bitcast i8* %126 to double*
store double %125, double* %127, align 8, !alias.scope !9, !noalias !14
%128 = fmul fast double %62, %54
%129 = insertelement <2 x double> <double undef, double 0.000000e+00>, double %128, i32 0
br label %vector.body272
vector.body272: ; preds = %vector.body272, %middle.block253
%index274 = phi i64 [ 0, %middle.block253 ], [ %index.next275, %vector.body272 ]
%vec.phi282 = phi <2 x double> [ %129, %middle.block253 ], [ %135, %vector.body272 ]
%offset.idx278 = or i64 %index274, 1
%130 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 1, i64 %offset.idx278
%131 = bitcast double* %130 to <2 x double>*
%wide.load283 = load <2 x double>, <2 x double>* %131, align 8, !alias.scope !6, !noalias !9
%132 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 2, i64 %offset.idx278
%133 = bitcast double* %132 to <2 x double>*
%wide.load284 = load <2 x double>, <2 x double>* %133, align 8, !alias.scope !6, !noalias !9
%134 = fmul fast <2 x double> %wide.load284, %wide.load283
%135 = fadd fast <2 x double> %134, %vec.phi282
%index.next275 = add i64 %index274, 2
%136 = icmp eq i64 %index274, 0
br i1 %136, label %middle.block270, label %vector.body272, !llvm.loop !22
middle.block270: ; preds = %vector.body272
%rdx.shuf285 = shufflevector <2 x double> %135, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%bin.rdx286 = fadd fast <2 x double> %135, %rdx.shuf285
%137 = extractelement <2 x double> %bin.rdx286, i32 0
%138 = getelementptr inbounds i8, i8* %72, i64 40
%139 = bitcast i8* %138 to double*
store double %137, double* %139, align 8, !alias.scope !9, !noalias !14
%140 = fmul fast double %23, %62
%141 = insertelement <2 x double> <double undef, double 0.000000e+00>, double %140, i32 0
br label %vector.body290
vector.body290: ; preds = %vector.body290, %middle.block270
%index292 = phi i64 [ 0, %middle.block270 ], [ %index.next293, %vector.body290 ]
%vec.phi300 = phi <2 x double> [ %141, %middle.block270 ], [ %147, %vector.body290 ]
%offset.idx296 = or i64 %index292, 1
%142 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 2, i64 %offset.idx296
%143 = bitcast double* %142 to <2 x double>*
%wide.load301 = load <2 x double>, <2 x double>* %143, align 8, !alias.scope !6, !noalias !9
%144 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 0, i64 %offset.idx296
%145 = bitcast double* %144 to <2 x double>*
%wide.load302 = load <2 x double>, <2 x double>* %145, align 8, !alias.scope !6, !noalias !9
%146 = fmul fast <2 x double> %wide.load302, %wide.load301
%147 = fadd fast <2 x double> %146, %vec.phi300
%index.next293 = add i64 %index292, 2
%148 = icmp eq i64 %index292, 0
br i1 %148, label %middle.block288, label %vector.body290, !llvm.loop !23
middle.block288: ; preds = %vector.body290
%rdx.shuf303 = shufflevector <2 x double> %147, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%bin.rdx304 = fadd fast <2 x double> %147, %rdx.shuf303
%149 = extractelement <2 x double> %bin.rdx304, i32 0
%150 = getelementptr inbounds i8, i8* %72, i64 48
%151 = bitcast i8* %150 to double*
store double %149, double* %151, align 8, !alias.scope !9, !noalias !14
%152 = fmul fast double %54, %62
%153 = insertelement <2 x double> <double undef, double 0.000000e+00>, double %152, i32 0
br label %vector.body308
vector.body308: ; preds = %vector.body308, %middle.block288
%index310 = phi i64 [ 0, %middle.block288 ], [ %index.next311, %vector.body308 ]
%vec.phi318 = phi <2 x double> [ %153, %middle.block288 ], [ %159, %vector.body308 ]
%offset.idx314 = or i64 %index310, 1
%154 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 2, i64 %offset.idx314
%155 = bitcast double* %154 to <2 x double>*
%wide.load319 = load <2 x double>, <2 x double>* %155, align 8, !alias.scope !6, !noalias !9
%156 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 1, i64 %offset.idx314
%157 = bitcast double* %156 to <2 x double>*
%wide.load320 = load <2 x double>, <2 x double>* %157, align 8, !alias.scope !6, !noalias !9
%158 = fmul fast <2 x double> %wide.load320, %wide.load319
%159 = fadd fast <2 x double> %158, %vec.phi318
%index.next311 = add i64 %index310, 2
%160 = icmp eq i64 %index310, 0
br i1 %160, label %middle.block306, label %vector.body308, !llvm.loop !24
middle.block306: ; preds = %vector.body308
%rdx.shuf321 = shufflevector <2 x double> %159, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%bin.rdx322 = fadd fast <2 x double> %159, %rdx.shuf321
%161 = extractelement <2 x double> %bin.rdx322, i32 0
%162 = getelementptr inbounds i8, i8* %72, i64 56
%163 = bitcast i8* %162 to double*
store double %161, double* %163, align 8, !alias.scope !9, !noalias !14
%164 = fmul fast double %62, %62
%165 = insertelement <2 x double> <double undef, double 0.000000e+00>, double %164, i32 0
br label %vector.body326
vector.body326: ; preds = %vector.body326, %middle.block306
%index328 = phi i64 [ 0, %middle.block306 ], [ %index.next329, %vector.body326 ]
%vec.phi336 = phi <2 x double> [ %165, %middle.block306 ], [ %169, %vector.body326 ]
%offset.idx332 = or i64 %index328, 1
%166 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %fusion.3, i64 0, i64 2, i64 %offset.idx332
%167 = bitcast double* %166 to <2 x double>*
%wide.load337 = load <2 x double>, <2 x double>* %167, align 8, !alias.scope !6, !noalias !9
%168 = fmul fast <2 x double> %wide.load337, %wide.load337
%169 = fadd fast <2 x double> %168, %vec.phi336
%index.next329 = add i64 %index328, 2
%170 = icmp eq i64 %index328, 0
br i1 %170, label %middle.block324, label %vector.body326, !llvm.loop !25
middle.block324: ; preds = %vector.body326
%rdx.shuf338 = shufflevector <2 x double> %169, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%bin.rdx339 = fadd fast <2 x double> %169, %rdx.shuf338
%171 = extractelement <2 x double> %bin.rdx339, i32 0
%172 = getelementptr inbounds i8, i8* %72, i64 64
%173 = bitcast i8* %172 to double*
store double %171, double* %173, align 8, !alias.scope !9, !noalias !14
%174 = getelementptr inbounds i8*, i8** %buffer_table, i64 3
%175 = bitcast i8** %174 to [1 x [2 x [2 x double]]]**
%176 = load [1 x [2 x [2 x double]]]*, [1 x [2 x [2 x double]]]** %175, align 8, !invariant.load !0, !dereferenceable !26, !align !2
%177 = getelementptr inbounds i8*, i8** %buffer_table, i64 12
%178 = bitcast i8** %177 to [1 x [2 x float]]**
%179 = load [1 x [2 x float]]*, [1 x [2 x float]]** %178, align 8, !invariant.load !0, !dereferenceable !2, !align !2
%180 = getelementptr inbounds i8*, i8** %buffer_table, i64 8
%181 = bitcast i8** %180 to [1 x [2 x double]]**
%182 = load [1 x [2 x double]]*, [1 x [2 x double]]** %181, align 8, !invariant.load !0, !dereferenceable !27, !align !2
%183 = getelementptr inbounds [1 x [2 x float]], [1 x [2 x float]]* %179, i64 0, i64 0, i64 0
%184 = load float, float* %183, align 8, !invariant.load !0, !noalias !28
%185 = fmul fast float %184, 2.000000e+00
%186 = fadd fast float %185, -1.000000e+00
%187 = fcmp fast one float %186, 0.000000e+00
%188 = uitofp i1 %187 to float
%189 = tail call fast float @llvm.copysign.f32(float %188, float %186)
%190 = fpext float %189 to double
%191 = getelementptr inbounds [1 x [2 x double]], [1 x [2 x double]]* %182, i64 0, i64 0, i64 0
%192 = load double, double* %191, align 8, !invariant.load !0, !noalias !28
%193 = fmul fast double %192, 0x3FDA827999FCEF34
%194 = fadd fast double %193, 1.000000e+00
%195 = fmul fast double %194, %190
%196 = bitcast i8* %10 to double*
store double %195, double* %196, align 8, !alias.scope !28, !noalias !30
%197 = getelementptr inbounds [1 x [2 x float]], [1 x [2 x float]]* %179, i64 0, i64 0, i64 1
%198 = load float, float* %197, align 4, !invariant.load !0, !noalias !28
%199 = fmul fast float %198, 2.000000e+00
%200 = fadd fast float %199, -1.000000e+00
%201 = fcmp fast one float %200, 0.000000e+00
%202 = uitofp i1 %201 to float
%203 = tail call fast float @llvm.copysign.f32(float %202, float %200)
%204 = fpext float %203 to double
%205 = getelementptr inbounds [1 x [2 x double]], [1 x [2 x double]]* %182, i64 0, i64 0, i64 1
%206 = load double, double* %205, align 8, !invariant.load !0, !noalias !28
%207 = fmul fast double %206, 0x3FDA827999FCEF34
%208 = fadd fast double %207, 1.000000e+00
%209 = fmul fast double %208, %204
%210 = getelementptr inbounds i8, i8* %10, i64 8
%211 = bitcast i8* %210 to double*
store double 0.000000e+00, double* %211, align 8, !alias.scope !28, !noalias !30
%212 = getelementptr inbounds [1 x [2 x [2 x double]]], [1 x [2 x [2 x double]]]* %176, i64 0, i64 0, i64 1, i64 0
%213 = load double, double* %212, align 8, !invariant.load !0, !noalias !28
%214 = getelementptr inbounds i8, i8* %10, i64 16
%215 = bitcast i8* %214 to double*
store double %213, double* %215, align 8, !alias.scope !28, !noalias !30
%216 = getelementptr inbounds i8, i8* %10, i64 24
%217 = bitcast i8* %216 to double*
store double %209, double* %217, align 8, !alias.scope !28, !noalias !30
%218 = getelementptr inbounds i8*, i8** %buffer_table, i64 22
%219 = load i8*, i8** %218, align 8, !invariant.load !0, !dereferenceable !31, !align !27
%220 = getelementptr inbounds i8, i8* %219, i64 864
%221 = fmul fast double %195, %195
%.phi.trans.insert148 = getelementptr inbounds i8, i8* %10, i64 8
%222 = bitcast i8* %.phi.trans.insert148 to double*
%.pre149 = load double, double* %222, align 8, !alias.scope !28, !noalias !30
%223 = fmul fast double %.pre149, %.pre149
%224 = fadd fast double %223, %221
%225 = bitcast i8* %220 to double*
store double %224, double* %225, align 16, !alias.scope !30, !noalias !32
%226 = fmul fast double %213, %195
%.phi.trans.insert150 = getelementptr inbounds i8, i8* %10, i64 8
%227 = bitcast i8* %.phi.trans.insert150 to double*
%.pre151 = load double, double* %227, align 8, !alias.scope !28, !noalias !30
%.phi.trans.insert152 = getelementptr inbounds i8, i8* %10, i64 24
%228 = bitcast i8* %.phi.trans.insert152 to double*
%.pre153 = load double, double* %228, align 8, !alias.scope !28, !noalias !30
%229 = fmul fast double %.pre153, %.pre151
%230 = fadd fast double %229, %226
%231 = getelementptr inbounds i8, i8* %219, i64 872
%232 = bitcast i8* %231 to double*
store double %230, double* %232, align 8, !alias.scope !30, !noalias !32
%233 = fmul fast double %195, %213
%.phi.trans.insert154 = getelementptr inbounds i8, i8* %10, i64 24
%234 = bitcast i8* %.phi.trans.insert154 to double*
%.pre155 = load double, double* %234, align 8, !alias.scope !28, !noalias !30
%.phi.trans.insert156 = getelementptr inbounds i8, i8* %10, i64 8
%235 = bitcast i8* %.phi.trans.insert156 to double*
%.pre157 = load double, double* %235, align 8, !alias.scope !28, !noalias !30
%236 = fmul fast double %.pre157, %.pre155
%237 = fadd fast double %236, %233
%238 = getelementptr inbounds i8, i8* %219, i64 880
%239 = bitcast i8* %238 to double*
store double %237, double* %239, align 16, !alias.scope !30, !noalias !32
%240 = fmul fast double %213, %213
%.phi.trans.insert158 = getelementptr inbounds i8, i8* %10, i64 24
%241 = bitcast i8* %.phi.trans.insert158 to double*
%.pre159 = load double, double* %241, align 8, !alias.scope !28, !noalias !30
%242 = fmul fast double %.pre159, %.pre159
%243 = fadd fast double %242, %240
%244 = getelementptr inbounds i8, i8* %219, i64 888
%245 = bitcast i8* %244 to double*
store double %243, double* %245, align 8, !alias.scope !30, !noalias !32
%246 = getelementptr inbounds i8*, i8** %buffer_table, i64 10
%247 = bitcast i8** %246 to [3 x [1 x float]]**
%248 = load [3 x [1 x float]]*, [3 x [1 x float]]** %247, align 8, !invariant.load !0, !dereferenceable !1, !align !2
%249 = getelementptr inbounds i8*, i8** %buffer_table, i64 6
%250 = bitcast i8** %249 to [3 x [1 x double]]**
%251 = load [3 x [1 x double]]*, [3 x [1 x double]]** %250, align 8, !invariant.load !0, !dereferenceable !3, !align !2
%252 = getelementptr inbounds [3 x [1 x float]], [3 x [1 x float]]* %248, i64 0, i64 0, i64 0
%253 = load float, float* %252, align 8, !invariant.load !0, !noalias !34
%254 = fmul fast float %253, 2.000000e+00
%255 = fadd fast float %254, -1.000000e+00
%256 = fcmp fast one float %255, 0.000000e+00
%257 = uitofp i1 %256 to float
%258 = tail call fast float @llvm.copysign.f32(float %257, float %255)
%259 = fpext float %258 to double
%260 = getelementptr inbounds [3 x [1 x double]], [3 x [1 x double]]* %251, i64 0, i64 0, i64 0
%261 = load double, double* %260, align 8, !invariant.load !0, !noalias !34
%262 = fmul fast double %261, 0x3FDA827999FCEF34
%263 = fadd fast double %262, 1.000000e+00
%264 = fmul fast double %263, %259
%265 = fmul fast double %264, %264
%266 = insertelement <4 x double> undef, double %265, i32 0
%267 = shufflevector <4 x double> %266, <4 x double> undef, <4 x i32> zeroinitializer
%268 = bitcast i8* %72 to <2 x double>*
%269 = load <2 x double>, <2 x double>* %268, align 8, !alias.scope !9, !noalias !14
%270 = bitcast i8* %220 to <2 x double>*
%271 = load <2 x double>, <2 x double>* %270, align 16, !alias.scope !30, !noalias !32
%272 = fmul fast <2 x double> %269, %271
%273 = shufflevector <2 x double> %272, <2 x double> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
%274 = fmul fast <4 x double> %267, %273
%275 = shufflevector <4 x double> %274, <4 x double> <double undef, double 0.000000e+00, double 0.000000e+00, double 0.000000e+00>, <4 x i32> <i32 0, i32 5, i32 6, i32 7>
%276 = bitcast i8* %219 to <4 x double>*
store <4 x double> %275, <4 x double>* %276, align 16, !alias.scope !38, !noalias !39
%277 = getelementptr inbounds i8, i8* %219, i64 32
%278 = bitcast i8* %277 to double*
store double 0.000000e+00, double* %278, align 16, !alias.scope !38, !noalias !39
%279 = getelementptr inbounds i8, i8* %219, i64 40
%280 = bitcast i8* %279 to double*
store double 0.000000e+00, double* %280, align 8, !alias.scope !38, !noalias !39
%281 = getelementptr inbounds i8, i8* %72, i64 24
%282 = getelementptr inbounds i8, i8* %219, i64 48
%283 = bitcast i8* %281 to <2 x double>*
%284 = load <2 x double>, <2 x double>* %283, align 8, !alias.scope !9, !noalias !14
%285 = bitcast i8* %220 to <2 x double>*
%286 = load <2 x double>, <2 x double>* %285, align 16, !alias.scope !30, !noalias !32
%shuffle345.1 = shufflevector <2 x double> %286, <2 x double> undef, <4 x i32> <i32 undef, i32 0, i32 undef, i32 undef>
%287 = shufflevector <2 x double> %284, <2 x double> undef, <4 x i32> <i32 undef, i32 1, i32 undef, i32 undef>
%288 = fmul fast <4 x double> %287, %shuffle345.1
%289 = fmul fast <4 x double> %267, %288
%290 = shufflevector <4 x double> <double 0.000000e+00, double undef, double 0.000000e+00, double 0.000000e+00>, <4 x double> %289, <4 x i32> <i32 0, i32 5, i32 2, i32 3>
%291 = bitcast i8* %282 to <4 x double>*
store <4 x double> %290, <4 x double>* %291, align 16, !alias.scope !38, !noalias !39
%292 = getelementptr inbounds i8, i8* %219, i64 80
%293 = bitcast i8* %292 to double*
store double 0.000000e+00, double* %293, align 16, !alias.scope !38, !noalias !39
%294 = getelementptr inbounds i8, i8* %219, i64 88
%295 = bitcast i8* %294 to double*
store double 0.000000e+00, double* %295, align 8, !alias.scope !38, !noalias !39
%296 = getelementptr inbounds i8, i8* %219, i64 96
%297 = getelementptr inbounds i8, i8* %72, i64 64
%298 = bitcast i8* %297 to double*
%299 = load double, double* %298, align 8, !alias.scope !9, !noalias !14
%300 = bitcast i8* %220 to <2 x double>*
%301 = load <2 x double>, <2 x double>* %300, align 16, !alias.scope !30, !noalias !32
%shuffle345.2 = shufflevector <2 x double> %301, <2 x double> undef, <4 x i32> <i32 undef, i32 undef, i32 0, i32 undef>
%302 = insertelement <4 x double> undef, double %299, i32 2
%303 = fmul fast <4 x double> %302, %shuffle345.2
%304 = fmul fast <4 x double> %267, %303
%305 = shufflevector <4 x double> <double 0.000000e+00, double 0.000000e+00, double undef, double 0.000000e+00>, <4 x double> %304, <4 x i32> <i32 0, i32 1, i32 6, i32 3>
%306 = bitcast i8* %296 to <4 x double>*
store <4 x double> %305, <4 x double>* %306, align 16, !alias.scope !38, !noalias !39
%307 = getelementptr inbounds i8, i8* %219, i64 128
%308 = bitcast i8* %307 to double*
store double 0.000000e+00, double* %308, align 16, !alias.scope !38, !noalias !39
%309 = getelementptr inbounds i8, i8* %219, i64 136
%310 = bitcast i8* %309 to double*
store double 0.000000e+00, double* %310, align 8, !alias.scope !38, !noalias !39
%311 = getelementptr inbounds i8, i8* %219, i64 880
%312 = getelementptr inbounds i8, i8* %219, i64 144
%313 = bitcast i8* %72 to <2 x double>*
%314 = load <2 x double>, <2 x double>* %313, align 8, !alias.scope !9, !noalias !14
%315 = bitcast i8* %311 to <2 x double>*
%316 = load <2 x double>, <2 x double>* %315, align 16, !alias.scope !30, !noalias !32
%shuffle345.3 = shufflevector <2 x double> %316, <2 x double> undef, <4 x i32> <i32 undef, i32 undef, i32 undef, i32 1>
%317 = shufflevector <2 x double> %314, <2 x double> undef, <4 x i32> <i32 undef, i32 undef, i32 undef, i32 0>
%318 = fmul fast <4 x double> %317, %shuffle345.3
%319 = fmul fast <4 x double> %267, %318
%320 = shufflevector <4 x double> <double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double undef>, <4 x double> %319, <4 x i32> <i32 0, i32 1, i32 2, i32 7>
%321 = bitcast i8* %312 to <4 x double>*
store <4 x double> %320, <4 x double>* %321, align 16, !alias.scope !38, !noalias !39
%322 = getelementptr inbounds i8, i8* %219, i64 176
%323 = bitcast i8* %322 to double*
store double 0.000000e+00, double* %323, align 16, !alias.scope !38, !noalias !39
%324 = getelementptr inbounds i8, i8* %219, i64 184
%325 = bitcast i8* %324 to double*
store double 0.000000e+00, double* %325, align 8, !alias.scope !38, !noalias !39
%326 = getelementptr inbounds i8, i8* %219, i64 880
%327 = getelementptr inbounds i8, i8* %72, i64 24
%328 = getelementptr inbounds i8, i8* %219, i64 192
%329 = bitcast i8* %327 to <2 x double>*
%330 = load <2 x double>, <2 x double>* %329, align 8, !alias.scope !9, !noalias !14
%331 = bitcast i8* %326 to <2 x double>*
%332 = load <2 x double>, <2 x double>* %331, align 16, !alias.scope !30, !noalias !32
%333 = extractelement <2 x double> %330, i32 1
%334 = bitcast i8* %328 to <4 x double>*
store <4 x double> zeroinitializer, <4 x double>* %334, align 16, !alias.scope !38, !noalias !39
%335 = extractelement <2 x double> %332, i32 1
%336 = fmul fast double %333, %335
%337 = fmul fast double %265, %336
%338 = getelementptr inbounds i8, i8* %219, i64 224
%339 = bitcast i8* %338 to double*
store double %337, double* %339, align 16, !alias.scope !38, !noalias !39
%340 = getelementptr inbounds i8, i8* %219, i64 232
%341 = bitcast i8* %340 to double*
store double 0.000000e+00, double* %341, align 8, !alias.scope !38, !noalias !39
%342 = getelementptr inbounds i8, i8* %219, i64 880
%343 = getelementptr inbounds i8, i8* %219, i64 240
%344 = getelementptr inbounds i8, i8* %72, i64 64
%345 = bitcast i8* %344 to double*
%346 = load double, double* %345, align 8, !alias.scope !9, !noalias !14
%347 = bitcast i8* %342 to <2 x double>*
%348 = load <2 x double>, <2 x double>* %347, align 16, !alias.scope !30, !noalias !32
%349 = bitcast i8* %343 to <4 x double>*
store <4 x double> zeroinitializer, <4 x double>* %349, align 16, !alias.scope !38, !noalias !39
%350 = extractelement <2 x double> %348, i32 1
%351 = getelementptr inbounds i8, i8* %219, i64 272
%352 = bitcast i8* %351 to double*
store double 0.000000e+00, double* %352, align 16, !alias.scope !38, !noalias !39
%353 = fmul fast double %346, %350
%354 = fmul fast double %265, %353
%355 = getelementptr inbounds i8, i8* %219, i64 280
%356 = bitcast i8* %355 to double*
store double %354, double* %356, align 8, !alias.scope !38, !noalias !39
%357 = getelementptr inbounds [3 x [1 x float]], [3 x [1 x float]]* %248, i64 0, i64 1, i64 0
%358 = load float, float* %357, align 4, !invariant.load !0, !noalias !34
%359 = fmul fast float %358, 2.000000e+00
%360 = fadd fast float %359, -1.000000e+00
%361 = fcmp fast one float %360, 0.000000e+00
%362 = uitofp i1 %361 to float
%363 = tail call fast float @llvm.copysign.f32(float %362, float %360)
%364 = fpext float %363 to double
%365 = getelementptr inbounds [3 x [1 x double]], [3 x [1 x double]]* %251, i64 0, i64 1, i64 0
%366 = load double, double* %365, align 8, !invariant.load !0, !noalias !34
%367 = fmul fast double %366, 0x3FDA827999FCEF34
%368 = fadd fast double %367, 1.000000e+00
%369 = fmul fast double %368, %364
%370 = fmul fast double %369, %369
%371 = insertelement <4 x double> undef, double %370, i32 0
%372 = shufflevector <4 x double> %371, <4 x double> undef, <4 x i32> zeroinitializer
%373 = getelementptr inbounds i8, i8* %219, i64 288
%374 = bitcast i8* %72 to <2 x double>*
%375 = load <2 x double>, <2 x double>* %374, align 8, !alias.scope !9, !noalias !14
%376 = bitcast i8* %220 to <2 x double>*
%377 = load <2 x double>, <2 x double>* %376, align 16, !alias.scope !30, !noalias !32
%378 = fmul fast <2 x double> %375, %377
%379 = shufflevector <2 x double> %378, <2 x double> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
%380 = fmul fast <4 x double> %372, %379
%381 = shufflevector <4 x double> %380, <4 x double> <double undef, double 0.000000e+00, double 0.000000e+00, double 0.000000e+00>, <4 x i32> <i32 0, i32 5, i32 6, i32 7>
%382 = bitcast i8* %373 to <4 x double>*
store <4 x double> %381, <4 x double>* %382, align 16, !alias.scope !38, !noalias !39
%383 = getelementptr inbounds i8, i8* %219, i64 320
%384 = bitcast i8* %383 to double*
store double 0.000000e+00, double* %384, align 16, !alias.scope !38, !noalias !39
%385 = getelementptr inbounds i8, i8* %219, i64 328
%386 = bitcast i8* %385 to double*
store double 0.000000e+00, double* %386, align 8, !alias.scope !38, !noalias !39
%387 = getelementptr inbounds i8, i8* %72, i64 24
%388 = getelementptr inbounds i8, i8* %219, i64 336
%389 = bitcast i8* %387 to <2 x double>*
%390 = load <2 x double>, <2 x double>* %389, align 8, !alias.scope !9, !noalias !14
%391 = bitcast i8* %220 to <2 x double>*
%392 = load <2 x double>, <2 x double>* %391, align 16, !alias.scope !30, !noalias !32
%shuffle344.1 = shufflevector <2 x double> %392, <2 x double> undef, <4 x i32> <i32 undef, i32 0, i32 undef, i32 undef>
%393 = shufflevector <2 x double> %390, <2 x double> undef, <4 x i32> <i32 undef, i32 1, i32 undef, i32 undef>
%394 = fmul fast <4 x double> %393, %shuffle344.1
%395 = fmul fast <4 x double> %372, %394
%396 = shufflevector <4 x double> <double 0.000000e+00, double undef, double 0.000000e+00, double 0.000000e+00>, <4 x double> %395, <4 x i32> <i32 0, i32 5, i32 2, i32 3>
%397 = bitcast i8* %388 to <4 x double>*
store <4 x double> %396, <4 x double>* %397, align 16, !alias.scope !38, !noalias !39
%398 = getelementptr inbounds i8, i8* %219, i64 368
%399 = bitcast i8* %398 to double*
store double 0.000000e+00, double* %399, align 16, !alias.scope !38, !noalias !39
%400 = getelementptr inbounds i8, i8* %219, i64 376
%401 = bitcast i8* %400 to double*
store double 0.000000e+00, double* %401, align 8, !alias.scope !38, !noalias !39
%402 = getelementptr inbounds i8, i8* %219, i64 384
%403 = getelementptr inbounds i8, i8* %72, i64 64
%404 = bitcast i8* %403 to double*
%405 = load double, double* %404, align 8, !alias.scope !9, !noalias !14
%406 = bitcast i8* %220 to <2 x double>*
%407 = load <2 x double>, <2 x double>* %406, align 16, !alias.scope !30, !noalias !32
%shuffle344.2 = shufflevector <2 x double> %407, <2 x double> undef, <4 x i32> <i32 undef, i32 undef, i32 0, i32 undef>
%408 = insertelement <4 x double> undef, double %405, i32 2
%409 = fmul fast <4 x double> %408, %shuffle344.2
%410 = fmul fast <4 x double> %372, %409
%411 = shufflevector <4 x double> <double 0.000000e+00, double 0.000000e+00, double undef, double 0.000000e+00>, <4 x double> %410, <4 x i32> <i32 0, i32 1, i32 6, i32 3>
%412 = bitcast i8* %402 to <4 x double>*
store <4 x double> %411, <4 x double>* %412, align 16, !alias.scope !38, !noalias !39
%413 = getelementptr inbounds i8, i8* %219, i64 416
%414 = bitcast i8* %413 to double*
store double 0.000000e+00, double* %414, align 16, !alias.scope !38, !noalias !39
%415 = getelementptr inbounds i8, i8* %219, i64 424
%416 = bitcast i8* %415 to double*
store double 0.000000e+00, double* %416, align 8, !alias.scope !38, !noalias !39
%417 = getelementptr inbounds i8, i8* %219, i64 880
%418 = getelementptr inbounds i8, i8* %219, i64 432
%419 = bitcast i8* %72 to <2 x double>*
%420 = load <2 x double>, <2 x double>* %419, align 8, !alias.scope !9, !noalias !14
%421 = bitcast i8* %417 to <2 x double>*
%422 = load <2 x double>, <2 x double>* %421, align 16, !alias.scope !30, !noalias !32
%shuffle344.3 = shufflevector <2 x double> %422, <2 x double> undef, <4 x i32> <i32 undef, i32 undef, i32 undef, i32 1>
%423 = shufflevector <2 x double> %420, <2 x double> undef, <4 x i32> <i32 undef, i32 undef, i32 undef, i32 0>
%424 = fmul fast <4 x double> %423, %shuffle344.3
%425 = fmul fast <4 x double> %372, %424
%426 = shufflevector <4 x double> <double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double undef>, <4 x double> %425, <4 x i32> <i32 0, i32 1, i32 2, i32 7>
%427 = bitcast i8* %418 to <4 x double>*
store <4 x double> %426, <4 x double>* %427, align 16, !alias.scope !38, !noalias !39
%428 = getelementptr inbounds i8, i8* %219, i64 464
%429 = bitcast i8* %428 to double*
store double 0.000000e+00, double* %429, align 16, !alias.scope !38, !noalias !39
%430 = getelementptr inbounds i8, i8* %219, i64 472
%431 = bitcast i8* %430 to double*
store double 0.000000e+00, double* %431, align 8, !alias.scope !38, !noalias !39
%432 = getelementptr inbounds i8, i8* %219, i64 880
%433 = getelementptr inbounds i8, i8* %72, i64 24
%434 = getelementptr inbounds i8, i8* %219, i64 480
%435 = bitcast i8* %433 to <2 x double>*
%436 = load <2 x double>, <2 x double>* %435, align 8, !alias.scope !9, !noalias !14
%437 = bitcast i8* %432 to <2 x double>*
%438 = load <2 x double>, <2 x double>* %437, align 16, !alias.scope !30, !noalias !32
%439 = extractelement <2 x double> %436, i32 1
%440 = bitcast i8* %434 to <4 x double>*
store <4 x double> zeroinitializer, <4 x double>* %440, align 16, !alias.scope !38, !noalias !39
%441 = extractelement <2 x double> %438, i32 1
%442 = fmul fast double %439, %441
%443 = fmul fast double %370, %442
%444 = getelementptr inbounds i8, i8* %219, i64 512
%445 = bitcast i8* %444 to double*
store double %443, double* %445, align 16, !alias.scope !38, !noalias !39
%446 = getelementptr inbounds i8, i8* %219, i64 520
%447 = bitcast i8* %446 to double*
store double 0.000000e+00, double* %447, align 8, !alias.scope !38, !noalias !39
%448 = getelementptr inbounds i8, i8* %219, i64 880
%449 = getelementptr inbounds i8, i8* %219, i64 528
%450 = getelementptr inbounds i8, i8* %72, i64 64
%451 = bitcast i8* %450 to double*
%452 = load double, double* %451, align 8, !alias.scope !9, !noalias !14
%453 = bitcast i8* %448 to <2 x double>*
%454 = load <2 x double>, <2 x double>* %453, align 16, !alias.scope !30, !noalias !32
%455 = bitcast i8* %449 to <4 x double>*
store <4 x double> zeroinitializer, <4 x double>* %455, align 16, !alias.scope !38, !noalias !39
%456 = extractelement <2 x double> %454, i32 1
%457 = getelementptr inbounds i8, i8* %219, i64 560
%458 = bitcast i8* %457 to double*
store double 0.000000e+00, double* %458, align 16, !alias.scope !38, !noalias !39
%459 = fmul fast double %452, %456
%460 = fmul fast double %370, %459
%461 = getelementptr inbounds i8, i8* %219, i64 568
%462 = bitcast i8* %461 to double*
store double %460, double* %462, align 8, !alias.scope !38, !noalias !39
%463 = getelementptr inbounds [3 x [1 x float]], [3 x [1 x float]]* %248, i64 0, i64 2, i64 0
%464 = load float, float* %463, align 8, !invariant.load !0, !noalias !34
%465 = fmul fast float %464, 2.000000e+00
%466 = fadd fast float %465, -1.000000e+00
%467 = fcmp fast one float %466, 0.000000e+00
%468 = uitofp i1 %467 to float
%469 = tail call fast float @llvm.copysign.f32(float %468, float %466)
%470 = fpext float %469 to double
%471 = getelementptr inbounds [3 x [1 x double]], [3 x [1 x double]]* %251, i64 0, i64 2, i64 0
%472 = load double, double* %471, align 8, !invariant.load !0, !noalias !34
%473 = fmul fast double %472, 0x3FDA827999FCEF34
%474 = fadd fast double %473, 1.000000e+00
%475 = fmul fast double %474, %470
%476 = fmul fast double %475, %475
%477 = insertelement <4 x double> undef, double %476, i32 0
%478 = shufflevector <4 x double> %477, <4 x double> undef, <4 x i32> zeroinitializer
%479 = getelementptr inbounds i8, i8* %219, i64 576
%480 = bitcast i8* %72 to <2 x double>*
%481 = load <2 x double>, <2 x double>* %480, align 8, !alias.scope !9, !noalias !14
%482 = bitcast i8* %220 to <2 x double>*
%483 = load <2 x double>, <2 x double>* %482, align 16, !alias.scope !30, !noalias !32
%484 = fmul fast <2 x double> %481, %483
%485 = shufflevector <2 x double> %484, <2 x double> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
%486 = fmul fast <4 x double> %478, %485
%487 = shufflevector <4 x double> %486, <4 x double> <double undef, double 0.000000e+00, double 0.000000e+00, double 0.000000e+00>, <4 x i32> <i32 0, i32 5, i32 6, i32 7>
%488 = bitcast i8* %479 to <4 x double>*
store <4 x double> %487, <4 x double>* %488, align 16, !alias.scope !38, !noalias !39
%489 = getelementptr inbounds i8, i8* %219, i64 608
%490 = bitcast i8* %489 to double*
store double 0.000000e+00, double* %490, align 16, !alias.scope !38, !noalias !39
%491 = getelementptr inbounds i8, i8* %219, i64 616
%492 = bitcast i8* %491 to double*
store double 0.000000e+00, double* %492, align 8, !alias.scope !38, !noalias !39
%493 = getelementptr inbounds i8, i8* %72, i64 24
%494 = getelementptr inbounds i8, i8* %219, i64 624
%495 = bitcast i8* %493 to <2 x double>*
%496 = load <2 x double>, <2 x double>* %495, align 8, !alias.scope !9, !noalias !14
%497 = bitcast i8* %220 to <2 x double>*
%498 = load <2 x double>, <2 x double>* %497, align 16, !alias.scope !30, !noalias !32
%shuffle343.1 = shufflevector <2 x double> %498, <2 x double> undef, <4 x i32> <i32 undef, i32 0, i32 undef, i32 undef>
%499 = shufflevector <2 x double> %496, <2 x double> undef, <4 x i32> <i32 undef, i32 1, i32 undef, i32 undef>
%500 = fmul fast <4 x double> %499, %shuffle343.1
%501 = fmul fast <4 x double> %478, %500
%502 = shufflevector <4 x double> <double 0.000000e+00, double undef, double 0.000000e+00, double 0.000000e+00>, <4 x double> %501, <4 x i32> <i32 0, i32 5, i32 2, i32 3>
%503 = bitcast i8* %494 to <4 x double>*
store <4 x double> %502, <4 x double>* %503, align 16, !alias.scope !38, !noalias !39
%504 = getelementptr inbounds i8, i8* %219, i64 656
%505 = bitcast i8* %504 to double*
store double 0.000000e+00, double* %505, align 16, !alias.scope !38, !noalias !39
%506 = getelementptr inbounds i8, i8* %219, i64 664
%507 = bitcast i8* %506 to double*
store double 0.000000e+00, double* %507, align 8, !alias.scope !38, !noalias !39
%508 = getelementptr inbounds i8, i8* %219, i64 672
%509 = getelementptr inbounds i8, i8* %72, i64 64
%510 = bitcast i8* %509 to double*
%511 = load double, double* %510, align 8, !alias.scope !9, !noalias !14
%512 = bitcast i8* %220 to <2 x double>*
%513 = load <2 x double>, <2 x double>* %512, align 16, !alias.scope !30, !noalias !32
%shuffle343.2 = shufflevector <2 x double> %513, <2 x double> undef, <4 x i32> <i32 undef, i32 undef, i32 0, i32 undef>
%514 = insertelement <4 x double> undef, double %511, i32 2
%515 = fmul fast <4 x double> %514, %shuffle343.2
%516 = fmul fast <4 x double> %478, %515
%517 = shufflevector <4 x double> <double 0.000000e+00, double 0.000000e+00, double undef, double 0.000000e+00>, <4 x double> %516, <4 x i32> <i32 0, i32 1, i32 6, i32 3>
%518 = bitcast i8* %508 to <4 x double>*
store <4 x double> %517, <4 x double>* %518, align 16, !alias.scope !38, !noalias !39
%519 = getelementptr inbounds i8, i8* %219, i64 704
%520 = bitcast i8* %519 to double*
store double 0.000000e+00, double* %520, align 16, !alias.scope !38, !noalias !39
%521 = getelementptr inbounds i8, i8* %219, i64 712
%522 = bitcast i8* %521 to double*
store double 0.000000e+00, double* %522, align 8, !alias.scope !38, !noalias !39
%523 = getelementptr inbounds i8, i8* %219, i64 880
%524 = getelementptr inbounds i8, i8* %219, i64 720
%525 = bitcast i8* %72 to <2 x double>*
%526 = load <2 x double>, <2 x double>* %525, align 8, !alias.scope !9, !noalias !14
%527 = bitcast i8* %523 to <2 x double>*
%528 = load <2 x double>, <2 x double>* %527, align 16, !alias.scope !30, !noalias !32
%shuffle343.3 = shufflevector <2 x double> %528, <2 x double> undef, <4 x i32> <i32 undef, i32 undef, i32 undef, i32 1>
%529 = shufflevector <2 x double> %526, <2 x double> undef, <4 x i32> <i32 undef, i32 undef, i32 undef, i32 0>
%530 = fmul fast <4 x double> %529, %shuffle343.3
%531 = fmul fast <4 x double> %478, %530
%532 = shufflevector <4 x double> <double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double undef>, <4 x double> %531, <4 x i32> <i32 0, i32 1, i32 2, i32 7>
%533 = bitcast i8* %524 to <4 x double>*
store <4 x double> %532, <4 x double>* %533, align 16, !alias.scope !38, !noalias !39
%534 = getelementptr inbounds i8, i8* %219, i64 752
%535 = bitcast i8* %534 to double*
store double 0.000000e+00, double* %535, align 16, !alias.scope !38, !noalias !39
%536 = getelementptr inbounds i8, i8* %219, i64 760
%537 = bitcast i8* %536 to double*
store double 0.000000e+00, double* %537, align 8, !alias.scope !38, !noalias !39
%538 = getelementptr inbounds i8, i8* %219, i64 880
%539 = getelementptr inbounds i8, i8* %72, i64 24
%540 = getelementptr inbounds i8, i8* %219, i64 768
%541 = bitcast i8* %539 to <2 x double>*
%542 = load <2 x double>, <2 x double>* %541, align 8, !alias.scope !9, !noalias !14
%543 = bitcast i8* %538 to <2 x double>*
%544 = load <2 x double>, <2 x double>* %543, align 16, !alias.scope !30, !noalias !32
%545 = extractelement <2 x double> %542, i32 1
%546 = bitcast i8* %540 to <4 x double>*
store <4 x double> zeroinitializer, <4 x double>* %546, align 16, !alias.scope !38, !noalias !39
%547 = extractelement <2 x double> %544, i32 1
%548 = fmul fast double %545, %547
%549 = fmul fast double %476, %548
%550 = getelementptr inbounds i8, i8* %219, i64 800
%551 = bitcast i8* %550 to double*
store double %549, double* %551, align 16, !alias.scope !38, !noalias !39
%552 = getelementptr inbounds i8, i8* %219, i64 808
%553 = bitcast i8* %552 to double*
store double 0.000000e+00, double* %553, align 8, !alias.scope !38, !noalias !39
%554 = getelementptr inbounds i8, i8* %219, i64 880
%555 = getelementptr inbounds i8, i8* %219, i64 816
%556 = getelementptr inbounds i8, i8* %72, i64 64
%557 = bitcast i8* %556 to double*
%558 = load double, double* %557, align 8, !alias.scope !9, !noalias !14
%559 = bitcast i8* %554 to <2 x double>*
%560 = load <2 x double>, <2 x double>* %559, align 16, !alias.scope !30, !noalias !32
%561 = bitcast i8* %555 to <4 x double>*
store <4 x double> zeroinitializer, <4 x double>* %561, align 16, !alias.scope !38, !noalias !39
%562 = extractelement <2 x double> %560, i32 1
%563 = getelementptr inbounds i8, i8* %219, i64 848
%564 = bitcast i8* %563 to double*
store double 0.000000e+00, double* %564, align 16, !alias.scope !38, !noalias !39
%565 = fmul fast double %558, %562
%566 = fmul fast double %476, %565
%567 = getelementptr inbounds i8, i8* %219, i64 856
%568 = bitcast i8* %567 to double*
store double %566, double* %568, align 8, !alias.scope !38, !noalias !39
%569 = bitcast i8* %219 to <2 x double>*
%570 = load <2 x double>, <2 x double>* %569, align 16, !alias.scope !38, !noalias !39
%571 = getelementptr inbounds i8, i8* %219, i64 16
%572 = bitcast i8* %571 to <4 x double>*
%573 = load <4 x double>, <4 x double>* %572, align 16, !alias.scope !38, !noalias !39
%574 = getelementptr inbounds i8, i8* %219, i64 48
%575 = bitcast i8* %574 to <2 x double>*
%576 = load <2 x double>, <2 x double>* %575, align 16, !alias.scope !38, !noalias !39
%577 = fadd fast <2 x double> %576, %570
%578 = getelementptr inbounds i8, i8* %219, i64 64
%579 = bitcast i8* %578 to <4 x double>*
%580 = load <4 x double>, <4 x double>* %579, align 16, !alias.scope !38, !noalias !39
%581 = fadd fast <4 x double> %580, %573
%582 = getelementptr inbounds i8, i8* %219, i64 96
%583 = bitcast i8* %582 to <2 x double>*
%584 = load <2 x double>, <2 x double>* %583, align 16, !alias.scope !38, !noalias !39
%585 = fadd fast <2 x double> %584, %577
%586 = getelementptr inbounds i8, i8* %219, i64 112
%587 = bitcast i8* %586 to <4 x double>*
%588 = load <4 x double>, <4 x double>* %587, align 16, !alias.scope !38, !noalias !39
%589 = fadd fast <4 x double> %588, %581
%590 = getelementptr inbounds i8, i8* %219, i64 144
%591 = bitcast i8* %590 to <2 x double>*
%592 = load <2 x double>, <2 x double>* %591, align 16, !alias.scope !38, !noalias !39
%593 = fadd fast <2 x double> %592, %585
%594 = getelementptr inbounds i8, i8* %219, i64 160
%595 = bitcast i8* %594 to <4 x double>*
%596 = load <4 x double>, <4 x double>* %595, align 16, !alias.scope !38, !noalias !39
%597 = fadd fast <4 x double> %596, %589
%598 = getelementptr inbounds i8, i8* %219, i64 192
%599 = bitcast i8* %598 to <2 x double>*
%600 = load <2 x double>, <2 x double>* %599, align 16, !alias.scope !38, !noalias !39
%601 = fadd fast <2 x double> %600, %593
%602 = getelementptr inbounds i8, i8* %219, i64 208
%603 = bitcast i8* %602 to <4 x double>*
%604 = load <4 x double>, <4 x double>* %603, align 16, !alias.scope !38, !noalias !39
%605 = fadd fast <4 x double> %604, %597
%606 = getelementptr inbounds i8, i8* %219, i64 240
%607 = bitcast i8* %606 to <2 x double>*
%608 = load <2 x double>, <2 x double>* %607, align 16, !alias.scope !38, !noalias !39
%609 = fadd fast <2 x double> %608, %601
%610 = getelementptr inbounds i8, i8* %219, i64 256
%611 = bitcast i8* %610 to <4 x double>*
%612 = load <4 x double>, <4 x double>* %611, align 16, !alias.scope !38, !noalias !39
%613 = fadd fast <4 x double> %612, %605
%614 = bitcast i8* %10 to <2 x double>*
store <2 x double> %609, <2 x double>* %614, align 8, !alias.scope !42, !noalias !43
%615 = getelementptr inbounds i8, i8* %10, i64 16
%616 = bitcast i8* %615 to <4 x double>*
store <4 x double> %613, <4 x double>* %616, align 8, !alias.scope !42, !noalias !43
%617 = getelementptr inbounds i8, i8* %219, i64 288
%618 = bitcast i8* %617 to <2 x double>*
%619 = load <2 x double>, <2 x double>* %618, align 16, !alias.scope !38, !noalias !39
%620 = getelementptr inbounds i8, i8* %219, i64 304
%621 = bitcast i8* %620 to <4 x double>*
%622 = load <4 x double>, <4 x double>* %621, align 16, !alias.scope !38, !noalias !39
%623 = getelementptr inbounds i8, i8* %219, i64 336
%624 = bitcast i8* %623 to <2 x double>*
%625 = load <2 x double>, <2 x double>* %624, align 16, !alias.scope !38, !noalias !39
%626 = fadd fast <2 x double> %625, %619
%627 = getelementptr inbounds i8, i8* %219, i64 352
%628 = bitcast i8* %627 to <4 x double>*
%629 = load <4 x double>, <4 x double>* %628, align 16, !alias.scope !38, !noalias !39
%630 = fadd fast <4 x double> %629, %622
%631 = getelementptr inbounds i8, i8* %219, i64 384
%632 = bitcast i8* %631 to <2 x double>*
%633 = load <2 x double>, <2 x double>* %632, align 16, !alias.scope !38, !noalias !39
%634 = fadd fast <2 x double> %633, %626
%635 = getelementptr inbounds i8, i8* %219, i64 400
%636 = bitcast i8* %635 to <4 x double>*
%637 = load <4 x double>, <4 x double>* %636, align 16, !alias.scope !38, !noalias !39
%638 = fadd fast <4 x double> %637, %630
%639 = getelementptr inbounds i8, i8* %219, i64 432
%640 = bitcast i8* %639 to <2 x double>*
%641 = load <2 x double>, <2 x double>* %640, align 16, !alias.scope !38, !noalias !39
%642 = fadd fast <2 x double> %641, %634
%643 = getelementptr inbounds i8, i8* %219, i64 448
%644 = bitcast i8* %643 to <4 x double>*
%645 = load <4 x double>, <4 x double>* %644, align 16, !alias.scope !38, !noalias !39
%646 = fadd fast <4 x double> %645, %638
%647 = getelementptr inbounds i8, i8* %219, i64 480
%648 = bitcast i8* %647 to <2 x double>*
%649 = load <2 x double>, <2 x double>* %648, align 16, !alias.scope !38, !noalias !39
%650 = fadd fast <2 x double> %649, %642
%651 = getelementptr inbounds i8, i8* %219, i64 496
%652 = bitcast i8* %651 to <4 x double>*
%653 = load <4 x double>, <4 x double>* %652, align 16, !alias.scope !38, !noalias !39
%654 = fadd fast <4 x double> %653, %646
%655 = getelementptr inbounds i8, i8* %219, i64 528
%656 = bitcast i8* %655 to <2 x double>*
%657 = load <2 x double>, <2 x double>* %656, align 16, !alias.scope !38, !noalias !39
%658 = fadd fast <2 x double> %657, %650
%659 = getelementptr inbounds i8, i8* %219, i64 544
%660 = bitcast i8* %659 to <4 x double>*
%661 = load <4 x double>, <4 x double>* %660, align 16, !alias.scope !38, !noalias !39
%662 = fadd fast <4 x double> %661, %654
%663 = getelementptr inbounds i8, i8* %10, i64 48
%664 = bitcast i8* %663 to <2 x double>*
store <2 x double> %658, <2 x double>* %664, align 8, !alias.scope !42, !noalias !43
%665 = getelementptr inbounds i8, i8* %10, i64 64
%666 = bitcast i8* %665 to <4 x double>*
store <4 x double> %662, <4 x double>* %666, align 8, !alias.scope !42, !noalias !43
%667 = getelementptr inbounds i8, i8* %219, i64 576
%668 = bitcast i8* %667 to <2 x double>*
%669 = load <2 x double>, <2 x double>* %668, align 16, !alias.scope !38, !noalias !39
%670 = getelementptr inbounds i8, i8* %219, i64 592
%671 = bitcast i8* %670 to <4 x double>*
%672 = load <4 x double>, <4 x double>* %671, align 16, !alias.scope !38, !noalias !39
%673 = getelementptr inbounds i8, i8* %219, i64 624
%674 = bitcast i8* %673 to <2 x double>*
%675 = load <2 x double>, <2 x double>* %674, align 16, !alias.scope !38, !noalias !39
%676 = fadd fast <2 x double> %675, %669
%677 = getelementptr inbounds i8, i8* %219, i64 640
%678 = bitcast i8* %677 to <4 x double>*
%679 = load <4 x double>, <4 x double>* %678, align 16, !alias.scope !38, !noalias !39
%680 = fadd fast <4 x double> %679, %672
%681 = getelementptr inbounds i8, i8* %219, i64 672
%682 = bitcast i8* %681 to <2 x double>*
%683 = load <2 x double>, <2 x double>* %682, align 16, !alias.scope !38, !noalias !39
%684 = fadd fast <2 x double> %683, %676
%685 = getelementptr inbounds i8, i8* %219, i64 688
%686 = bitcast i8* %685 to <4 x double>*
%687 = load <4 x double>, <4 x double>* %686, align 16, !alias.scope !38, !noalias !39
%688 = fadd fast <4 x double> %687, %680
%689 = getelementptr inbounds i8, i8* %219, i64 720
%690 = bitcast i8* %689 to <2 x double>*
%691 = load <2 x double>, <2 x double>* %690, align 16, !alias.scope !38, !noalias !39
%692 = fadd fast <2 x double> %691, %684
%693 = getelementptr inbounds i8, i8* %219, i64 736
%694 = bitcast i8* %693 to <4 x double>*
%695 = load <4 x double>, <4 x double>* %694, align 16, !alias.scope !38, !noalias !39
%696 = fadd fast <4 x double> %695, %688
%697 = getelementptr inbounds i8, i8* %219, i64 768
%698 = bitcast i8* %697 to <2 x double>*
%699 = load <2 x double>, <2 x double>* %698, align 16, !alias.scope !38, !noalias !39
%700 = fadd fast <2 x double> %699, %692
%701 = getelementptr inbounds i8, i8* %219, i64 784
%702 = bitcast i8* %701 to <4 x double>*
%703 = load <4 x double>, <4 x double>* %702, align 16, !alias.scope !38, !noalias !39
%704 = fadd fast <4 x double> %703, %696
%705 = getelementptr inbounds i8, i8* %219, i64 816
%706 = bitcast i8* %705 to <2 x double>*
%707 = load <2 x double>, <2 x double>* %706, align 16, !alias.scope !38, !noalias !39
%708 = fadd fast <2 x double> %707, %700
%709 = getelementptr inbounds i8, i8* %219, i64 832
%710 = bitcast i8* %709 to <4 x double>*
%711 = load <4 x double>, <4 x double>* %710, align 16, !alias.scope !38, !noalias !39
%712 = fadd fast <4 x double> %711, %704
%713 = getelementptr inbounds i8, i8* %10, i64 96
%714 = bitcast i8* %713 to <2 x double>*
store <2 x double> %708, <2 x double>* %714, align 8, !alias.scope !42, !noalias !43
%715 = getelementptr inbounds i8, i8* %10, i64 112
%716 = bitcast i8* %715 to <4 x double>*
store <4 x double> %712, <4 x double>* %716, align 8, !alias.scope !42, !noalias !43
%717 = bitcast i8* %72 to i64*
%718 = load i64, i64* %717, align 8, !alias.scope !45, !noalias !0
%719 = bitcast i8* %219 to i64*
store i64 %718, i64* %719, align 16, !alias.scope !46, !noalias !47
%720 = getelementptr inbounds i8, i8* %219, i64 8
call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(24) %720, i8 0, i64 24, i1 false)
%721 = bitcast i8* %126 to i64*
%722 = load i64, i64* %721, align 8, !alias.scope !9, !noalias !14
%723 = getelementptr inbounds i8, i8* %219, i64 32
%724 = bitcast i8* %723 to i64*
store i64 %722, i64* %724, align 16, !alias.scope !46, !noalias !47
%725 = getelementptr inbounds i8, i8* %219, i64 40
%726 = getelementptr inbounds i8, i8* %219, i64 56
call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(24) %725, i8 0, i64 24, i1 false)
%727 = bitcast i8* %172 to i64*
%728 = load i64, i64* %727, align 8, !alias.scope !9, !noalias !14
%729 = getelementptr inbounds i8, i8* %219, i64 64
%730 = bitcast i8* %729 to i64*
store i64 %728, i64* %730, align 16, !alias.scope !46, !noalias !47
%731 = getelementptr inbounds i8, i8* %219, i64 80
%732 = getelementptr inbounds i8, i8* %219, i64 88
%733 = bitcast i8* %720 to <2 x double>*
%734 = load <2 x double>, <2 x double>* %733, align 8, !alias.scope !46, !noalias !47
%735 = bitcast i8* %723 to <2 x double>*
%736 = load <2 x double>, <2 x double>* %735, align 16, !alias.scope !46, !noalias !47
%737 = fadd fast <2 x double> %736, %734
%738 = bitcast i8* %726 to <2 x double>*
%739 = load <2 x double>, <2 x double>* %738, align 8, !alias.scope !46, !noalias !47
%740 = fadd fast <2 x double> %739, %737
%741 = bitcast i8* %732 to <2 x double>*
%742 = bitcast i8* %731 to i64*
store i64 %718, i64* %742, align 16, !alias.scope !48, !noalias !49
store <2 x double> %740, <2 x double>* %741, align 8, !alias.scope !48, !noalias !49
%743 = bitcast i8* %220 to i64*
%744 = load i64, i64* %743, align 16, !alias.scope !30, !noalias !32
%745 = bitcast i8* %72 to i64*
store i64 %744, i64* %745, align 8, !alias.scope !50, !noalias !51
%746 = getelementptr inbounds i8, i8* %72, i64 8
%747 = getelementptr inbounds i8, i8* %72, i64 16
call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(16) %746, i8 0, i64 16, i1 false)
%748 = bitcast i8* %244 to i64*
%749 = load i64, i64* %748, align 8, !alias.scope !30, !noalias !32
%750 = getelementptr inbounds i8, i8* %72, i64 24
%751 = bitcast i8* %750 to i64*
store i64 %749, i64* %751, align 8, !alias.scope !50, !noalias !51
%752 = bitcast i8* %72 to <2 x double>*
%753 = load <2 x double>, <2 x double>* %752, align 8, !alias.scope !50, !noalias !51
%754 = bitcast i8* %747 to <2 x double>*
%755 = load <2 x double>, <2 x double>* %754, align 8, !alias.scope !50, !noalias !51
%756 = fadd fast <2 x double> %755, %753
%757 = bitcast i8* %219 to <2 x double>*
store <2 x double> %756, <2 x double>* %757, align 16, !alias.scope !52, !noalias !53
%758 = bitcast i8* %731 to double*
%759 = load double, double* %758, align 16, !alias.scope !48, !noalias !49
%shuffle = shufflevector <2 x double> %756, <2 x double> undef, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%760 = extractelement <2 x double> %756, i32 0
%761 = fmul fast double %759, %760
%762 = bitcast [3 x [1 x float]]* %248 to <2 x float>*
%763 = load <2 x float>, <2 x float>* %762, align 8, !invariant.load !0, !noalias !34
%764 = fmul fast <2 x float> %763, <float 2.000000e+00, float 2.000000e+00>
%765 = fadd fast <2 x float> %764, <float -1.000000e+00, float -1.000000e+00>
%766 = fcmp fast one <2 x float> %765, zeroinitializer
%767 = uitofp <2 x i1> %766 to <2 x float>
%768 = call fast <2 x float> @llvm.copysign.v2f32(<2 x float> %767, <2 x float> %765)
%769 = fpext <2 x float> %768 to <2 x double>
%770 = bitcast [3 x [1 x double]]* %251 to <2 x double>*
%771 = load <2 x double>, <2 x double>* %770, align 8, !invariant.load !0, !noalias !34
%772 = fmul fast <2 x double> %771, <double 0x3FDA827999FCEF34, double 0x3FDA827999FCEF34>
%773 = fadd fast <2 x double> %772, <double 1.000000e+00, double 1.000000e+00>
%774 = fmul fast <2 x double> %773, %769
%775 = fmul fast <2 x double> %774, %774
%shuffle341 = shufflevector <2 x double> %775, <2 x double> undef, <4 x i32> <i32 0, i32 1, i32 1, i32 1>
%776 = extractelement <2 x double> %775, i32 0
%777 = fmul fast double %776, %761
%778 = bitcast i8* %72 to double*
store double %777, double* %778, align 8, !alias.scope !54, !noalias !55
%779 = getelementptr inbounds i8, i8* %219, i64 88
%780 = bitcast i8* %779 to double*
%781 = getelementptr inbounds i8, i8* %72, i64 8
%782 = getelementptr inbounds i8, i8* %219, i64 96
%783 = bitcast i8* %782 to double*
%784 = bitcast i8* %779 to <2 x double>*
%785 = load <2 x double>, <2 x double>* %784, align 8, !alias.scope !48, !noalias !49
%786 = shufflevector <2 x double> %785, <2 x double> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
%787 = extractelement <2 x double> %785, i32 1
%788 = shufflevector <2 x double> %785, <2 x double> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%789 = insertelement <4 x double> %788, double %759, i32 2
%790 = shufflevector <4 x double> %789, <4 x double> %786, <4 x i32> <i32 0, i32 1, i32 2, i32 4>
%791 = fmul fast <4 x double> %790, %shuffle
%792 = shufflevector <2 x double> %775, <2 x double> undef, <4 x i32> zeroinitializer
%793 = fmul fast <4 x double> %792, %791
%794 = bitcast i8* %781 to <4 x double>*
store <4 x double> %793, <4 x double>* %794, align 8, !alias.scope !54, !noalias !55
%795 = extractelement <2 x double> %756, i32 1
%796 = fmul fast double %787, %795
%797 = getelementptr inbounds i8, i8* %72, i64 40
%798 = insertelement <4 x double> undef, double %796, i32 0
%799 = insertelement <4 x double> %798, double %761, i32 1
%800 = shufflevector <4 x double> %799, <4 x double> %791, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%801 = fmul fast <4 x double> %shuffle341, %800
%802 = bitcast i8* %797 to <4 x double>*
store <4 x double> %801, <4 x double>* %802, align 8, !alias.scope !54, !noalias !55
%803 = extractelement <4 x double> %791, i32 2
%804 = extractelement <2 x double> %775, i32 1
%805 = fmul fast double %804, %803
%806 = getelementptr inbounds i8, i8* %72, i64 72
%807 = bitcast i8* %806 to double*
store double %805, double* %807, align 8, !alias.scope !54, !noalias !55
%808 = getelementptr inbounds i8, i8* %72, i64 80
%809 = load float, float* %463, align 8, !invariant.load !0, !noalias !34
%810 = fmul fast float %809, 2.000000e+00
%811 = fadd fast float %810, -1.000000e+00
%812 = fcmp fast one float %811, 0.000000e+00
%813 = uitofp i1 %812 to float
%814 = tail call fast float @llvm.copysign.f32(float %813, float %811)
%815 = fpext float %814 to double
%816 = load double, double* %471, align 8, !invariant.load !0, !noalias !34
%817 = fmul fast double %816, 0x3FDA827999FCEF34
%818 = fadd fast double %817, 1.000000e+00
%819 = fmul fast double %818, %815
%820 = bitcast i8* %219 to <2 x double>*
%821 = load <2 x double>, <2 x double>* %820, align 16, !alias.scope !52, !noalias !53
%reorder_shuffle = shufflevector <2 x double> %821, <2 x double> undef, <2 x i32> <i32 1, i32 0>
%shuffle342 = shufflevector <2 x double> %reorder_shuffle, <2 x double> undef, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%822 = load double, double* %758, align 16, !alias.scope !48, !noalias !49
%823 = fmul fast double %819, %819
%824 = load double, double* %780, align 8, !alias.scope !48, !noalias !49
%825 = insertelement <4 x double> %788, double %822, i32 2
%826 = insertelement <4 x double> %825, double %824, i32 3
%827 = fmul fast <4 x double> %826, %shuffle342
%828 = insertelement <4 x double> undef, double %804, i32 0
%829 = insertelement <4 x double> %828, double %804, i32 1
%830 = insertelement <4 x double> %829, double %823, i32 2
%831 = insertelement <4 x double> %830, double %823, i32 3
%832 = fmul fast <4 x double> %831, %827
%833 = bitcast i8* %808 to <4 x double>*
store <4 x double> %832, <4 x double>* %833, align 8, !alias.scope !54, !noalias !55
%834 = getelementptr inbounds i8, i8* %72, i64 112
%835 = load double, double* %783, align 16, !alias.scope !48, !noalias !49
%836 = insertelement <4 x double> undef, double %787, i32 0
%837 = insertelement <4 x double> %836, double %822, i32 1
%838 = insertelement <4 x double> %837, double %824, i32 2
%839 = insertelement <4 x double> %838, double %835, i32 3
%840 = shufflevector <2 x double> %821, <2 x double> undef, <4 x i32> <i32 0, i32 1, i32 1, i32 1>
%841 = fmul fast <4 x double> %839, %840
%842 = insertelement <4 x double> undef, double %823, i32 0
%843 = shufflevector <4 x double> %842, <4 x double> undef, <4 x i32> zeroinitializer
%844 = fmul fast <4 x double> %843, %841
%845 = bitcast i8* %834 to <4 x double>*
store <4 x double> %844, <4 x double>* %845, align 8, !alias.scope !54, !noalias !55
%846 = getelementptr inbounds i8*, i8** %buffer_table, i64 7
%847 = bitcast i8** %846 to [2 x i8*]**
%848 = load [2 x i8*]*, [2 x i8*]** %847, align 8, !invariant.load !0, !dereferenceable !27, !align !2
%849 = getelementptr inbounds [2 x i8*], [2 x i8*]* %848, i64 0, i64 0
store i8* %72, i8** %849, align 8, !alias.scope !56, !noalias !57
%850 = getelementptr inbounds [2 x i8*], [2 x i8*]* %848, i64 0, i64 1
store i8* %10, i8** %850, align 8, !alias.scope !56, !noalias !57
ret void
}
; Function Attrs: nounwind readnone speculatable willreturn
declare float @llvm.copysign.f32(float, float) #1
; Function Attrs: argmemonly nounwind willreturn writeonly
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #2
; Function Attrs: nounwind readnone speculatable willreturn
declare <2 x float> @llvm.copysign.v2f32(<2 x float>, <2 x float>) #1
attributes #0 = { nofree nounwind uwtable "denormal-fp-math"="preserve-sign" "no-frame-pointer-elim"="false" }
attributes #1 = { nounwind readnone speculatable willreturn }
attributes #2 = { argmemonly nounwind willreturn writeonly }
!0 = !{}
!1 = !{i64 12}
!2 = !{i64 8}
!3 = !{i64 24}
!4 = !{i64 72}
!5 = !{i64 144}
!6 = !{!7}
!7 = !{!"buffer: {index:1, offset:0, size:72}", !8}
!8 = !{!"XLA global AA domain"}
!9 = !{!10}
!10 = !{!"buffer: {index:0, offset:0, size:72}", !8}
!11 = distinct !{!11, !12, !13}
!12 = !{!"llvm.loop.unroll.disable"}
!13 = !{!"llvm.loop.isvectorized", i32 1}
!14 = !{!7, !15, !16, !17}
!15 = !{!"buffer: {index:22, offset:0, size:72}", !8}
!16 = !{!"buffer: {index:22, offset:0, size:864}", !8}
!17 = !{!"buffer: {index:22, offset:864, size:32}", !8}
!18 = distinct !{!18, !12, !13}
!19 = distinct !{!19, !12, !13}
!20 = distinct !{!20, !12, !13}
!21 = distinct !{!21, !12, !13}
!22 = distinct !{!22, !12, !13}
!23 = distinct !{!23, !12, !13}
!24 = distinct !{!24, !12, !13}
!25 = distinct !{!25, !12, !13}
!26 = !{i64 32}
!27 = !{i64 16}
!28 = !{!29}
!29 = !{!"buffer: {index:1, offset:0, size:32}", !8}
!30 = !{!17}
!31 = !{i64 896}
!32 = !{!33, !10, !29, !16}
!33 = !{!"buffer: {index:0, offset:0, size:32}", !8}
!34 = !{!10, !35, !36, !16, !37, !17}
!35 = !{!"buffer: {index:0, offset:0, size:144}", !8}
!36 = !{!"buffer: {index:22, offset:0, size:16}", !8}
!37 = !{!"buffer: {index:22, offset:80, size:24}", !8}
!38 = !{!16}
!39 = !{!10, !40, !41, !17}
!40 = !{!"buffer: {index:1, offset:0, size:144}", !8}
!41 = !{!"buffer: {index:11, offset:0, size:8}", !8}
!42 = !{!40}
!43 = !{!35, !44, !41, !16}
!44 = !{!"buffer: {index:7, offset:0, size:16}", !8}
!45 = !{!15, !10}
!46 = !{!15}
!47 = !{!10, !41, !37}
!48 = !{!37}
!49 = !{!35, !41, !36, !15}
!50 = !{!33}
!51 = !{!41, !36, !17}
!52 = !{!36}
!53 = !{!33, !35, !41, !37}
!54 = !{!35}
!55 = !{!40, !44, !36, !37}
!56 = !{!44}
!57 = !{!35, !40}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment