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.