Attachment 75025 Details for Bug 61036 – Error message produced by LLVM 3.0

Error message produced by LLVM 3.0

log.txt (text/plain), 62.97 KB, created by Brian Crowell on 2013-02-18 03:55:01 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Brian Crowell

Created: 2013-02-18 03:55:01 UTC

Size: 62.97 KB

patch

obsolete

>DEBUG:fluggo.editor.plugins.test:Setting gain to 2.0
>DEBUG:fluggo.editor.graph.video:Adding effect Gain/Offset
>DEBUG:fluggo.editor.graph.video:Feeding with initial input
>DEBUG:fluggo.editor.graph.video:Using as output
>DEBUG:fluggo.media.cprocess.gl:gl_ensure_context() called
>DEBUG:fluggo.media.cprocess.gl:No current context, going to check for a thread context...
>DEBUG:fluggo.media.cprocess.gl:Opening X display...
>DEBUG:fluggo.media.cprocess.gl:Choosing framebuffer config
>couldn't open libtxc_dxtn.so, software DXTn compression/decompression unavailable
>Mesa warning: couldn't open libtxc_dxtn.so, software DXTn compression/decompression unavailable
>INFO:fluggo.media.cprocess.gl:Info from compiling the shader "Compositor vertex shader":
>
>
>INFO:fluggo.media.cprocess.gl:Info from compiling the shader "Fluggo SolidColorVideoSource shader":
>
>
>INFO:fluggo.media.cprocess.gl:Info from linking the program "Fluggo SolidColorVideoSource shader":
>
>
>DEBUG:root:Using gain of 2.000000
>INFO:fluggo.media.cprocess.gl:Info from compiling the shader "Fluggo Gain/Offset shader":
>
>
>INFO:fluggo.media.cprocess.gl:Info from linking the program "Fluggo Gain/Offset shader":
>
>
>Invalid insertelement operands!
>  %242 = insertelement <4 x i32> undef, float %241, i32 0
>Invalid insertelement operands!
>  %245 = insertelement <4 x i32> %242, float %244, i32 1
>Invalid insertelement operands!
>  %248 = insertelement <4 x i32> %245, float %247, i32 2
>Invalid insertelement operands!
>  %251 = insertelement <4 x i32> %248, float %250, i32 3
>Instruction does not dominate all uses!
>  %251 = insertelement <4 x i32> %248, float %250, i32 3
>  %252 = sitofp <4 x i32> %251 to <4 x float>
>Invalid insertelement operands!
>  %264 = insertelement <4 x i32> undef, float %263, i32 0
>Invalid insertelement operands!
>  %267 = insertelement <4 x i32> %264, float %266, i32 1
>Invalid insertelement operands!
>  %270 = insertelement <4 x i32> %267, float %269, i32 2
>Invalid insertelement operands!
>  %273 = insertelement <4 x i32> %270, float %272, i32 3
>Instruction does not dominate all uses!
>  %273 = insertelement <4 x i32> %270, float %272, i32 3
>  %274 = sitofp <4 x i32> %273 to <4 x float>
>Instruction does not dominate all uses!
>  %252 = sitofp <4 x i32> %251 to <4 x float>
>  %277 = bitcast <4 x float> %252 to <4 x i32>
>Instruction does not dominate all uses!
>  %277 = bitcast <4 x float> %252 to <4 x i32>
>  %279 = and <4 x i32> %277, %maskfull43
>Instruction does not dominate all uses!
>  %279 = and <4 x i32> %277, %maskfull43
>  %282 = or <4 x i32> %279, %281
>Instruction does not dominate all uses!
>  %282 = or <4 x i32> %279, %281
>  %283 = bitcast <4 x i32> %282 to <4 x float>
>Instruction does not dominate all uses!
>  %283 = bitcast <4 x i32> %282 to <4 x float>
>  store <4 x float> %283, <4 x float>* %275
>Instruction does not dominate all uses!
>  %274 = sitofp <4 x i32> %273 to <4 x float>
>  %286 = bitcast <4 x float> %274 to <4 x i32>
>Instruction does not dominate all uses!
>  %286 = bitcast <4 x float> %274 to <4 x i32>
>  %288 = and <4 x i32> %286, %maskfull43
>Instruction does not dominate all uses!
>  %288 = and <4 x i32> %286, %maskfull43
>  %291 = or <4 x i32> %288, %290
>Instruction does not dominate all uses!
>  %291 = or <4 x i32> %288, %290
>  %292 = bitcast <4 x i32> %291 to <4 x float>
>Instruction does not dominate all uses!
>  %292 = bitcast <4 x i32> %291 to <4 x float>
>  store <4 x float> %292, <4 x float>* %284
>Broken module found, verification continues.
>
>define i32 @draw_llvm_shader({ [16 x float*], [16 x float*], [14 x [4 x float]]*, float*, [32 x { i32, i32, i32, i32, i32, i8*, [16 x i32], [16 x i32], [16 x i32] }], [16 x { float, float, float, [4 x float] }] }* noalias %context, { i32, [4 x float], [4 x float], [6 x [4 x float]] }* noalias %io, i8** noalias %vbuffers, i32 %start, i32 %count, i32 %stride, { i32, i32, i8*, i8* }* noalias %vb, i32 %instance_id) {
>entry:
>  %0 = alloca <4 x i32>
>  %addr37 = alloca <4 x i32>
>  %addr36 = alloca <4 x i32>
>  %addr35 = alloca <4 x i32>
>  %addr = alloca <4 x i32>
>  %output34 = alloca <4 x float>
>  %output33 = alloca <4 x float>
>  %output32 = alloca <4 x float>
>  %output31 = alloca <4 x float>
>  %output30 = alloca <4 x float>
>  %output29 = alloca <4 x float>
>  %output28 = alloca <4 x float>
>  %output27 = alloca <4 x float>
>  %output26 = alloca <4 x float>
>  %output25 = alloca <4 x float>
>  %output24 = alloca <4 x float>
>  %output23 = alloca <4 x float>
>  %output22 = alloca <4 x float>
>  %output21 = alloca <4 x float>
>  %output20 = alloca <4 x float>
>  %output19 = alloca <4 x float>
>  %output18 = alloca <4 x float>
>  %output17 = alloca <4 x float>
>  %output16 = alloca <4 x float>
>  %output = alloca <4 x float>
>  %temp_array = alloca <4 x float>, i32 96
>  %looplimiter = alloca i32
>  %loop_counter = alloca i32
>  %1 = alloca <4 x i32>
>  store <4 x i32> zeroinitializer, <4 x i32>* %1
>  store <4 x i32> zeroinitializer, <4 x i32>* %1
>  %2 = add i32 %start, %count
>  %fetch_max = sub i32 %2, 1
>  store i32 0, i32* %loop_counter
>  store i32 %start, i32* %loop_counter
>  br label %loop_begin
>
>loop_begin:                                       ; preds = %endloop, %entry
>  %3 = load i32* %loop_counter
>  %4 = sub i32 %3, %start
>  %5 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %io, i32 %4
>  %6 = add i32 %3, 0
>  %7 = icmp slt i32 %6, %fetch_max
>  %8 = sext i1 %7 to i32
>  %9 = trunc i32 %8 to i1
>  %10 = select i1 %9, i32 %6, i32 %fetch_max
>  %11 = insertelement <4 x i32> zeroinitializer, i32 %10, i32 0
>  %12 = getelementptr { i32, i32, i8*, i8* }* %vb, i32 0
>  %13 = getelementptr i8** %vbuffers, i64 0
>  %.stride_ptr = getelementptr { i32, i32, i8*, i8* }* %12, i32 0, i32 0
>  %.stride = load i32* %.stride_ptr
>  %.buffer_offset_ptr = getelementptr { i32, i32, i8*, i8* }* %12, i32 0, i32 1
>  %.buffer_offset = load i32* %.buffer_offset_ptr
>  %14 = mul i32 %.stride, %10
>  %vbuffer = load i8** %13
>  %15 = add i32 %14, %.buffer_offset
>  %16 = add i32 %15, 0
>  %17 = getelementptr i8* %vbuffer, i32 %16
>  %18 = getelementptr i8* %17, i32 0
>  %19 = bitcast i8* %18 to i64*
>  %20 = load i64* %19
>  %21 = zext i64 %20 to i128
>  %22 = bitcast i128 %21 to <4 x float>
>  %23 = shufflevector <4 x float> %22, <4 x float> <float 0.000000e+00, float 1.000000e+00, float undef, float undef>, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
>  %24 = add i32 %3, 1
>  %25 = icmp slt i32 %24, %fetch_max
>  %26 = sext i1 %25 to i32
>  %27 = trunc i32 %26 to i1
>  %28 = select i1 %27, i32 %24, i32 %fetch_max
>  %29 = insertelement <4 x i32> %11, i32 %28, i32 1
>  %30 = getelementptr { i32, i32, i8*, i8* }* %vb, i32 0
>  %31 = getelementptr i8** %vbuffers, i64 0
>  %.stride_ptr1 = getelementptr { i32, i32, i8*, i8* }* %30, i32 0, i32 0
>  %.stride2 = load i32* %.stride_ptr1
>  %.buffer_offset_ptr3 = getelementptr { i32, i32, i8*, i8* }* %30, i32 0, i32 1
>  %.buffer_offset4 = load i32* %.buffer_offset_ptr3
>  %32 = mul i32 %.stride2, %28
>  %vbuffer5 = load i8** %31
>  %33 = add i32 %32, %.buffer_offset4
>  %34 = add i32 %33, 0
>  %35 = getelementptr i8* %vbuffer5, i32 %34
>  %36 = getelementptr i8* %35, i32 0
>  %37 = bitcast i8* %36 to i64*
>  %38 = load i64* %37
>  %39 = zext i64 %38 to i128
>  %40 = bitcast i128 %39 to <4 x float>
>  %41 = shufflevector <4 x float> %40, <4 x float> <float 0.000000e+00, float 1.000000e+00, float undef, float undef>, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
>  %42 = add i32 %3, 2
>  %43 = icmp slt i32 %42, %fetch_max
>  %44 = sext i1 %43 to i32
>  %45 = trunc i32 %44 to i1
>  %46 = select i1 %45, i32 %42, i32 %fetch_max
>  %47 = insertelement <4 x i32> %29, i32 %46, i32 2
>  %48 = getelementptr { i32, i32, i8*, i8* }* %vb, i32 0
>  %49 = getelementptr i8** %vbuffers, i64 0
>  %.stride_ptr6 = getelementptr { i32, i32, i8*, i8* }* %48, i32 0, i32 0
>  %.stride7 = load i32* %.stride_ptr6
>  %.buffer_offset_ptr8 = getelementptr { i32, i32, i8*, i8* }* %48, i32 0, i32 1
>  %.buffer_offset9 = load i32* %.buffer_offset_ptr8
>  %50 = mul i32 %.stride7, %46
>  %vbuffer10 = load i8** %49
>  %51 = add i32 %50, %.buffer_offset9
>  %52 = add i32 %51, 0
>  %53 = getelementptr i8* %vbuffer10, i32 %52
>  %54 = getelementptr i8* %53, i32 0
>  %55 = bitcast i8* %54 to i64*
>  %56 = load i64* %55
>  %57 = zext i64 %56 to i128
>  %58 = bitcast i128 %57 to <4 x float>
>  %59 = shufflevector <4 x float> %58, <4 x float> <float 0.000000e+00, float 1.000000e+00, float undef, float undef>, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
>  %60 = add i32 %3, 3
>  %61 = icmp slt i32 %60, %fetch_max
>  %62 = sext i1 %61 to i32
>  %63 = trunc i32 %62 to i1
>  %64 = select i1 %63, i32 %60, i32 %fetch_max
>  %65 = insertelement <4 x i32> %47, i32 %64, i32 3
>  %66 = getelementptr { i32, i32, i8*, i8* }* %vb, i32 0
>  %67 = getelementptr i8** %vbuffers, i64 0
>  %.stride_ptr11 = getelementptr { i32, i32, i8*, i8* }* %66, i32 0, i32 0
>  %.stride12 = load i32* %.stride_ptr11
>  %.buffer_offset_ptr13 = getelementptr { i32, i32, i8*, i8* }* %66, i32 0, i32 1
>  %.buffer_offset14 = load i32* %.buffer_offset_ptr13
>  %68 = mul i32 %.stride12, %64
>  %vbuffer15 = load i8** %67
>  %69 = add i32 %68, %.buffer_offset14
>  %70 = add i32 %69, 0
>  %71 = getelementptr i8* %vbuffer15, i32 %70
>  %72 = getelementptr i8* %71, i32 0
>  %73 = bitcast i8* %72 to i64*
>  %74 = load i64* %73
>  %75 = zext i64 %74 to i128
>  %76 = bitcast i128 %75 to <4 x float>
>  %77 = shufflevector <4 x float> %76, <4 x float> <float 0.000000e+00, float 1.000000e+00, float undef, float undef>, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
>  %78 = shufflevector <4 x float> %23, <4 x float> %41, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %79 = shufflevector <4 x float> %59, <4 x float> %77, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %80 = shufflevector <4 x float> %23, <4 x float> %41, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %81 = shufflevector <4 x float> %59, <4 x float> %77, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %t0 = bitcast <4 x float> %78 to <2 x double>
>  %t1 = bitcast <4 x float> %79 to <2 x double>
>  %t2 = bitcast <4 x float> %80 to <2 x double>
>  %t3 = bitcast <4 x float> %81 to <2 x double>
>  %82 = shufflevector <2 x double> %t0, <2 x double> %t1, <2 x i32> <i32 0, i32 2>
>  %83 = shufflevector <2 x double> %t0, <2 x double> %t1, <2 x i32> <i32 1, i32 3>
>  %84 = shufflevector <2 x double> %t2, <2 x double> %t3, <2 x i32> <i32 0, i32 2>
>  %85 = shufflevector <2 x double> %t2, <2 x double> %t3, <2 x i32> <i32 1, i32 3>
>  %dst0 = bitcast <2 x double> %82 to <4 x float>
>  %dst1 = bitcast <2 x double> %83 to <4 x float>
>  %dst2 = bitcast <2 x double> %84 to <4 x float>
>  %dst3 = bitcast <2 x double> %85 to <4 x float>
>  %context.vs_constants_ptr = getelementptr { [16 x float*], [16 x float*], [14 x [4 x float]]*, float*, [32 x { i32, i32, i32, i32, i32, i8*, [16 x i32], [16 x i32], [16 x i32] }], [16 x { float, float, float, [4 x float] }] }* %context, i32 0, i32 0
>  store i32 0, i32* %looplimiter
>  store i32 65535, i32* %looplimiter
>  store <4 x float> zeroinitializer, <4 x float>* %output
>  store <4 x float> zeroinitializer, <4 x float>* %output16
>  store <4 x float> zeroinitializer, <4 x float>* %output17
>  store <4 x float> zeroinitializer, <4 x float>* %output18
>  store <4 x float> zeroinitializer, <4 x float>* %output19
>  store <4 x float> zeroinitializer, <4 x float>* %output20
>  store <4 x float> zeroinitializer, <4 x float>* %output21
>  store <4 x float> zeroinitializer, <4 x float>* %output22
>  store <4 x float> zeroinitializer, <4 x float>* %output23
>  store <4 x float> zeroinitializer, <4 x float>* %output24
>  store <4 x float> zeroinitializer, <4 x float>* %output25
>  store <4 x float> zeroinitializer, <4 x float>* %output26
>  store <4 x float> zeroinitializer, <4 x float>* %output27
>  store <4 x float> zeroinitializer, <4 x float>* %output28
>  store <4 x float> zeroinitializer, <4 x float>* %output29
>  store <4 x float> zeroinitializer, <4 x float>* %output30
>  store <4 x float> zeroinitializer, <4 x float>* %output31
>  store <4 x float> zeroinitializer, <4 x float>* %output32
>  store <4 x float> zeroinitializer, <4 x float>* %output33
>  store <4 x float> zeroinitializer, <4 x float>* %output34
>  store <4 x i32> zeroinitializer, <4 x i32>* %addr
>  store <4 x i32> zeroinitializer, <4 x i32>* %addr35
>  store <4 x i32> zeroinitializer, <4 x i32>* %addr36
>  store <4 x i32> zeroinitializer, <4 x i32>* %addr37
>  %86 = getelementptr <4 x float>* %temp_array, i32 6
>  store <4 x float> zeroinitializer, <4 x float>* %86
>  %87 = getelementptr <4 x float>* %temp_array, i32 7
>  store <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, <4 x float>* %87
>  %88 = fmul <4 x float> %dst0, <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>
>  %89 = fadd <4 x float> %88, <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>
>  %90 = fmul <4 x float> %dst1, <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>
>  %91 = fadd <4 x float> %90, <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>
>  %92 = getelementptr <4 x float>* %temp_array, i32 4
>  store <4 x float> %89, <4 x float>* %92
>  %93 = getelementptr <4 x float>* %temp_array, i32 5
>  store <4 x float> %91, <4 x float>* %93
>  %94 = getelementptr <4 x float>* %temp_array, i32 4
>  %95 = load <4 x float>* %94
>  %96 = getelementptr <4 x float>* %temp_array, i32 5
>  %97 = load <4 x float>* %96
>  %98 = getelementptr <4 x float>* %temp_array, i32 6
>  %99 = load <4 x float>* %98
>  %100 = getelementptr <4 x float>* %temp_array, i32 7
>  %101 = load <4 x float>* %100
>  %102 = getelementptr <4 x float>* %temp_array, i32 12
>  store <4 x float> %95, <4 x float>* %102
>  %103 = getelementptr <4 x float>* %temp_array, i32 13
>  store <4 x float> %97, <4 x float>* %103
>  %104 = getelementptr <4 x float>* %temp_array, i32 14
>  store <4 x float> %99, <4 x float>* %104
>  %105 = getelementptr <4 x float>* %temp_array, i32 15
>  store <4 x float> %101, <4 x float>* %105
>  %106 = getelementptr <4 x float>* %temp_array, i32 16
>  store <4 x float> zeroinitializer, <4 x float>* %106
>  store <4 x i32> zeroinitializer, <4 x i32>* %0
>  store <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, <4 x i32>* %0
>  br label %bgnloop
>
>bgnloop:                                          ; preds = %bgnloop, %loop_begin
>  %107 = load <4 x i32>* %0
>  %maskcb = and <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %107
>  %maskfull = and <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %maskcb
>  %108 = getelementptr <4 x float>* %temp_array, i32 16
>  %109 = bitcast <4 x float>* %108 to <4 x i32>*
>  %110 = load <4 x i32>* %109
>  %"&context.vs_constants_ptr[]" = getelementptr [16 x float*]* %context.vs_constants_ptr, i32 0, i32 0
>  %"context.vs_constants_ptr[]" = load float** %"&context.vs_constants_ptr[]"
>  %111 = getelementptr float* %"context.vs_constants_ptr[]", i32 8
>  %112 = bitcast float* %111 to i32*
>  %113 = load i32* %112
>  %114 = insertelement <4 x i32> undef, i32 %113, i32 0
>  %115 = shufflevector <4 x i32> %114, <4 x i32> undef, <4 x i32> zeroinitializer
>  %116 = icmp sge <4 x i32> %110, %115
>  %117 = sext <4 x i1> %116 to <4 x i32>
>  %118 = and <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %117
>  %119 = xor <4 x i32> %117, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %120 = and <4 x i32> zeroinitializer, %119
>  %121 = or <4 x i32> %118, %120
>  %122 = getelementptr <4 x float>* %temp_array, i32 20
>  %123 = bitcast <4 x float>* %122 to <4 x i32>*
>  %124 = load <4 x i32>* %123
>  %125 = and <4 x i32> %121, %maskfull
>  %126 = xor <4 x i32> %maskfull, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %127 = and <4 x i32> %124, %126
>  %128 = or <4 x i32> %125, %127
>  store <4 x i32> %128, <4 x i32>* %123
>  %129 = getelementptr <4 x float>* %temp_array, i32 20
>  %130 = load <4 x float>* %129
>  %131 = fcmp une <4 x float> %130, zeroinitializer
>  %132 = sext <4 x i1> %131 to <4 x i32>
>  %133 = and <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %132
>  %maskcb38 = and <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %107
>  %maskfull39 = and <4 x i32> %133, %maskcb38
>  %break = xor <4 x i32> %maskfull39, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %break_full = and <4 x i32> %107, %break
>  %maskcb40 = and <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %break_full
>  %maskfull41 = and <4 x i32> %133, %maskcb40
>  %maskcb42 = and <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %break_full
>  %maskfull43 = and <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %maskcb42
>  %"&context.vs_constants_ptr[]44" = getelementptr [16 x float*]* %context.vs_constants_ptr, i32 0, i32 0
>  %"context.vs_constants_ptr[]45" = load float** %"&context.vs_constants_ptr[]44"
>  %134 = getelementptr float* %"context.vs_constants_ptr[]45", i32 4
>  %135 = bitcast float* %134 to i32*
>  %136 = load i32* %135
>  %137 = insertelement <4 x i32> undef, i32 %136, i32 0
>  %138 = shufflevector <4 x i32> %137, <4 x i32> undef, <4 x i32> zeroinitializer
>  %139 = sitofp <4 x i32> %138 to <4 x float>
>  %"&context.vs_constants_ptr[]46" = getelementptr [16 x float*]* %context.vs_constants_ptr, i32 0, i32 0
>  %"context.vs_constants_ptr[]47" = load float** %"&context.vs_constants_ptr[]46"
>  %140 = getelementptr float* %"context.vs_constants_ptr[]47", i32 5
>  %141 = bitcast float* %140 to i32*
>  %142 = load i32* %141
>  %143 = insertelement <4 x i32> undef, i32 %142, i32 0
>  %144 = shufflevector <4 x i32> %143, <4 x i32> undef, <4 x i32> zeroinitializer
>  %145 = sitofp <4 x i32> %144 to <4 x float>
>  %146 = getelementptr <4 x float>* %temp_array, i32 24
>  %147 = load <4 x float>* %146
>  %148 = bitcast <4 x float> %139 to <4 x i32>
>  %149 = bitcast <4 x float> %147 to <4 x i32>
>  %150 = and <4 x i32> %148, %maskfull43
>  %151 = xor <4 x i32> %maskfull43, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %152 = and <4 x i32> %149, %151
>  %153 = or <4 x i32> %150, %152
>  %154 = bitcast <4 x i32> %153 to <4 x float>
>  store <4 x float> %154, <4 x float>* %146
>  %155 = getelementptr <4 x float>* %temp_array, i32 25
>  %156 = load <4 x float>* %155
>  %157 = bitcast <4 x float> %145 to <4 x i32>
>  %158 = bitcast <4 x float> %156 to <4 x i32>
>  %159 = and <4 x i32> %157, %maskfull43
>  %160 = xor <4 x i32> %maskfull43, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %161 = and <4 x i32> %158, %160
>  %162 = or <4 x i32> %159, %161
>  %163 = bitcast <4 x i32> %162 to <4 x float>
>  store <4 x float> %163, <4 x float>* %155
>  %"&context.vs_constants_ptr[]48" = getelementptr [16 x float*]* %context.vs_constants_ptr, i32 0, i32 0
>  %"context.vs_constants_ptr[]49" = load float** %"&context.vs_constants_ptr[]48"
>  %164 = getelementptr float* %"context.vs_constants_ptr[]49", i32 0
>  %165 = bitcast float* %164 to i32*
>  %166 = load i32* %165
>  %167 = insertelement <4 x i32> undef, i32 %166, i32 0
>  %168 = shufflevector <4 x i32> %167, <4 x i32> undef, <4 x i32> zeroinitializer
>  %169 = sitofp <4 x i32> %168 to <4 x float>
>  %"&context.vs_constants_ptr[]50" = getelementptr [16 x float*]* %context.vs_constants_ptr, i32 0, i32 0
>  %"context.vs_constants_ptr[]51" = load float** %"&context.vs_constants_ptr[]50"
>  %170 = getelementptr float* %"context.vs_constants_ptr[]51", i32 1
>  %171 = bitcast float* %170 to i32*
>  %172 = load i32* %171
>  %173 = insertelement <4 x i32> undef, i32 %172, i32 0
>  %174 = shufflevector <4 x i32> %173, <4 x i32> undef, <4 x i32> zeroinitializer
>  %175 = sitofp <4 x i32> %174 to <4 x float>
>  %176 = getelementptr <4 x float>* %temp_array, i32 28
>  %177 = load <4 x float>* %176
>  %178 = bitcast <4 x float> %169 to <4 x i32>
>  %179 = bitcast <4 x float> %177 to <4 x i32>
>  %180 = and <4 x i32> %178, %maskfull43
>  %181 = xor <4 x i32> %maskfull43, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %182 = and <4 x i32> %179, %181
>  %183 = or <4 x i32> %180, %182
>  %184 = bitcast <4 x i32> %183 to <4 x float>
>  store <4 x float> %184, <4 x float>* %176
>  %185 = getelementptr <4 x float>* %temp_array, i32 29
>  %186 = load <4 x float>* %185
>  %187 = bitcast <4 x float> %175 to <4 x i32>
>  %188 = bitcast <4 x float> %186 to <4 x i32>
>  %189 = and <4 x i32> %187, %maskfull43
>  %190 = xor <4 x i32> %maskfull43, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %191 = and <4 x i32> %188, %190
>  %192 = or <4 x i32> %189, %191
>  %193 = bitcast <4 x i32> %192 to <4 x float>
>  store <4 x float> %193, <4 x float>* %185
>  %194 = getelementptr <4 x float>* %temp_array, i32 24
>  %195 = load <4 x float>* %194
>  %196 = getelementptr <4 x float>* %temp_array, i32 28
>  %197 = load <4 x float>* %196
>  %198 = fmul <4 x float> %dst0, %195
>  %199 = fadd <4 x float> %198, %197
>  %200 = getelementptr <4 x float>* %temp_array, i32 25
>  %201 = load <4 x float>* %200
>  %202 = getelementptr <4 x float>* %temp_array, i32 29
>  %203 = load <4 x float>* %202
>  %204 = fmul <4 x float> %dst1, %201
>  %205 = fadd <4 x float> %204, %203
>  %206 = getelementptr <4 x float>* %temp_array, i32 32
>  %207 = load <4 x float>* %206
>  %208 = bitcast <4 x float> %199 to <4 x i32>
>  %209 = bitcast <4 x float> %207 to <4 x i32>
>  %210 = and <4 x i32> %208, %maskfull43
>  %211 = xor <4 x i32> %maskfull43, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %212 = and <4 x i32> %209, %211
>  %213 = or <4 x i32> %210, %212
>  %214 = bitcast <4 x i32> %213 to <4 x float>
>  store <4 x float> %214, <4 x float>* %206
>  %215 = getelementptr <4 x float>* %temp_array, i32 33
>  %216 = load <4 x float>* %215
>  %217 = bitcast <4 x float> %205 to <4 x i32>
>  %218 = bitcast <4 x float> %216 to <4 x i32>
>  %219 = and <4 x i32> %217, %maskfull43
>  %220 = xor <4 x i32> %maskfull43, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %221 = and <4 x i32> %218, %220
>  %222 = or <4 x i32> %219, %221
>  %223 = bitcast <4 x i32> %222 to <4 x float>
>  store <4 x float> %223, <4 x float>* %215
>  %224 = getelementptr <4 x float>* %temp_array, i32 16
>  %225 = bitcast <4 x float>* %224 to <4 x i32>*
>  %226 = load <4 x i32>* %225
>  %227 = load <4 x i32>* %addr
>  %228 = and <4 x i32> %226, %maskfull43
>  %229 = xor <4 x i32> %maskfull43, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %230 = and <4 x i32> %227, %229
>  %231 = or <4 x i32> %228, %230
>  store <4 x i32> %231, <4 x i32>* %addr
>  %"&context.vs_constants_ptr[]52" = getelementptr [16 x float*]* %context.vs_constants_ptr, i32 0, i32 0
>  %"context.vs_constants_ptr[]53" = load float** %"&context.vs_constants_ptr[]52"
>  %"load addr reg" = load <4 x i32>* %addr
>  %232 = add <4 x i32> <i32 3, i32 3, i32 3, i32 3>, %"load addr reg"
>  %233 = icmp ult <4 x i32> %232, <i32 10, i32 10, i32 10, i32 10>
>  %234 = sext <4 x i1> %233 to <4 x i32>
>  %235 = and <4 x i32> %232, %234
>  %236 = xor <4 x i32> %234, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %237 = and <4 x i32> <i32 10, i32 10, i32 10, i32 10>, %236
>  %238 = or <4 x i32> %235, %237
>  %239 = shl <4 x i32> %238, <i32 2, i32 2, i32 2, i32 2>
>  %240 = extractelement <4 x i32> %239, i32 0
>  %gather_ptr = getelementptr float* %"context.vs_constants_ptr[]53", i32 %240
>  %241 = load float* %gather_ptr
>  %242 = insertelement <4 x i32> undef, float %241, i32 0
>  %243 = extractelement <4 x i32> %239, i32 1
>  %gather_ptr54 = getelementptr float* %"context.vs_constants_ptr[]53", i32 %243
>  %244 = load float* %gather_ptr54
>  %245 = insertelement <4 x i32> %242, float %244, i32 1
>  %246 = extractelement <4 x i32> %239, i32 2
>  %gather_ptr55 = getelementptr float* %"context.vs_constants_ptr[]53", i32 %246
>  %247 = load float* %gather_ptr55
>  %248 = insertelement <4 x i32> %245, float %247, i32 2
>  %249 = extractelement <4 x i32> %239, i32 3
>  %gather_ptr56 = getelementptr float* %"context.vs_constants_ptr[]53", i32 %249
>  %250 = load float* %gather_ptr56
>  %251 = insertelement <4 x i32> %248, float %250, i32 3
>  %252 = sitofp <4 x i32> %251 to <4 x float>
>  %"&context.vs_constants_ptr[]57" = getelementptr [16 x float*]* %context.vs_constants_ptr, i32 0, i32 0
>  %"context.vs_constants_ptr[]58" = load float** %"&context.vs_constants_ptr[]57"
>  %"load addr reg59" = load <4 x i32>* %addr
>  %253 = add <4 x i32> <i32 3, i32 3, i32 3, i32 3>, %"load addr reg59"
>  %254 = icmp ult <4 x i32> %253, <i32 10, i32 10, i32 10, i32 10>
>  %255 = sext <4 x i1> %254 to <4 x i32>
>  %256 = and <4 x i32> %253, %255
>  %257 = xor <4 x i32> %255, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %258 = and <4 x i32> <i32 10, i32 10, i32 10, i32 10>, %257
>  %259 = or <4 x i32> %256, %258
>  %260 = shl <4 x i32> %259, <i32 2, i32 2, i32 2, i32 2>
>  %261 = add <4 x i32> %260, <i32 1, i32 1, i32 1, i32 1>
>  %262 = extractelement <4 x i32> %261, i32 0
>  %gather_ptr60 = getelementptr float* %"context.vs_constants_ptr[]58", i32 %262
>  %263 = load float* %gather_ptr60
>  %264 = insertelement <4 x i32> undef, float %263, i32 0
>  %265 = extractelement <4 x i32> %261, i32 1
>  %gather_ptr61 = getelementptr float* %"context.vs_constants_ptr[]58", i32 %265
>  %266 = load float* %gather_ptr61
>  %267 = insertelement <4 x i32> %264, float %266, i32 1
>  %268 = extractelement <4 x i32> %261, i32 2
>  %gather_ptr62 = getelementptr float* %"context.vs_constants_ptr[]58", i32 %268
>  %269 = load float* %gather_ptr62
>  %270 = insertelement <4 x i32> %267, float %269, i32 2
>  %271 = extractelement <4 x i32> %261, i32 3
>  %gather_ptr63 = getelementptr float* %"context.vs_constants_ptr[]58", i32 %271
>  %272 = load float* %gather_ptr63
>  %273 = insertelement <4 x i32> %270, float %272, i32 3
>  %274 = sitofp <4 x i32> %273 to <4 x float>
>  %275 = getelementptr <4 x float>* %temp_array, i32 36
>  %276 = load <4 x float>* %275
>  %277 = bitcast <4 x float> %252 to <4 x i32>
>  %278 = bitcast <4 x float> %276 to <4 x i32>
>  %279 = and <4 x i32> %277, %maskfull43
>  %280 = xor <4 x i32> %maskfull43, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %281 = and <4 x i32> %278, %280
>  %282 = or <4 x i32> %279, %281
>  %283 = bitcast <4 x i32> %282 to <4 x float>
>  store <4 x float> %283, <4 x float>* %275
>  %284 = getelementptr <4 x float>* %temp_array, i32 37
>  %285 = load <4 x float>* %284
>  %286 = bitcast <4 x float> %274 to <4 x i32>
>  %287 = bitcast <4 x float> %285 to <4 x i32>
>  %288 = and <4 x i32> %286, %maskfull43
>  %289 = xor <4 x i32> %maskfull43, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %290 = and <4 x i32> %287, %289
>  %291 = or <4 x i32> %288, %290
>  %292 = bitcast <4 x i32> %291 to <4 x float>
>  store <4 x float> %292, <4 x float>* %284
>  %293 = getelementptr <4 x float>* %temp_array, i32 16
>  %294 = bitcast <4 x float>* %293 to <4 x i32>*
>  %295 = load <4 x i32>* %294
>  %296 = load <4 x i32>* %addr
>  %297 = and <4 x i32> %295, %maskfull43
>  %298 = xor <4 x i32> %maskfull43, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %299 = and <4 x i32> %296, %298
>  %300 = or <4 x i32> %297, %299
>  store <4 x i32> %300, <4 x i32>* %addr
>  %301 = getelementptr <4 x float>* %temp_array, i32 32
>  %302 = load <4 x float>* %301
>  %303 = getelementptr <4 x float>* %temp_array, i32 36
>  %304 = load <4 x float>* %303
>  %305 = fadd <4 x float> %302, %304
>  %306 = getelementptr <4 x float>* %temp_array, i32 33
>  %307 = load <4 x float>* %306
>  %308 = getelementptr <4 x float>* %temp_array, i32 37
>  %309 = load <4 x float>* %308
>  %310 = fadd <4 x float> %307, %309
>  %"load addr reg64" = load <4 x i32>* %addr
>  %311 = add <4 x i32> <i32 11, i32 11, i32 11, i32 11>, %"load addr reg64"
>  %312 = icmp ult <4 x i32> %311, <i32 23, i32 23, i32 23, i32 23>
>  %313 = sext <4 x i1> %312 to <4 x i32>
>  %314 = and <4 x i32> %311, %313
>  %315 = xor <4 x i32> %313, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %316 = and <4 x i32> <i32 23, i32 23, i32 23, i32 23>, %315
>  %317 = or <4 x i32> %314, %316
>  %318 = shl <4 x i32> %317, <i32 2, i32 2, i32 2, i32 2>
>  %319 = mul <4 x i32> %318, <i32 4, i32 4, i32 4, i32 4>
>  %320 = add <4 x i32> %319, <i32 0, i32 1, i32 2, i32 3>
>  %321 = bitcast <4 x float>* %temp_array to float*
>  %322 = extractelement <4 x i32> %320, i32 0
>  %scatter_ptr = getelementptr float* %321, i32 %322
>  %scatter_val = extractelement <4 x float> %305, i32 0
>  %scatter_pred = extractelement <4 x i32> %maskfull43, i32 0
>  %323 = load float* %scatter_ptr
>  %324 = trunc i32 %scatter_pred to i1
>  %325 = select i1 %324, float %scatter_val, float %323
>  store float %325, float* %scatter_ptr
>  %326 = extractelement <4 x i32> %320, i32 1
>  %scatter_ptr65 = getelementptr float* %321, i32 %326
>  %scatter_val66 = extractelement <4 x float> %305, i32 1
>  %scatter_pred67 = extractelement <4 x i32> %maskfull43, i32 1
>  %327 = load float* %scatter_ptr65
>  %328 = trunc i32 %scatter_pred67 to i1
>  %329 = select i1 %328, float %scatter_val66, float %327
>  store float %329, float* %scatter_ptr65
>  %330 = extractelement <4 x i32> %320, i32 2
>  %scatter_ptr68 = getelementptr float* %321, i32 %330
>  %scatter_val69 = extractelement <4 x float> %305, i32 2
>  %scatter_pred70 = extractelement <4 x i32> %maskfull43, i32 2
>  %331 = load float* %scatter_ptr68
>  %332 = trunc i32 %scatter_pred70 to i1
>  %333 = select i1 %332, float %scatter_val69, float %331
>  store float %333, float* %scatter_ptr68
>  %334 = extractelement <4 x i32> %320, i32 3
>  %scatter_ptr71 = getelementptr float* %321, i32 %334
>  %scatter_val72 = extractelement <4 x float> %305, i32 3
>  %scatter_pred73 = extractelement <4 x i32> %maskfull43, i32 3
>  %335 = load float* %scatter_ptr71
>  %336 = trunc i32 %scatter_pred73 to i1
>  %337 = select i1 %336, float %scatter_val72, float %335
>  store float %337, float* %scatter_ptr71
>  %"load addr reg74" = load <4 x i32>* %addr
>  %338 = add <4 x i32> <i32 11, i32 11, i32 11, i32 11>, %"load addr reg74"
>  %339 = icmp ult <4 x i32> %338, <i32 23, i32 23, i32 23, i32 23>
>  %340 = sext <4 x i1> %339 to <4 x i32>
>  %341 = and <4 x i32> %338, %340
>  %342 = xor <4 x i32> %340, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %343 = and <4 x i32> <i32 23, i32 23, i32 23, i32 23>, %342
>  %344 = or <4 x i32> %341, %343
>  %345 = shl <4 x i32> %344, <i32 2, i32 2, i32 2, i32 2>
>  %346 = add <4 x i32> %345, <i32 1, i32 1, i32 1, i32 1>
>  %347 = mul <4 x i32> %346, <i32 4, i32 4, i32 4, i32 4>
>  %348 = add <4 x i32> %347, <i32 0, i32 1, i32 2, i32 3>
>  %349 = bitcast <4 x float>* %temp_array to float*
>  %350 = extractelement <4 x i32> %348, i32 0
>  %scatter_ptr75 = getelementptr float* %349, i32 %350
>  %scatter_val76 = extractelement <4 x float> %310, i32 0
>  %scatter_pred77 = extractelement <4 x i32> %maskfull43, i32 0
>  %351 = load float* %scatter_ptr75
>  %352 = trunc i32 %scatter_pred77 to i1
>  %353 = select i1 %352, float %scatter_val76, float %351
>  store float %353, float* %scatter_ptr75
>  %354 = extractelement <4 x i32> %348, i32 1
>  %scatter_ptr78 = getelementptr float* %349, i32 %354
>  %scatter_val79 = extractelement <4 x float> %310, i32 1
>  %scatter_pred80 = extractelement <4 x i32> %maskfull43, i32 1
>  %355 = load float* %scatter_ptr78
>  %356 = trunc i32 %scatter_pred80 to i1
>  %357 = select i1 %356, float %scatter_val79, float %355
>  store float %357, float* %scatter_ptr78
>  %358 = extractelement <4 x i32> %348, i32 2
>  %scatter_ptr81 = getelementptr float* %349, i32 %358
>  %scatter_val82 = extractelement <4 x float> %310, i32 2
>  %scatter_pred83 = extractelement <4 x i32> %maskfull43, i32 2
>  %359 = load float* %scatter_ptr81
>  %360 = trunc i32 %scatter_pred83 to i1
>  %361 = select i1 %360, float %scatter_val82, float %359
>  store float %361, float* %scatter_ptr81
>  %362 = extractelement <4 x i32> %348, i32 3
>  %scatter_ptr84 = getelementptr float* %349, i32 %362
>  %scatter_val85 = extractelement <4 x float> %310, i32 3
>  %scatter_pred86 = extractelement <4 x i32> %maskfull43, i32 3
>  %363 = load float* %scatter_ptr84
>  %364 = trunc i32 %scatter_pred86 to i1
>  %365 = select i1 %364, float %scatter_val85, float %363
>  store float %365, float* %scatter_ptr84
>  %366 = getelementptr <4 x float>* %temp_array, i32 16
>  %367 = bitcast <4 x float>* %366 to <4 x i32>*
>  %368 = load <4 x i32>* %367
>  %369 = add <4 x i32> %368, <i32 1, i32 1, i32 1, i32 1>
>  %370 = getelementptr <4 x float>* %temp_array, i32 16
>  %371 = bitcast <4 x float>* %370 to <4 x i32>*
>  %372 = load <4 x i32>* %371
>  %373 = and <4 x i32> %369, %maskfull43
>  %374 = xor <4 x i32> %maskfull43, <i32 -1, i32 -1, i32 -1, i32 -1>
>  %375 = and <4 x i32> %372, %374
>  %376 = or <4 x i32> %373, %375
>  store <4 x i32> %376, <4 x i32>* %371
>  %maskcb87 = and <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %break_full
>  %maskfull88 = and <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %maskcb87
>  store <4 x i32> %break_full, <4 x i32>* %0
>  %377 = load i32* %looplimiter
>  %378 = sub i32 %377, 1
>  store i32 %378, i32* %looplimiter
>  %379 = bitcast <4 x i32> %maskfull88 to i128
>  %380 = icmp ne i128 %379, 0
>  %381 = icmp sgt i32 %378, 0
>  %382 = and i1 %380, %381
>  br i1 %382, label %bgnloop, label %endloop
>
>endloop:                                          ; preds = %bgnloop
>  %383 = getelementptr <4 x float>* %temp_array, i32 44
>  %384 = load <4 x float>* %383
>  %385 = getelementptr <4 x float>* %temp_array, i32 45
>  %386 = load <4 x float>* %385
>  %387 = getelementptr <4 x float>* %temp_array, i32 80
>  store <4 x float> %384, <4 x float>* %387
>  %388 = getelementptr <4 x float>* %temp_array, i32 81
>  store <4 x float> %386, <4 x float>* %388
>  %389 = getelementptr <4 x float>* %temp_array, i32 48
>  %390 = load <4 x float>* %389
>  %391 = getelementptr <4 x float>* %temp_array, i32 49
>  %392 = load <4 x float>* %391
>  %393 = getelementptr <4 x float>* %temp_array, i32 82
>  store <4 x float> %390, <4 x float>* %393
>  %394 = getelementptr <4 x float>* %temp_array, i32 83
>  store <4 x float> %392, <4 x float>* %394
>  %395 = getelementptr <4 x float>* %temp_array, i32 52
>  %396 = load <4 x float>* %395
>  %397 = getelementptr <4 x float>* %temp_array, i32 53
>  %398 = load <4 x float>* %397
>  %399 = getelementptr <4 x float>* %temp_array, i32 84
>  store <4 x float> %396, <4 x float>* %399
>  %400 = getelementptr <4 x float>* %temp_array, i32 85
>  store <4 x float> %398, <4 x float>* %400
>  %401 = getelementptr <4 x float>* %temp_array, i32 56
>  %402 = load <4 x float>* %401
>  %403 = getelementptr <4 x float>* %temp_array, i32 57
>  %404 = load <4 x float>* %403
>  %405 = getelementptr <4 x float>* %temp_array, i32 86
>  store <4 x float> %402, <4 x float>* %405
>  %406 = getelementptr <4 x float>* %temp_array, i32 87
>  store <4 x float> %404, <4 x float>* %406
>  %407 = getelementptr <4 x float>* %temp_array, i32 60
>  %408 = load <4 x float>* %407
>  %409 = getelementptr <4 x float>* %temp_array, i32 61
>  %410 = load <4 x float>* %409
>  %411 = getelementptr <4 x float>* %temp_array, i32 88
>  store <4 x float> %408, <4 x float>* %411
>  %412 = getelementptr <4 x float>* %temp_array, i32 89
>  store <4 x float> %410, <4 x float>* %412
>  %413 = getelementptr <4 x float>* %temp_array, i32 64
>  %414 = load <4 x float>* %413
>  %415 = getelementptr <4 x float>* %temp_array, i32 65
>  %416 = load <4 x float>* %415
>  %417 = getelementptr <4 x float>* %temp_array, i32 90
>  store <4 x float> %414, <4 x float>* %417
>  %418 = getelementptr <4 x float>* %temp_array, i32 91
>  store <4 x float> %416, <4 x float>* %418
>  %419 = getelementptr <4 x float>* %temp_array, i32 68
>  %420 = load <4 x float>* %419
>  %421 = getelementptr <4 x float>* %temp_array, i32 69
>  %422 = load <4 x float>* %421
>  %423 = getelementptr <4 x float>* %temp_array, i32 92
>  store <4 x float> %420, <4 x float>* %423
>  %424 = getelementptr <4 x float>* %temp_array, i32 93
>  store <4 x float> %422, <4 x float>* %424
>  %425 = getelementptr <4 x float>* %temp_array, i32 72
>  %426 = load <4 x float>* %425
>  %427 = getelementptr <4 x float>* %temp_array, i32 73
>  %428 = load <4 x float>* %427
>  %429 = getelementptr <4 x float>* %temp_array, i32 94
>  store <4 x float> %426, <4 x float>* %429
>  %430 = getelementptr <4 x float>* %temp_array, i32 95
>  store <4 x float> %428, <4 x float>* %430
>  %431 = getelementptr <4 x float>* %temp_array, i32 80
>  %432 = load <4 x float>* %431
>  %433 = getelementptr <4 x float>* %temp_array, i32 81
>  %434 = load <4 x float>* %433
>  %435 = getelementptr <4 x float>* %temp_array, i32 82
>  %436 = load <4 x float>* %435
>  %437 = getelementptr <4 x float>* %temp_array, i32 83
>  %438 = load <4 x float>* %437
>  store <4 x float> %432, <4 x float>* %output19
>  store <4 x float> %434, <4 x float>* %output20
>  store <4 x float> %436, <4 x float>* %output21
>  store <4 x float> %438, <4 x float>* %output22
>  %439 = getelementptr <4 x float>* %temp_array, i32 84
>  %440 = load <4 x float>* %439
>  %441 = getelementptr <4 x float>* %temp_array, i32 85
>  %442 = load <4 x float>* %441
>  %443 = getelementptr <4 x float>* %temp_array, i32 86
>  %444 = load <4 x float>* %443
>  %445 = getelementptr <4 x float>* %temp_array, i32 87
>  %446 = load <4 x float>* %445
>  store <4 x float> %440, <4 x float>* %output23
>  store <4 x float> %442, <4 x float>* %output24
>  store <4 x float> %444, <4 x float>* %output25
>  store <4 x float> %446, <4 x float>* %output26
>  %447 = getelementptr <4 x float>* %temp_array, i32 88
>  %448 = load <4 x float>* %447
>  %449 = getelementptr <4 x float>* %temp_array, i32 89
>  %450 = load <4 x float>* %449
>  %451 = getelementptr <4 x float>* %temp_array, i32 90
>  %452 = load <4 x float>* %451
>  %453 = getelementptr <4 x float>* %temp_array, i32 91
>  %454 = load <4 x float>* %453
>  store <4 x float> %448, <4 x float>* %output27
>  store <4 x float> %450, <4 x float>* %output28
>  store <4 x float> %452, <4 x float>* %output29
>  store <4 x float> %454, <4 x float>* %output30
>  %455 = getelementptr <4 x float>* %temp_array, i32 12
>  %456 = load <4 x float>* %455
>  %457 = getelementptr <4 x float>* %temp_array, i32 13
>  %458 = load <4 x float>* %457
>  %459 = getelementptr <4 x float>* %temp_array, i32 14
>  %460 = load <4 x float>* %459
>  %461 = getelementptr <4 x float>* %temp_array, i32 15
>  %462 = load <4 x float>* %461
>  store <4 x float> %456, <4 x float>* %output
>  store <4 x float> %458, <4 x float>* %output16
>  store <4 x float> %460, <4 x float>* %output17
>  store <4 x float> %462, <4 x float>* %output18
>  %463 = getelementptr <4 x float>* %temp_array, i32 92
>  %464 = load <4 x float>* %463
>  %465 = getelementptr <4 x float>* %temp_array, i32 93
>  %466 = load <4 x float>* %465
>  %467 = getelementptr <4 x float>* %temp_array, i32 94
>  %468 = load <4 x float>* %467
>  %469 = getelementptr <4 x float>* %temp_array, i32 95
>  %470 = load <4 x float>* %469
>  store <4 x float> %464, <4 x float>* %output31
>  store <4 x float> %466, <4 x float>* %output32
>  store <4 x float> %468, <4 x float>* %output33
>  store <4 x float> %470, <4 x float>* %output34
>  %471 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 0
>  %472 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 1
>  %473 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 2
>  %474 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 3
>  %475 = load <4 x float>* %output
>  %476 = load <4 x float>* %output16
>  %477 = load <4 x float>* %output17
>  %478 = load <4 x float>* %output18
>  %.clip_ptr = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %471, i32 0, i32 1
>  %.clip_ptr89 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %472, i32 0, i32 1
>  %.clip_ptr90 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %473, i32 0, i32 1
>  %.clip_ptr91 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %474, i32 0, i32 1
>  %479 = shufflevector <4 x float> %475, <4 x float> %476, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %480 = shufflevector <4 x float> %477, <4 x float> %478, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %481 = shufflevector <4 x float> %475, <4 x float> %476, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %482 = shufflevector <4 x float> %477, <4 x float> %478, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %t092 = bitcast <4 x float> %479 to <2 x double>
>  %t193 = bitcast <4 x float> %480 to <2 x double>
>  %t294 = bitcast <4 x float> %481 to <2 x double>
>  %t395 = bitcast <4 x float> %482 to <2 x double>
>  %483 = shufflevector <2 x double> %t092, <2 x double> %t193, <2 x i32> <i32 0, i32 2>
>  %484 = shufflevector <2 x double> %t092, <2 x double> %t193, <2 x i32> <i32 1, i32 3>
>  %485 = shufflevector <2 x double> %t294, <2 x double> %t395, <2 x i32> <i32 0, i32 2>
>  %486 = shufflevector <2 x double> %t294, <2 x double> %t395, <2 x i32> <i32 1, i32 3>
>  %dst096 = bitcast <2 x double> %483 to <4 x float>
>  %dst197 = bitcast <2 x double> %484 to <4 x float>
>  %dst298 = bitcast <2 x double> %485 to <4 x float>
>  %dst399 = bitcast <2 x double> %486 to <4 x float>
>  %487 = shufflevector <4 x float> %dst096, <4 x float> %dst096, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
>  %488 = shufflevector <4 x float> %dst197, <4 x float> %dst197, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
>  %489 = shufflevector <4 x float> %dst298, <4 x float> %dst298, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
>  %490 = shufflevector <4 x float> %dst399, <4 x float> %dst399, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
>  %clipo = getelementptr [4 x float]* %.clip_ptr, i32 0, i32 0
>  %491 = bitcast float* %clipo to <4 x float>*
>  store <4 x float> %487, <4 x float>* %491, align 4
>  %clipo100 = getelementptr [4 x float]* %.clip_ptr89, i32 0, i32 0
>  %492 = bitcast float* %clipo100 to <4 x float>*
>  store <4 x float> %488, <4 x float>* %492, align 4
>  %clipo101 = getelementptr [4 x float]* %.clip_ptr90, i32 0, i32 0
>  %493 = bitcast float* %clipo101 to <4 x float>*
>  store <4 x float> %489, <4 x float>* %493, align 4
>  %clipo102 = getelementptr [4 x float]* %.clip_ptr91, i32 0, i32 0
>  %494 = bitcast float* %clipo102 to <4 x float>*
>  store <4 x float> %490, <4 x float>* %494, align 4
>  %495 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 0
>  %496 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 1
>  %497 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 2
>  %498 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 3
>  %499 = load <4 x float>* %output
>  %500 = load <4 x float>* %output16
>  %501 = load <4 x float>* %output17
>  %502 = load <4 x float>* %output18
>  %.pre_clip_pos_ptr = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %495, i32 0, i32 2
>  %.pre_clip_pos_ptr103 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %496, i32 0, i32 2
>  %.pre_clip_pos_ptr104 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %497, i32 0, i32 2
>  %.pre_clip_pos_ptr105 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %498, i32 0, i32 2
>  %503 = shufflevector <4 x float> %499, <4 x float> %500, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %504 = shufflevector <4 x float> %501, <4 x float> %502, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %505 = shufflevector <4 x float> %499, <4 x float> %500, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %506 = shufflevector <4 x float> %501, <4 x float> %502, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %t0106 = bitcast <4 x float> %503 to <2 x double>
>  %t1107 = bitcast <4 x float> %504 to <2 x double>
>  %t2108 = bitcast <4 x float> %505 to <2 x double>
>  %t3109 = bitcast <4 x float> %506 to <2 x double>
>  %507 = shufflevector <2 x double> %t0106, <2 x double> %t1107, <2 x i32> <i32 0, i32 2>
>  %508 = shufflevector <2 x double> %t0106, <2 x double> %t1107, <2 x i32> <i32 1, i32 3>
>  %509 = shufflevector <2 x double> %t2108, <2 x double> %t3109, <2 x i32> <i32 0, i32 2>
>  %510 = shufflevector <2 x double> %t2108, <2 x double> %t3109, <2 x i32> <i32 1, i32 3>
>  %dst0110 = bitcast <2 x double> %507 to <4 x float>
>  %dst1111 = bitcast <2 x double> %508 to <4 x float>
>  %dst2112 = bitcast <2 x double> %509 to <4 x float>
>  %dst3113 = bitcast <2 x double> %510 to <4 x float>
>  %511 = shufflevector <4 x float> %dst0110, <4 x float> %dst0110, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
>  %512 = shufflevector <4 x float> %dst1111, <4 x float> %dst1111, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
>  %513 = shufflevector <4 x float> %dst2112, <4 x float> %dst2112, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
>  %514 = shufflevector <4 x float> %dst3113, <4 x float> %dst3113, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
>  %clipo114 = getelementptr [4 x float]* %.pre_clip_pos_ptr, i32 0, i32 0
>  %515 = bitcast float* %clipo114 to <4 x float>*
>  store <4 x float> %511, <4 x float>* %515, align 4
>  %clipo115 = getelementptr [4 x float]* %.pre_clip_pos_ptr103, i32 0, i32 0
>  %516 = bitcast float* %clipo115 to <4 x float>*
>  store <4 x float> %512, <4 x float>* %516, align 4
>  %clipo116 = getelementptr [4 x float]* %.pre_clip_pos_ptr104, i32 0, i32 0
>  %517 = bitcast float* %clipo116 to <4 x float>*
>  store <4 x float> %513, <4 x float>* %517, align 4
>  %clipo117 = getelementptr [4 x float]* %.pre_clip_pos_ptr105, i32 0, i32 0
>  %518 = bitcast float* %clipo117 to <4 x float>*
>  store <4 x float> %514, <4 x float>* %518, align 4
>  %519 = load <4 x i32>* %1
>  %520 = load <4 x float>* %output
>  %521 = load <4 x float>* %output16
>  %522 = load <4 x float>* %output17
>  %523 = load <4 x float>* %output18
>  %524 = fcmp ugt <4 x float> %520, %523
>  %525 = sext <4 x i1> %524 to <4 x i32>
>  %526 = and <4 x i32> %525, <i32 1, i32 1, i32 1, i32 1>
>  %527 = fadd <4 x float> %520, %523
>  %528 = fcmp ugt <4 x float> zeroinitializer, %527
>  %529 = sext <4 x i1> %528 to <4 x i32>
>  %530 = and <4 x i32> %529, <i32 2, i32 2, i32 2, i32 2>
>  %531 = or <4 x i32> %526, %530
>  %532 = fcmp ugt <4 x float> %521, %523
>  %533 = sext <4 x i1> %532 to <4 x i32>
>  %534 = and <4 x i32> %533, <i32 4, i32 4, i32 4, i32 4>
>  %535 = or <4 x i32> %531, %534
>  %536 = fadd <4 x float> %521, %523
>  %537 = fcmp ugt <4 x float> zeroinitializer, %536
>  %538 = sext <4 x i1> %537 to <4 x i32>
>  %539 = and <4 x i32> %538, <i32 8, i32 8, i32 8, i32 8>
>  %540 = or <4 x i32> %535, %539
>  %541 = fadd <4 x float> %522, %523
>  %542 = fcmp ugt <4 x float> zeroinitializer, %541
>  %543 = sext <4 x i1> %542 to <4 x i32>
>  %544 = and <4 x i32> %543, <i32 16, i32 16, i32 16, i32 16>
>  %545 = or <4 x i32> %540, %544
>  %546 = fcmp ugt <4 x float> %522, %523
>  %547 = sext <4 x i1> %546 to <4 x i32>
>  %548 = and <4 x i32> %547, <i32 32, i32 32, i32 32, i32 32>
>  %549 = or <4 x i32> %545, %548
>  %550 = or <4 x i32> %549, %519
>  store <4 x i32> %550, <4 x i32>* %1
>  %551 = load <4 x float>* %output18
>  %context.viewport_ptr = getelementptr { [16 x float*], [16 x float*], [14 x [4 x float]]*, float*, [32 x { i32, i32, i32, i32, i32, i8*, [16 x i32], [16 x i32], [16 x i32] }], [16 x { float, float, float, [4 x float] }] }* %context, i32 0, i32 3
>  %context.viewport = load float** %context.viewport_ptr
>  %552 = fdiv <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, %551
>  store <4 x float> %552, <4 x float>* %output18
>  %553 = load <4 x float>* %output
>  %554 = getelementptr float* %context.viewport, i32 0
>  %555 = getelementptr float* %context.viewport, i32 4
>  %scale = load float* %554
>  %556 = insertelement <4 x float> undef, float %scale, i32 0
>  %557 = shufflevector <4 x float> %556, <4 x float> undef, <4 x i32> zeroinitializer
>  %trans = load float* %555
>  %558 = insertelement <4 x float> undef, float %trans, i32 0
>  %559 = shufflevector <4 x float> %558, <4 x float> undef, <4 x i32> zeroinitializer
>  %560 = fmul <4 x float> %553, %552
>  %561 = fmul <4 x float> %560, %557
>  %562 = fadd <4 x float> %561, %559
>  store <4 x float> %562, <4 x float>* %output
>  %563 = load <4 x float>* %output16
>  %564 = getelementptr float* %context.viewport, i32 1
>  %565 = getelementptr float* %context.viewport, i32 5
>  %scale118 = load float* %564
>  %566 = insertelement <4 x float> undef, float %scale118, i32 0
>  %567 = shufflevector <4 x float> %566, <4 x float> undef, <4 x i32> zeroinitializer
>  %trans119 = load float* %565
>  %568 = insertelement <4 x float> undef, float %trans119, i32 0
>  %569 = shufflevector <4 x float> %568, <4 x float> undef, <4 x i32> zeroinitializer
>  %570 = fmul <4 x float> %563, %552
>  %571 = fmul <4 x float> %570, %567
>  %572 = fadd <4 x float> %571, %569
>  store <4 x float> %572, <4 x float>* %output16
>  %573 = load <4 x float>* %output17
>  %574 = getelementptr float* %context.viewport, i32 2
>  %575 = getelementptr float* %context.viewport, i32 6
>  %scale120 = load float* %574
>  %576 = insertelement <4 x float> undef, float %scale120, i32 0
>  %577 = shufflevector <4 x float> %576, <4 x float> undef, <4 x i32> zeroinitializer
>  %trans121 = load float* %575
>  %578 = insertelement <4 x float> undef, float %trans121, i32 0
>  %579 = shufflevector <4 x float> %578, <4 x float> undef, <4 x i32> zeroinitializer
>  %580 = fmul <4 x float> %573, %552
>  %581 = fmul <4 x float> %580, %577
>  %582 = fadd <4 x float> %581, %579
>  store <4 x float> %582, <4 x float>* %output17
>  %output0.x = load <4 x float>* %output
>  %output0.y = load <4 x float>* %output16
>  %output0.z = load <4 x float>* %output17
>  %output0.w = load <4 x float>* %output18
>  %583 = shufflevector <4 x float> %output0.x, <4 x float> %output0.y, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %584 = shufflevector <4 x float> %output0.z, <4 x float> %output0.w, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %585 = shufflevector <4 x float> %output0.x, <4 x float> %output0.y, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %586 = shufflevector <4 x float> %output0.z, <4 x float> %output0.w, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %t0122 = bitcast <4 x float> %583 to <2 x double>
>  %t1123 = bitcast <4 x float> %584 to <2 x double>
>  %t2124 = bitcast <4 x float> %585 to <2 x double>
>  %t3125 = bitcast <4 x float> %586 to <2 x double>
>  %587 = shufflevector <2 x double> %t0122, <2 x double> %t1123, <2 x i32> <i32 0, i32 2>
>  %588 = shufflevector <2 x double> %t0122, <2 x double> %t1123, <2 x i32> <i32 1, i32 3>
>  %589 = shufflevector <2 x double> %t2124, <2 x double> %t3125, <2 x i32> <i32 0, i32 2>
>  %590 = shufflevector <2 x double> %t2124, <2 x double> %t3125, <2 x i32> <i32 1, i32 3>
>  %dst0126 = bitcast <2 x double> %587 to <4 x float>
>  %dst1127 = bitcast <2 x double> %588 to <4 x float>
>  %dst2128 = bitcast <2 x double> %589 to <4 x float>
>  %dst3129 = bitcast <2 x double> %590 to <4 x float>
>  %591 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 0
>  %592 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 1
>  %593 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 2
>  %594 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 3
>  %595 = or <4 x i32> <i32 -49152, i32 -49152, i32 -49152, i32 -49152>, %549
>  %.id_ptr = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %591, i32 0, i32 0
>  %596 = extractelement <4 x i32> %595, i32 0
>  store i32 %596, i32* %.id_ptr
>  %.id_ptr130 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %592, i32 0, i32 0
>  %597 = extractelement <4 x i32> %595, i32 1
>  store i32 %597, i32* %.id_ptr130
>  %.id_ptr131 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %593, i32 0, i32 0
>  %598 = extractelement <4 x i32> %595, i32 2
>  store i32 %598, i32* %.id_ptr131
>  %.id_ptr132 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %594, i32 0, i32 0
>  %599 = extractelement <4 x i32> %595, i32 3
>  store i32 %599, i32* %.id_ptr132
>  %.data_ptr = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %591, i32 0, i32 3
>  %600 = getelementptr [6 x [4 x float]]* %.data_ptr, i32 0, i32 0, i32 0
>  %601 = bitcast float* %600 to <4 x float>*
>  store <4 x float> %dst0126, <4 x float>* %601, align 4
>  %.data_ptr133 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %592, i32 0, i32 3
>  %602 = getelementptr [6 x [4 x float]]* %.data_ptr133, i32 0, i32 0, i32 0
>  %603 = bitcast float* %602 to <4 x float>*
>  store <4 x float> %dst1127, <4 x float>* %603, align 4
>  %.data_ptr134 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %593, i32 0, i32 3
>  %604 = getelementptr [6 x [4 x float]]* %.data_ptr134, i32 0, i32 0, i32 0
>  %605 = bitcast float* %604 to <4 x float>*
>  store <4 x float> %dst2128, <4 x float>* %605, align 4
>  %.data_ptr135 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %594, i32 0, i32 3
>  %606 = getelementptr [6 x [4 x float]]* %.data_ptr135, i32 0, i32 0, i32 0
>  %607 = bitcast float* %606 to <4 x float>*
>  store <4 x float> %dst3129, <4 x float>* %607, align 4
>  %output1.x = load <4 x float>* %output19
>  %output1.y = load <4 x float>* %output20
>  %output1.z = load <4 x float>* %output21
>  %output1.w = load <4 x float>* %output22
>  %608 = shufflevector <4 x float> %output1.x, <4 x float> %output1.y, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %609 = shufflevector <4 x float> %output1.z, <4 x float> %output1.w, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %610 = shufflevector <4 x float> %output1.x, <4 x float> %output1.y, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %611 = shufflevector <4 x float> %output1.z, <4 x float> %output1.w, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %t0136 = bitcast <4 x float> %608 to <2 x double>
>  %t1137 = bitcast <4 x float> %609 to <2 x double>
>  %t2138 = bitcast <4 x float> %610 to <2 x double>
>  %t3139 = bitcast <4 x float> %611 to <2 x double>
>  %612 = shufflevector <2 x double> %t0136, <2 x double> %t1137, <2 x i32> <i32 0, i32 2>
>  %613 = shufflevector <2 x double> %t0136, <2 x double> %t1137, <2 x i32> <i32 1, i32 3>
>  %614 = shufflevector <2 x double> %t2138, <2 x double> %t3139, <2 x i32> <i32 0, i32 2>
>  %615 = shufflevector <2 x double> %t2138, <2 x double> %t3139, <2 x i32> <i32 1, i32 3>
>  %dst0140 = bitcast <2 x double> %612 to <4 x float>
>  %dst1141 = bitcast <2 x double> %613 to <4 x float>
>  %dst2142 = bitcast <2 x double> %614 to <4 x float>
>  %dst3143 = bitcast <2 x double> %615 to <4 x float>
>  %616 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 0
>  %617 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 1
>  %618 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 2
>  %619 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 3
>  %.data_ptr144 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %616, i32 0, i32 3
>  %620 = getelementptr [6 x [4 x float]]* %.data_ptr144, i32 0, i32 1, i32 0
>  %621 = bitcast float* %620 to <4 x float>*
>  store <4 x float> %dst0140, <4 x float>* %621, align 4
>  %.data_ptr145 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %617, i32 0, i32 3
>  %622 = getelementptr [6 x [4 x float]]* %.data_ptr145, i32 0, i32 1, i32 0
>  %623 = bitcast float* %622 to <4 x float>*
>  store <4 x float> %dst1141, <4 x float>* %623, align 4
>  %.data_ptr146 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %618, i32 0, i32 3
>  %624 = getelementptr [6 x [4 x float]]* %.data_ptr146, i32 0, i32 1, i32 0
>  %625 = bitcast float* %624 to <4 x float>*
>  store <4 x float> %dst2142, <4 x float>* %625, align 4
>  %.data_ptr147 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %619, i32 0, i32 3
>  %626 = getelementptr [6 x [4 x float]]* %.data_ptr147, i32 0, i32 1, i32 0
>  %627 = bitcast float* %626 to <4 x float>*
>  store <4 x float> %dst3143, <4 x float>* %627, align 4
>  %output2.x = load <4 x float>* %output23
>  %output2.y = load <4 x float>* %output24
>  %output2.z = load <4 x float>* %output25
>  %output2.w = load <4 x float>* %output26
>  %628 = shufflevector <4 x float> %output2.x, <4 x float> %output2.y, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %629 = shufflevector <4 x float> %output2.z, <4 x float> %output2.w, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %630 = shufflevector <4 x float> %output2.x, <4 x float> %output2.y, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %631 = shufflevector <4 x float> %output2.z, <4 x float> %output2.w, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %t0148 = bitcast <4 x float> %628 to <2 x double>
>  %t1149 = bitcast <4 x float> %629 to <2 x double>
>  %t2150 = bitcast <4 x float> %630 to <2 x double>
>  %t3151 = bitcast <4 x float> %631 to <2 x double>
>  %632 = shufflevector <2 x double> %t0148, <2 x double> %t1149, <2 x i32> <i32 0, i32 2>
>  %633 = shufflevector <2 x double> %t0148, <2 x double> %t1149, <2 x i32> <i32 1, i32 3>
>  %634 = shufflevector <2 x double> %t2150, <2 x double> %t3151, <2 x i32> <i32 0, i32 2>
>  %635 = shufflevector <2 x double> %t2150, <2 x double> %t3151, <2 x i32> <i32 1, i32 3>
>  %dst0152 = bitcast <2 x double> %632 to <4 x float>
>  %dst1153 = bitcast <2 x double> %633 to <4 x float>
>  %dst2154 = bitcast <2 x double> %634 to <4 x float>
>  %dst3155 = bitcast <2 x double> %635 to <4 x float>
>  %636 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 0
>  %637 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 1
>  %638 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 2
>  %639 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 3
>  %.data_ptr156 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %636, i32 0, i32 3
>  %640 = getelementptr [6 x [4 x float]]* %.data_ptr156, i32 0, i32 2, i32 0
>  %641 = bitcast float* %640 to <4 x float>*
>  store <4 x float> %dst0152, <4 x float>* %641, align 4
>  %.data_ptr157 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %637, i32 0, i32 3
>  %642 = getelementptr [6 x [4 x float]]* %.data_ptr157, i32 0, i32 2, i32 0
>  %643 = bitcast float* %642 to <4 x float>*
>  store <4 x float> %dst1153, <4 x float>* %643, align 4
>  %.data_ptr158 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %638, i32 0, i32 3
>  %644 = getelementptr [6 x [4 x float]]* %.data_ptr158, i32 0, i32 2, i32 0
>  %645 = bitcast float* %644 to <4 x float>*
>  store <4 x float> %dst2154, <4 x float>* %645, align 4
>  %.data_ptr159 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %639, i32 0, i32 3
>  %646 = getelementptr [6 x [4 x float]]* %.data_ptr159, i32 0, i32 2, i32 0
>  %647 = bitcast float* %646 to <4 x float>*
>  store <4 x float> %dst3155, <4 x float>* %647, align 4
>  %output3.x = load <4 x float>* %output27
>  %output3.y = load <4 x float>* %output28
>  %output3.z = load <4 x float>* %output29
>  %output3.w = load <4 x float>* %output30
>  %648 = shufflevector <4 x float> %output3.x, <4 x float> %output3.y, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %649 = shufflevector <4 x float> %output3.z, <4 x float> %output3.w, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %650 = shufflevector <4 x float> %output3.x, <4 x float> %output3.y, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %651 = shufflevector <4 x float> %output3.z, <4 x float> %output3.w, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %t0160 = bitcast <4 x float> %648 to <2 x double>
>  %t1161 = bitcast <4 x float> %649 to <2 x double>
>  %t2162 = bitcast <4 x float> %650 to <2 x double>
>  %t3163 = bitcast <4 x float> %651 to <2 x double>
>  %652 = shufflevector <2 x double> %t0160, <2 x double> %t1161, <2 x i32> <i32 0, i32 2>
>  %653 = shufflevector <2 x double> %t0160, <2 x double> %t1161, <2 x i32> <i32 1, i32 3>
>  %654 = shufflevector <2 x double> %t2162, <2 x double> %t3163, <2 x i32> <i32 0, i32 2>
>  %655 = shufflevector <2 x double> %t2162, <2 x double> %t3163, <2 x i32> <i32 1, i32 3>
>  %dst0164 = bitcast <2 x double> %652 to <4 x float>
>  %dst1165 = bitcast <2 x double> %653 to <4 x float>
>  %dst2166 = bitcast <2 x double> %654 to <4 x float>
>  %dst3167 = bitcast <2 x double> %655 to <4 x float>
>  %656 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 0
>  %657 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 1
>  %658 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 2
>  %659 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 3
>  %.data_ptr168 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %656, i32 0, i32 3
>  %660 = getelementptr [6 x [4 x float]]* %.data_ptr168, i32 0, i32 3, i32 0
>  %661 = bitcast float* %660 to <4 x float>*
>  store <4 x float> %dst0164, <4 x float>* %661, align 4
>  %.data_ptr169 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %657, i32 0, i32 3
>  %662 = getelementptr [6 x [4 x float]]* %.data_ptr169, i32 0, i32 3, i32 0
>  %663 = bitcast float* %662 to <4 x float>*
>  store <4 x float> %dst1165, <4 x float>* %663, align 4
>  %.data_ptr170 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %658, i32 0, i32 3
>  %664 = getelementptr [6 x [4 x float]]* %.data_ptr170, i32 0, i32 3, i32 0
>  %665 = bitcast float* %664 to <4 x float>*
>  store <4 x float> %dst2166, <4 x float>* %665, align 4
>  %.data_ptr171 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %659, i32 0, i32 3
>  %666 = getelementptr [6 x [4 x float]]* %.data_ptr171, i32 0, i32 3, i32 0
>  %667 = bitcast float* %666 to <4 x float>*
>  store <4 x float> %dst3167, <4 x float>* %667, align 4
>  %output4.x = load <4 x float>* %output31
>  %output4.y = load <4 x float>* %output32
>  %output4.z = load <4 x float>* %output33
>  %output4.w = load <4 x float>* %output34
>  %668 = shufflevector <4 x float> %output4.x, <4 x float> %output4.y, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %669 = shufflevector <4 x float> %output4.z, <4 x float> %output4.w, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
>  %670 = shufflevector <4 x float> %output4.x, <4 x float> %output4.y, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %671 = shufflevector <4 x float> %output4.z, <4 x float> %output4.w, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
>  %t0172 = bitcast <4 x float> %668 to <2 x double>
>  %t1173 = bitcast <4 x float> %669 to <2 x double>
>  %t2174 = bitcast <4 x float> %670 to <2 x double>
>  %t3175 = bitcast <4 x float> %671 to <2 x double>
>  %672 = shufflevector <2 x double> %t0172, <2 x double> %t1173, <2 x i32> <i32 0, i32 2>
>  %673 = shufflevector <2 x double> %t0172, <2 x double> %t1173, <2 x i32> <i32 1, i32 3>
>  %674 = shufflevector <2 x double> %t2174, <2 x double> %t3175, <2 x i32> <i32 0, i32 2>
>  %675 = shufflevector <2 x double> %t2174, <2 x double> %t3175, <2 x i32> <i32 1, i32 3>
>  %dst0176 = bitcast <2 x double> %672 to <4 x float>
>  %dst1177 = bitcast <2 x double> %673 to <4 x float>
>  %dst2178 = bitcast <2 x double> %674 to <4 x float>
>  %dst3179 = bitcast <2 x double> %675 to <4 x float>
>  %676 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 0
>  %677 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 1
>  %678 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 2
>  %679 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %5, i32 3
>  %.data_ptr180 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %676, i32 0, i32 3
>  %680 = getelementptr [6 x [4 x float]]* %.data_ptr180, i32 0, i32 4, i32 0
>  %681 = bitcast float* %680 to <4 x float>*
>  store <4 x float> %dst0176, <4 x float>* %681, align 4
>  %.data_ptr181 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %677, i32 0, i32 3
>  %682 = getelementptr [6 x [4 x float]]* %.data_ptr181, i32 0, i32 4, i32 0
>  %683 = bitcast float* %682 to <4 x float>*
>  store <4 x float> %dst1177, <4 x float>* %683, align 4
>  %.data_ptr182 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %678, i32 0, i32 3
>  %684 = getelementptr [6 x [4 x float]]* %.data_ptr182, i32 0, i32 4, i32 0
>  %685 = bitcast float* %684 to <4 x float>*
>  store <4 x float> %dst2178, <4 x float>* %685, align 4
>  %.data_ptr183 = getelementptr { i32, [4 x float], [4 x float], [6 x [4 x float]] }* %679, i32 0, i32 3
>  %686 = getelementptr [6 x [4 x float]]* %.data_ptr183, i32 0, i32 4, i32 0
>  %687 = bitcast float* %686 to <4 x float>*
>  store <4 x float> %dst3179, <4 x float>* %687, align 4
>  %688 = add i32 %3, 4
>  store i32 %688, i32* %loop_counter
>  %689 = icmp uge i32 %688, %2
>  br i1 %689, label %loop_end, label %loop_begin
>
>loop_end:                                         ; preds = %endloop
>  %690 = load i32* %loop_counter
>  %691 = load <4 x i32>* %1
>  %692 = extractelement <4 x i32> %691, i32 0
>  %693 = or i32 0, %692
>  %694 = extractelement <4 x i32> %691, i32 1
>  %695 = or i32 %693, %694
>  %696 = extractelement <4 x i32> %691, i32 2
>  %697 = or i32 %695, %696
>  %698 = extractelement <4 x i32> %691, i32 3
>  %699 = or i32 %697, %698
>  ret i32 %699
>}
>
>src/gallium/auxiliary/gallivm/lp_bld_init.c:587:gallivm_verify_function: Assertion `0' failed.

Actions: View

Attachments on bug 61036: 75019 | 75025 | 75081

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.