libGL error: MESA-LOADER: failed to open llvmpipe: /home/alyssa/mesa/build/src/gallium/targets/dri/llvmpipe_dri.so: cannot open shared object file: No such file or directory (search paths /home/alyssa/mesa/build/src/gallium/targets/dri, suffix _dri)
libGL error: failed to load driver: llvmpipe
Both operands to a binary operator are not of the same type!
  %188 = add <4 x i32> zeroinitializer, <4 x float> %18
Both operands to a binary operator are not of the same type!
  %410 = add <4 x i32> zeroinitializer, <4 x float> %26
Both operands to a binary operator are not of the same type!
  %632 = add <4 x i32> zeroinitializer, <4 x float> %34
define i32 @draw_llvm_gs_variant({ [14 x [4 x float]]*, float*, i32**, <4 x i32>*, <4 x i32>* }* noalias %0, { [16 x { i32*, i32 }], [32 x { i32*, i32 }], [128 x { i8*, i32, i32, i32, i32, i32, [16 x i32], [16 x i32], i32, i32, [16 x i32] }], [32 x { float, float, float, [4 x float], float }], [64 x { i8*, i32, i32, i32, i32, i32, i32, i32 }], float* }* noalias %1, [80 x [4 x <4 x float>]]* noalias %2, { i32, [4 x float], [2 x [4 x float]] }** noalias %3, i32 %4, i32 %5, <4 x i32>* noalias %6, i32 %7, i32 %8) {
entry:
  %reg = alloca [3 x [4 x <4 x i32>]], align 16
  %output10 = alloca <4 x float>, align 16
  %output9 = alloca <4 x float>, align 16
  %output8 = alloca <4 x float>, align 16
  %output7 = alloca <4 x float>, align 16
  %output6 = alloca <4 x float>, align 16
  %output5 = alloca <4 x float>, align 16
  %output4 = alloca <4 x float>, align 16
  %output3 = alloca <4 x float>, align 16
  %output2 = alloca <4 x float>, align 16
  %output1 = alloca <4 x float>, align 16
  %output = alloca <4 x float>, align 16
  %looplimiter = alloca i32, align 4
  %total_emitted_vertices_ptr = alloca <4 x i32>, align 16
  %emitted_vertices_ptr = alloca <4 x i32>, align 16
  %emitted_prims_ptr = alloca <4 x i32>, align 16
  %execution_mask = alloca <4 x i32>, align 16
  %9 = getelementptr { [16 x { i32*, i32 }], [32 x { i32*, i32 }], [128 x { i8*, i32, i32, i32, i32, i32, [16 x i32], [16 x i32], i32, i32, [16 x i32] }], [32 x { float, float, float, [4 x float], float }], [64 x { i8*, i32, i32, i32, i32, i32, i32, i32 }], float* }, { [16 x { i32*, i32 }], [32 x { i32*, i32 }], [128 x { i8*, i32, i32, i32, i32, i32, [16 x i32], [16 x i32], i32, i32, [16 x i32] }], [32 x { float, float, float, [4 x float], float }], [64 x { i8*, i32, i32, i32, i32, i32, i32, i32 }], float* }* %1, i32 0, i32 0
  %10 = getelementptr { [16 x { i32*, i32 }], [32 x { i32*, i32 }], [128 x { i8*, i32, i32, i32, i32, i32, [16 x i32], [16 x i32], i32, i32, [16 x i32] }], [32 x { float, float, float, [4 x float], float }], [64 x { i8*, i32, i32, i32, i32, i32, i32, i32 }], float* }, { [16 x { i32*, i32 }], [32 x { i32*, i32 }], [128 x { i8*, i32, i32, i32, i32, i32, [16 x i32], [16 x i32], i32, i32, [16 x i32] }], [32 x { float, float, float, [4 x float], float }], [64 x { i8*, i32, i32, i32, i32, i32, i32, i32 }], float* }* %1, i32 0, i32 1
  %11 = insertelement <4 x i32> undef, i32 %4, i32 0
  %12 = shufflevector <4 x i32> %11, <4 x i32> undef, <4 x i32> zeroinitializer
  %13 = icmp sgt <4 x i32> %12, <i32 0, i32 1, i32 2, i32 3>
  %14 = sext <4 x i1> %13 to <4 x i32>
  store <4 x i32> zeroinitializer, <4 x i32>* %execution_mask, align 16
  store <4 x i32> %14, <4 x i32>* %execution_mask, align 16
  %15 = getelementptr { [16 x { i32*, i32 }], [32 x { i32*, i32 }], [128 x { i8*, i32, i32, i32, i32, i32, [16 x i32], [16 x i32], i32, i32, [16 x i32] }], [32 x { float, float, float, [4 x float], float }], [64 x { i8*, i32, i32, i32, i32, i32, i32, i32 }], float* }, { [16 x { i32*, i32 }], [32 x { i32*, i32 }], [128 x { i8*, i32, i32, i32, i32, i32, [16 x i32], [16 x i32], i32, i32, [16 x i32] }], [32 x { float, float, float, [4 x float], float }], [64 x { i8*, i32, i32, i32, i32, i32, i32, i32 }], float* }* %1, i32 0, i32 5
  %16 = load float*, float** %15, align 8
  store <4 x i32> zeroinitializer, <4 x i32>* %emitted_prims_ptr, align 16
  store <4 x i32> zeroinitializer, <4 x i32>* %emitted_vertices_ptr, align 16
  store <4 x i32> zeroinitializer, <4 x i32>* %total_emitted_vertices_ptr, align 16
  store i32 0, i32* %looplimiter, align 4
  store i32 65535, i32* %looplimiter, align 4
  store <4 x float> zeroinitializer, <4 x float>* %output, align 16
  store <4 x float> zeroinitializer, <4 x float>* %output1, align 16
  store <4 x float> zeroinitializer, <4 x float>* %output2, align 16
  store <4 x float> zeroinitializer, <4 x float>* %output3, align 16
  store <4 x float> zeroinitializer, <4 x float>* %output4, align 16
  store <4 x float> zeroinitializer, <4 x float>* %output5, align 16
  store <4 x float> zeroinitializer, <4 x float>* %output6, align 16
  store <4 x float> zeroinitializer, <4 x float>* %output7, align 16
  store <4 x float> zeroinitializer, <4 x float>* %output8, align 16
  store <4 x float> zeroinitializer, <4 x float>* %output9, align 16
  store <4 x float> zeroinitializer, <4 x float>* %output10, align 16
  store [3 x [4 x <4 x i32>]] zeroinitializer, [3 x [4 x <4 x i32>]]* %reg, align 16
  %17 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 0, i32 0
  %18 = load <4 x float>, <4 x float>* %17, align 16
  %19 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 0, i32 1
  %20 = load <4 x float>, <4 x float>* %19, align 16
  %21 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 0, i32 2
  %22 = load <4 x float>, <4 x float>* %21, align 16
  %23 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 0, i32 3
  %24 = load <4 x float>, <4 x float>* %23, align 16
  %25 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 0, i32 0
  %26 = load <4 x float>, <4 x float>* %25, align 16
  %27 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 0, i32 1
  %28 = load <4 x float>, <4 x float>* %27, align 16
  %29 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 0, i32 2
  %30 = load <4 x float>, <4 x float>* %29, align 16
  %31 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 0, i32 3
  %32 = load <4 x float>, <4 x float>* %31, align 16
  %33 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 0, i32 0
  %34 = load <4 x float>, <4 x float>* %33, align 16
  %35 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 0, i32 1
  %36 = load <4 x float>, <4 x float>* %35, align 16
  %37 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 0, i32 2
  %38 = load <4 x float>, <4 x float>* %37, align 16
  %39 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 0, i32 3
  %40 = load <4 x float>, <4 x float>* %39, align 16
  %41 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 1, i32 0
  %42 = load <4 x float>, <4 x float>* %41, align 16
  %43 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 1, i32 1
  %44 = load <4 x float>, <4 x float>* %43, align 16
  %45 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 1, i32 2
  %46 = load <4 x float>, <4 x float>* %45, align 16
  %47 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 1, i32 3
  %48 = load <4 x float>, <4 x float>* %47, align 16
  %49 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 1, i32 0
  %50 = load <4 x float>, <4 x float>* %49, align 16
  %51 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 1, i32 1
  %52 = load <4 x float>, <4 x float>* %51, align 16
  %53 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 1, i32 2
  %54 = load <4 x float>, <4 x float>* %53, align 16
  %55 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 1, i32 3
  %56 = load <4 x float>, <4 x float>* %55, align 16
  %57 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 1, i32 0
  %58 = load <4 x float>, <4 x float>* %57, align 16
  %59 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 1, i32 1
  %60 = load <4 x float>, <4 x float>* %59, align 16
  %61 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 1, i32 2
  %62 = load <4 x float>, <4 x float>* %61, align 16
  %63 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 1, i32 3
  %64 = load <4 x float>, <4 x float>* %63, align 16
  %65 = bitcast <4 x float> %20 to <4 x i32>
  %66 = bitcast <4 x float> %22 to <4 x i32>
  %67 = bitcast <4 x float> %24 to <4 x i32>
  %68 = bitcast <4 x float> %42 to <4 x i32>
  %69 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %65, 0
  %70 = insertvalue [4 x <4 x i32>] %69, <4 x i32> %66, 1
  %71 = insertvalue [4 x <4 x i32>] %70, <4 x i32> %67, 2
  %72 = insertvalue [4 x <4 x i32>] %71, <4 x i32> %68, 3
  %73 = bitcast <4 x float> %28 to <4 x i32>
  %74 = bitcast <4 x float> %30 to <4 x i32>
  %75 = bitcast <4 x float> %32 to <4 x i32>
  %76 = bitcast <4 x float> %50 to <4 x i32>
  %77 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %73, 0
  %78 = insertvalue [4 x <4 x i32>] %77, <4 x i32> %74, 1
  %79 = insertvalue [4 x <4 x i32>] %78, <4 x i32> %75, 2
  %80 = insertvalue [4 x <4 x i32>] %79, <4 x i32> %76, 3
  %81 = bitcast <4 x float> %36 to <4 x i32>
  %82 = bitcast <4 x float> %38 to <4 x i32>
  %83 = bitcast <4 x float> %40 to <4 x i32>
  %84 = bitcast <4 x float> %58 to <4 x i32>
  %85 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %81, 0
  %86 = insertvalue [4 x <4 x i32>] %85, <4 x i32> %82, 1
  %87 = insertvalue [4 x <4 x i32>] %86, <4 x i32> %83, 2
  %88 = insertvalue [4 x <4 x i32>] %87, <4 x i32> %84, 3
  %89 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 2, i32 0
  %90 = load <4 x float>, <4 x float>* %89, align 16
  %91 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 2, i32 0
  %92 = load <4 x float>, <4 x float>* %91, align 16
  %93 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 2, i32 0
  %94 = load <4 x float>, <4 x float>* %93, align 16
  %95 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 2, i32 1
  %96 = load <4 x float>, <4 x float>* %95, align 16
  %97 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 2, i32 2
  %98 = load <4 x float>, <4 x float>* %97, align 16
  %99 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 2, i32 3
  %100 = load <4 x float>, <4 x float>* %99, align 16
  %101 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 0, i32 3, i32 0
  %102 = load <4 x float>, <4 x float>* %101, align 16
  %103 = bitcast <4 x float> %96 to <4 x i32>
  %104 = bitcast <4 x float> %98 to <4 x i32>
  %105 = bitcast <4 x float> %100 to <4 x i32>
  %106 = bitcast <4 x float> %102 to <4 x i32>
  %107 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %103, 0
  %108 = insertvalue [4 x <4 x i32>] %107, <4 x i32> %104, 1
  %109 = insertvalue [4 x <4 x i32>] %108, <4 x i32> %105, 2
  %110 = insertvalue [4 x <4 x i32>] %109, <4 x i32> %106, 3
  %111 = extractvalue [4 x <4 x i32>] %110, 0
  %112 = extractvalue [4 x <4 x i32>] %110, 1
  %113 = extractvalue [4 x <4 x i32>] %110, 2
  %114 = extractvalue [4 x <4 x i32>] %110, 3
  %115 = getelementptr [3 x [4 x <4 x i32>]], [3 x [4 x <4 x i32>]]* %reg, i32 0, i32 0
  %116 = getelementptr [4 x <4 x i32>], [4 x <4 x i32>]* %115, i32 0, i32 0
  store <4 x i32> %111, <4 x i32>* %116, align 16
  %117 = getelementptr [3 x [4 x <4 x i32>]], [3 x [4 x <4 x i32>]]* %reg, i32 0, i32 0
  %118 = getelementptr [4 x <4 x i32>], [4 x <4 x i32>]* %117, i32 0, i32 1
  store <4 x i32> %112, <4 x i32>* %118, align 16
  %119 = getelementptr [3 x [4 x <4 x i32>]], [3 x [4 x <4 x i32>]]* %reg, i32 0, i32 0
  %120 = getelementptr [4 x <4 x i32>], [4 x <4 x i32>]* %119, i32 0, i32 2
  store <4 x i32> %113, <4 x i32>* %120, align 16
  %121 = getelementptr [3 x [4 x <4 x i32>]], [3 x [4 x <4 x i32>]]* %reg, i32 0, i32 0
  %122 = getelementptr [4 x <4 x i32>], [4 x <4 x i32>]* %121, i32 0, i32 3
  store <4 x i32> %114, <4 x i32>* %122, align 16
  %123 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 2, i32 1
  %124 = load <4 x float>, <4 x float>* %123, align 16
  %125 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 2, i32 2
  %126 = load <4 x float>, <4 x float>* %125, align 16
  %127 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 2, i32 3
  %128 = load <4 x float>, <4 x float>* %127, align 16
  %129 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 1, i32 3, i32 0
  %130 = load <4 x float>, <4 x float>* %129, align 16
  %131 = bitcast <4 x float> %124 to <4 x i32>
  %132 = bitcast <4 x float> %126 to <4 x i32>
  %133 = bitcast <4 x float> %128 to <4 x i32>
  %134 = bitcast <4 x float> %130 to <4 x i32>
  %135 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %131, 0
  %136 = insertvalue [4 x <4 x i32>] %135, <4 x i32> %132, 1
  %137 = insertvalue [4 x <4 x i32>] %136, <4 x i32> %133, 2
  %138 = insertvalue [4 x <4 x i32>] %137, <4 x i32> %134, 3
  %139 = extractvalue [4 x <4 x i32>] %138, 0
  %140 = extractvalue [4 x <4 x i32>] %138, 1
  %141 = extractvalue [4 x <4 x i32>] %138, 2
  %142 = extractvalue [4 x <4 x i32>] %138, 3
  %143 = getelementptr [3 x [4 x <4 x i32>]], [3 x [4 x <4 x i32>]]* %reg, i32 0, i32 1
  %144 = getelementptr [4 x <4 x i32>], [4 x <4 x i32>]* %143, i32 0, i32 0
  store <4 x i32> %139, <4 x i32>* %144, align 16
  %145 = getelementptr [3 x [4 x <4 x i32>]], [3 x [4 x <4 x i32>]]* %reg, i32 0, i32 1
  %146 = getelementptr [4 x <4 x i32>], [4 x <4 x i32>]* %145, i32 0, i32 1
  store <4 x i32> %140, <4 x i32>* %146, align 16
  %147 = getelementptr [3 x [4 x <4 x i32>]], [3 x [4 x <4 x i32>]]* %reg, i32 0, i32 1
  %148 = getelementptr [4 x <4 x i32>], [4 x <4 x i32>]* %147, i32 0, i32 2
  store <4 x i32> %141, <4 x i32>* %148, align 16
  %149 = getelementptr [3 x [4 x <4 x i32>]], [3 x [4 x <4 x i32>]]* %reg, i32 0, i32 1
  %150 = getelementptr [4 x <4 x i32>], [4 x <4 x i32>]* %149, i32 0, i32 3
  store <4 x i32> %142, <4 x i32>* %150, align 16
  %151 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 2, i32 1
  %152 = load <4 x float>, <4 x float>* %151, align 16
  %153 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 2, i32 2
  %154 = load <4 x float>, <4 x float>* %153, align 16
  %155 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 2, i32 3
  %156 = load <4 x float>, <4 x float>* %155, align 16
  %157 = getelementptr [80 x [4 x <4 x float>]], [80 x [4 x <4 x float>]]* %2, i32 2, i32 3, i32 0
  %158 = load <4 x float>, <4 x float>* %157, align 16
  %159 = bitcast <4 x float> %152 to <4 x i32>
  %160 = bitcast <4 x float> %154 to <4 x i32>
  %161 = bitcast <4 x float> %156 to <4 x i32>
  %162 = bitcast <4 x float> %158 to <4 x i32>
  %163 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %159, 0
  %164 = insertvalue [4 x <4 x i32>] %163, <4 x i32> %160, 1
  %165 = insertvalue [4 x <4 x i32>] %164, <4 x i32> %161, 2
  %166 = insertvalue [4 x <4 x i32>] %165, <4 x i32> %162, 3
  %167 = extractvalue [4 x <4 x i32>] %166, 0
  %168 = extractvalue [4 x <4 x i32>] %166, 1
  %169 = extractvalue [4 x <4 x i32>] %166, 2
  %170 = extractvalue [4 x <4 x i32>] %166, 3
  %171 = getelementptr [3 x [4 x <4 x i32>]], [3 x [4 x <4 x i32>]]* %reg, i32 0, i32 2
  %172 = getelementptr [4 x <4 x i32>], [4 x <4 x i32>]* %171, i32 0, i32 0
  store <4 x i32> %167, <4 x i32>* %172, align 16
  %173 = getelementptr [3 x [4 x <4 x i32>]], [3 x [4 x <4 x i32>]]* %reg, i32 0, i32 2
  %174 = getelementptr [4 x <4 x i32>], [4 x <4 x i32>]* %173, i32 0, i32 1
  store <4 x i32> %168, <4 x i32>* %174, align 16
  %175 = getelementptr [3 x [4 x <4 x i32>]], [3 x [4 x <4 x i32>]]* %reg, i32 0, i32 2
  %176 = getelementptr [4 x <4 x i32>], [4 x <4 x i32>]* %175, i32 0, i32 2
  store <4 x i32> %169, <4 x i32>* %176, align 16
  %177 = getelementptr [3 x [4 x <4 x i32>]], [3 x [4 x <4 x i32>]]* %reg, i32 0, i32 2
  %178 = getelementptr [4 x <4 x i32>], [4 x <4 x i32>]* %177, i32 0, i32 3
  store <4 x i32> %170, <4 x i32>* %178, align 16
  %179 = bitcast <4 x float> %44 to <4 x i32>
  %180 = sitofp <4 x i32> %179 to <4 x float>
  %181 = bitcast <4 x float> %46 to <4 x i32>
  %182 = sitofp <4 x i32> %181 to <4 x float>
  %183 = bitcast <4 x float> %48 to <4 x i32>
  %184 = sitofp <4 x i32> %183 to <4 x float>
  %185 = bitcast <4 x float> %90 to <4 x i32>
  %186 = sitofp <4 x i32> %185 to <4 x float>
  %187 = bitcast <4 x float> %18 to <4 x i32>
  %188 = add <4 x i32> zeroinitializer, <4 x float> %18
  %189 = icmp ult <4 x i32> %188, <i32 2, i32 2, i32 2, i32 2>
  %190 = sext <4 x i1> %189 to <4 x i32>
  %191 = trunc <4 x i32> %190 to <4 x i1>
  %192 = select <4 x i1> %191, <4 x i32> %188, <4 x i32> <i32 2, i32 2, i32 2, i32 2>
  %193 = bitcast [3 x [4 x <4 x i32>]]* %reg to i32*
  %194 = mul <4 x i32> %192, <i32 4, i32 4, i32 4, i32 4>
  %195 = mul <4 x i32> %194, <i32 4, i32 4, i32 4, i32 4>
  %196 = add <4 x i32> %195, <i32 0, i32 1, i32 2, i32 3>
  %197 = extractelement <4 x i32> %196, i32 0
  %gather_ptr = getelementptr i32, i32* %193, i32 %197
  %198 = load i32, i32* %gather_ptr, align 4
  %199 = insertelement <4 x i32> undef, i32 %198, i32 0
  %200 = extractelement <4 x i32> %196, i32 1
  %gather_ptr11 = getelementptr i32, i32* %193, i32 %200
  %201 = load i32, i32* %gather_ptr11, align 4
  %202 = insertelement <4 x i32> %199, i32 %201, i32 1
  %203 = extractelement <4 x i32> %196, i32 2
  %gather_ptr12 = getelementptr i32, i32* %193, i32 %203
  %204 = load i32, i32* %gather_ptr12, align 4
  %205 = insertelement <4 x i32> %202, i32 %204, i32 2
  %206 = extractelement <4 x i32> %196, i32 3
  %gather_ptr13 = getelementptr i32, i32* %193, i32 %206
  %207 = load i32, i32* %gather_ptr13, align 4
  %208 = insertelement <4 x i32> %205, i32 %207, i32 3
  %209 = mul <4 x i32> %192, <i32 4, i32 4, i32 4, i32 4>
  %210 = add <4 x i32> %209, <i32 1, i32 1, i32 1, i32 1>
  %211 = mul <4 x i32> %210, <i32 4, i32 4, i32 4, i32 4>
  %212 = add <4 x i32> %211, <i32 0, i32 1, i32 2, i32 3>
  %213 = extractelement <4 x i32> %212, i32 0
  %gather_ptr14 = getelementptr i32, i32* %193, i32 %213
  %214 = load i32, i32* %gather_ptr14, align 4
  %215 = insertelement <4 x i32> undef, i32 %214, i32 0
  %216 = extractelement <4 x i32> %212, i32 1
  %gather_ptr15 = getelementptr i32, i32* %193, i32 %216
  %217 = load i32, i32* %gather_ptr15, align 4
  %218 = insertelement <4 x i32> %215, i32 %217, i32 1
  %219 = extractelement <4 x i32> %212, i32 2
  %gather_ptr16 = getelementptr i32, i32* %193, i32 %219
  %220 = load i32, i32* %gather_ptr16, align 4
  %221 = insertelement <4 x i32> %218, i32 %220, i32 2
  %222 = extractelement <4 x i32> %212, i32 3
  %gather_ptr17 = getelementptr i32, i32* %193, i32 %222
  %223 = load i32, i32* %gather_ptr17, align 4
  %224 = insertelement <4 x i32> %221, i32 %223, i32 3
  %225 = mul <4 x i32> %192, <i32 4, i32 4, i32 4, i32 4>
  %226 = add <4 x i32> %225, <i32 2, i32 2, i32 2, i32 2>
  %227 = mul <4 x i32> %226, <i32 4, i32 4, i32 4, i32 4>
  %228 = add <4 x i32> %227, <i32 0, i32 1, i32 2, i32 3>
  %229 = extractelement <4 x i32> %228, i32 0
  %gather_ptr18 = getelementptr i32, i32* %193, i32 %229
  %230 = load i32, i32* %gather_ptr18, align 4
  %231 = insertelement <4 x i32> undef, i32 %230, i32 0
  %232 = extractelement <4 x i32> %228, i32 1
  %gather_ptr19 = getelementptr i32, i32* %193, i32 %232
  %233 = load i32, i32* %gather_ptr19, align 4
  %234 = insertelement <4 x i32> %231, i32 %233, i32 1
  %235 = extractelement <4 x i32> %228, i32 2
  %gather_ptr20 = getelementptr i32, i32* %193, i32 %235
  %236 = load i32, i32* %gather_ptr20, align 4
  %237 = insertelement <4 x i32> %234, i32 %236, i32 2
  %238 = extractelement <4 x i32> %228, i32 3
  %gather_ptr21 = getelementptr i32, i32* %193, i32 %238
  %239 = load i32, i32* %gather_ptr21, align 4
  %240 = insertelement <4 x i32> %237, i32 %239, i32 3
  %241 = mul <4 x i32> %192, <i32 4, i32 4, i32 4, i32 4>
  %242 = add <4 x i32> %241, <i32 3, i32 3, i32 3, i32 3>
  %243 = mul <4 x i32> %242, <i32 4, i32 4, i32 4, i32 4>
  %244 = add <4 x i32> %243, <i32 0, i32 1, i32 2, i32 3>
  %245 = extractelement <4 x i32> %244, i32 0
  %gather_ptr22 = getelementptr i32, i32* %193, i32 %245
  %246 = load i32, i32* %gather_ptr22, align 4
  %247 = insertelement <4 x i32> undef, i32 %246, i32 0
  %248 = extractelement <4 x i32> %244, i32 1
  %gather_ptr23 = getelementptr i32, i32* %193, i32 %248
  %249 = load i32, i32* %gather_ptr23, align 4
  %250 = insertelement <4 x i32> %247, i32 %249, i32 1
  %251 = extractelement <4 x i32> %244, i32 2
  %gather_ptr24 = getelementptr i32, i32* %193, i32 %251
  %252 = load i32, i32* %gather_ptr24, align 4
  %253 = insertelement <4 x i32> %250, i32 %252, i32 2
  %254 = extractelement <4 x i32> %244, i32 3
  %gather_ptr25 = getelementptr i32, i32* %193, i32 %254
  %255 = load i32, i32* %gather_ptr25, align 4
  %256 = insertelement <4 x i32> %253, i32 %255, i32 3
  %257 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %208, 0
  %258 = insertvalue [4 x <4 x i32>] %257, <4 x i32> %224, 1
  %259 = insertvalue [4 x <4 x i32>] %258, <4 x i32> %240, 2
  %260 = insertvalue [4 x <4 x i32>] %259, <4 x i32> %256, 3
  %261 = extractvalue [4 x <4 x i32>] %260, 0
  %262 = extractvalue [4 x <4 x i32>] %260, 1
  %263 = extractvalue [4 x <4 x i32>] %260, 2
  %264 = extractvalue [4 x <4 x i32>] %260, 3
  %265 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %261, 0
  %266 = insertvalue [4 x <4 x i32>] %265, <4 x i32> %262, 1
  %267 = insertvalue [4 x <4 x i32>] %266, <4 x i32> %263, 2
  %268 = insertvalue [4 x <4 x i32>] %267, <4 x i32> %264, 3
  %269 = extractvalue [4 x <4 x i32>] %268, 0
  %270 = extractvalue [4 x <4 x i32>] %268, 1
  %271 = extractvalue [4 x <4 x i32>] %268, 2
  %272 = extractvalue [4 x <4 x i32>] %268, 3
  %273 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %269, 0
  %274 = insertvalue [4 x <4 x i32>] %273, <4 x i32> %270, 1
  %275 = insertvalue [4 x <4 x i32>] %274, <4 x i32> %271, 2
  %276 = insertvalue [4 x <4 x i32>] %275, <4 x i32> %272, 3
  %277 = extractvalue [4 x <4 x i32>] %276, 0
  %278 = sitofp <4 x i32> %277 to <4 x float>
  %279 = extractvalue [4 x <4 x i32>] %276, 1
  %280 = sitofp <4 x i32> %279 to <4 x float>
  %281 = extractvalue [4 x <4 x i32>] %276, 2
  %282 = sitofp <4 x i32> %281 to <4 x float>
  %283 = extractvalue [4 x <4 x i32>] %276, 3
  %284 = sitofp <4 x i32> %283 to <4 x float>
  %285 = fdiv <4 x float> %180, %278
  %286 = call <4 x float> @llvm.floor.v4f32(<4 x float> %285) #1
  %287 = fmul <4 x float> %278, %286
  %288 = fneg <4 x float> %287
  %289 = fadd <4 x float> %180, %288
  %290 = fdiv <4 x float> %182, %280
  %291 = call <4 x float> @llvm.floor.v4f32(<4 x float> %290) #1
  %292 = fmul <4 x float> %280, %291
  %293 = fneg <4 x float> %292
  %294 = fadd <4 x float> %182, %293
  %295 = fdiv <4 x float> %184, %282
  %296 = call <4 x float> @llvm.floor.v4f32(<4 x float> %295) #1
  %297 = fmul <4 x float> %282, %296
  %298 = fneg <4 x float> %297
  %299 = fadd <4 x float> %184, %298
  %300 = fdiv <4 x float> %186, %284
  %301 = call <4 x float> @llvm.floor.v4f32(<4 x float> %300) #1
  %302 = fmul <4 x float> %284, %301
  %303 = fneg <4 x float> %302
  %304 = fadd <4 x float> %186, %303
  %305 = extractvalue [4 x <4 x i32>] %72, 0
  %306 = bitcast <4 x i32> %305 to <4 x float>
  store <4 x float> %306, <4 x float>* %output, align 16
  %307 = extractvalue [4 x <4 x i32>] %72, 1
  %308 = bitcast <4 x i32> %307 to <4 x float>
  store <4 x float> %308, <4 x float>* %output1, align 16
  %309 = extractvalue [4 x <4 x i32>] %72, 2
  %310 = bitcast <4 x i32> %309 to <4 x float>
  store <4 x float> %310, <4 x float>* %output2, align 16
  %311 = extractvalue [4 x <4 x i32>] %72, 3
  %312 = bitcast <4 x i32> %311 to <4 x float>
  store <4 x float> %312, <4 x float>* %output3, align 16
  store <4 x float> %289, <4 x float>* %output4, align 16
  store <4 x float> %294, <4 x float>* %output5, align 16
  store <4 x float> %299, <4 x float>* %output6, align 16
  store <4 x float> %304, <4 x float>* %output7, align 16
  %313 = load <4 x i32>, <4 x i32>* %total_emitted_vertices_ptr, align 16
  %314 = load <4 x i32>, <4 x i32>* %execution_mask, align 16
  %315 = icmp slt <4 x i32> %313, <i32 3, i32 3, i32 3, i32 3>
  %316 = sext <4 x i1> %315 to <4 x i32>
  %317 = and <4 x i32> %314, %316
  %318 = icmp ne <4 x i32> %317, zeroinitializer
  %319 = extractelement <4 x i32> %313, i32 0
  %320 = add i32 0, %319
  %321 = extractelement <4 x i1> %318, i32 0
  %322 = select i1 %321, i32 %320, i32 3
  %323 = extractelement <4 x i32> %313, i32 1
  %324 = add i32 4, %323
  %325 = extractelement <4 x i1> %318, i32 1
  %326 = select i1 %325, i32 %324, i32 3
  %327 = extractelement <4 x i32> %313, i32 2
  %328 = add i32 8, %327
  %329 = extractelement <4 x i1> %318, i32 2
  %330 = select i1 %329, i32 %328, i32 3
  %331 = extractelement <4 x i32> %313, i32 3
  %332 = add i32 12, %331
  %333 = extractelement <4 x i1> %318, i32 3
  %334 = select i1 %333, i32 %332, i32 3
  br i1 true, label %if-true-block, label %endif-block

if-true-block:                                    ; preds = %entry
  %335 = getelementptr { i32, [4 x float], [2 x [4 x float]] }*, { i32, [4 x float], [2 x [4 x float]] }** %3, i32 0
  %336 = load { i32, [4 x float], [2 x [4 x float]] }*, { i32, [4 x float], [2 x [4 x float]] }** %335, align 8
  %337 = load <4 x float>, <4 x float>* %output, align 16
  %338 = load <4 x float>, <4 x float>* %output1, align 16
  %339 = load <4 x float>, <4 x float>* %output2, align 16
  %340 = load <4 x float>, <4 x float>* %output3, align 16
  %341 = shufflevector <4 x float> %337, <4 x float> %338, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
  %342 = shufflevector <4 x float> %337, <4 x float> %338, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
  %t0 = bitcast <4 x float> %341 to <2 x double>
  %t2 = bitcast <4 x float> %342 to <2 x double>
  %343 = shufflevector <4 x float> %339, <4 x float> %340, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
  %344 = shufflevector <4 x float> %339, <4 x float> %340, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
  %t1 = bitcast <4 x float> %343 to <2 x double>
  %t3 = bitcast <4 x float> %344 to <2 x double>
  %345 = shufflevector <2 x double> %t0, <2 x double> %t1, <2 x i32> <i32 0, i32 2>
  %346 = shufflevector <2 x double> %t0, <2 x double> %t1, <2 x i32> <i32 1, i32 3>
  %347 = shufflevector <2 x double> %t2, <2 x double> %t3, <2 x i32> <i32 0, i32 2>
  %348 = shufflevector <2 x double> %t2, <2 x double> %t3, <2 x i32> <i32 1, i32 3>
  %dst0 = bitcast <2 x double> %345 to <4 x float>
  %dst1 = bitcast <2 x double> %346 to <4 x float>
  %dst2 = bitcast <2 x double> %347 to <4 x float>
  %dst3 = bitcast <2 x double> %348 to <4 x float>
  %349 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %336, i32 %322
  %350 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %336, i32 %326
  %351 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %336, i32 %330
  %352 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %336, i32 %334
  %353 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %349, i32 0, i32 0
  store i32 -49152, i32* %353, align 4
  %354 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %350, i32 0, i32 0
  store i32 -49152, i32* %354, align 4
  %355 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %351, i32 0, i32 0
  store i32 -49152, i32* %355, align 4
  %356 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %352, i32 0, i32 0
  store i32 -49152, i32* %356, align 4
  %357 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %349, i32 0, i32 2
  %358 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %357, i32 0, i32 0, i32 0
  %359 = bitcast float* %358 to <4 x float>*
  store <4 x float> %dst0, <4 x float>* %359, align 4
  %360 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %350, i32 0, i32 2
  %361 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %360, i32 0, i32 0, i32 0
  %362 = bitcast float* %361 to <4 x float>*
  store <4 x float> %dst1, <4 x float>* %362, align 4
  %363 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %351, i32 0, i32 2
  %364 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %363, i32 0, i32 0, i32 0
  %365 = bitcast float* %364 to <4 x float>*
  store <4 x float> %dst2, <4 x float>* %365, align 4
  %366 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %352, i32 0, i32 2
  %367 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %366, i32 0, i32 0, i32 0
  %368 = bitcast float* %367 to <4 x float>*
  store <4 x float> %dst3, <4 x float>* %368, align 4
  %369 = load <4 x float>, <4 x float>* %output4, align 16
  %370 = load <4 x float>, <4 x float>* %output5, align 16
  %371 = load <4 x float>, <4 x float>* %output6, align 16
  %372 = load <4 x float>, <4 x float>* %output7, align 16
  %373 = shufflevector <4 x float> %369, <4 x float> %370, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
  %374 = shufflevector <4 x float> %369, <4 x float> %370, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
  %t026 = bitcast <4 x float> %373 to <2 x double>
  %t227 = bitcast <4 x float> %374 to <2 x double>
  %375 = shufflevector <4 x float> %371, <4 x float> %372, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
  %376 = shufflevector <4 x float> %371, <4 x float> %372, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
  %t128 = bitcast <4 x float> %375 to <2 x double>
  %t329 = bitcast <4 x float> %376 to <2 x double>
  %377 = shufflevector <2 x double> %t026, <2 x double> %t128, <2 x i32> <i32 0, i32 2>
  %378 = shufflevector <2 x double> %t026, <2 x double> %t128, <2 x i32> <i32 1, i32 3>
  %379 = shufflevector <2 x double> %t227, <2 x double> %t329, <2 x i32> <i32 0, i32 2>
  %380 = shufflevector <2 x double> %t227, <2 x double> %t329, <2 x i32> <i32 1, i32 3>
  %dst030 = bitcast <2 x double> %377 to <4 x float>
  %dst131 = bitcast <2 x double> %378 to <4 x float>
  %dst232 = bitcast <2 x double> %379 to <4 x float>
  %dst333 = bitcast <2 x double> %380 to <4 x float>
  %381 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %336, i32 %322
  %382 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %336, i32 %326
  %383 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %336, i32 %330
  %384 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %336, i32 %334
  %385 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %381, i32 0, i32 2
  %386 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %385, i32 0, i32 1, i32 0
  %387 = bitcast float* %386 to <4 x float>*
  store <4 x float> %dst030, <4 x float>* %387, align 4
  %388 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %382, i32 0, i32 2
  %389 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %388, i32 0, i32 1, i32 0
  %390 = bitcast float* %389 to <4 x float>*
  store <4 x float> %dst131, <4 x float>* %390, align 4
  %391 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %383, i32 0, i32 2
  %392 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %391, i32 0, i32 1, i32 0
  %393 = bitcast float* %392 to <4 x float>*
  store <4 x float> %dst232, <4 x float>* %393, align 4
  %394 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %384, i32 0, i32 2
  %395 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %394, i32 0, i32 1, i32 0
  %396 = bitcast float* %395 to <4 x float>*
  store <4 x float> %dst333, <4 x float>* %396, align 4
  br label %endif-block

endif-block:                                      ; preds = %entry, %if-true-block
  %397 = load <4 x i32>, <4 x i32>* %emitted_vertices_ptr, align 16
  %398 = sub <4 x i32> %397, %317
  store <4 x i32> %398, <4 x i32>* %emitted_vertices_ptr, align 16
  %399 = load <4 x i32>, <4 x i32>* %total_emitted_vertices_ptr, align 16
  %400 = sub <4 x i32> %399, %317
  store <4 x i32> %400, <4 x i32>* %total_emitted_vertices_ptr, align 16
  %401 = bitcast <4 x float> %52 to <4 x i32>
  %402 = sitofp <4 x i32> %401 to <4 x float>
  %403 = bitcast <4 x float> %54 to <4 x i32>
  %404 = sitofp <4 x i32> %403 to <4 x float>
  %405 = bitcast <4 x float> %56 to <4 x i32>
  %406 = sitofp <4 x i32> %405 to <4 x float>
  %407 = bitcast <4 x float> %92 to <4 x i32>
  %408 = sitofp <4 x i32> %407 to <4 x float>
  %409 = bitcast <4 x float> %26 to <4 x i32>
  %410 = add <4 x i32> zeroinitializer, <4 x float> %26
  %411 = icmp ult <4 x i32> %410, <i32 2, i32 2, i32 2, i32 2>
  %412 = sext <4 x i1> %411 to <4 x i32>
  %413 = trunc <4 x i32> %412 to <4 x i1>
  %414 = select <4 x i1> %413, <4 x i32> %410, <4 x i32> <i32 2, i32 2, i32 2, i32 2>
  %415 = bitcast [3 x [4 x <4 x i32>]]* %reg to i32*
  %416 = mul <4 x i32> %414, <i32 4, i32 4, i32 4, i32 4>
  %417 = mul <4 x i32> %416, <i32 4, i32 4, i32 4, i32 4>
  %418 = add <4 x i32> %417, <i32 0, i32 1, i32 2, i32 3>
  %419 = extractelement <4 x i32> %418, i32 0
  %gather_ptr34 = getelementptr i32, i32* %415, i32 %419
  %420 = load i32, i32* %gather_ptr34, align 4
  %421 = insertelement <4 x i32> undef, i32 %420, i32 0
  %422 = extractelement <4 x i32> %418, i32 1
  %gather_ptr35 = getelementptr i32, i32* %415, i32 %422
  %423 = load i32, i32* %gather_ptr35, align 4
  %424 = insertelement <4 x i32> %421, i32 %423, i32 1
  %425 = extractelement <4 x i32> %418, i32 2
  %gather_ptr36 = getelementptr i32, i32* %415, i32 %425
  %426 = load i32, i32* %gather_ptr36, align 4
  %427 = insertelement <4 x i32> %424, i32 %426, i32 2
  %428 = extractelement <4 x i32> %418, i32 3
  %gather_ptr37 = getelementptr i32, i32* %415, i32 %428
  %429 = load i32, i32* %gather_ptr37, align 4
  %430 = insertelement <4 x i32> %427, i32 %429, i32 3
  %431 = mul <4 x i32> %414, <i32 4, i32 4, i32 4, i32 4>
  %432 = add <4 x i32> %431, <i32 1, i32 1, i32 1, i32 1>
  %433 = mul <4 x i32> %432, <i32 4, i32 4, i32 4, i32 4>
  %434 = add <4 x i32> %433, <i32 0, i32 1, i32 2, i32 3>
  %435 = extractelement <4 x i32> %434, i32 0
  %gather_ptr38 = getelementptr i32, i32* %415, i32 %435
  %436 = load i32, i32* %gather_ptr38, align 4
  %437 = insertelement <4 x i32> undef, i32 %436, i32 0
  %438 = extractelement <4 x i32> %434, i32 1
  %gather_ptr39 = getelementptr i32, i32* %415, i32 %438
  %439 = load i32, i32* %gather_ptr39, align 4
  %440 = insertelement <4 x i32> %437, i32 %439, i32 1
  %441 = extractelement <4 x i32> %434, i32 2
  %gather_ptr40 = getelementptr i32, i32* %415, i32 %441
  %442 = load i32, i32* %gather_ptr40, align 4
  %443 = insertelement <4 x i32> %440, i32 %442, i32 2
  %444 = extractelement <4 x i32> %434, i32 3
  %gather_ptr41 = getelementptr i32, i32* %415, i32 %444
  %445 = load i32, i32* %gather_ptr41, align 4
  %446 = insertelement <4 x i32> %443, i32 %445, i32 3
  %447 = mul <4 x i32> %414, <i32 4, i32 4, i32 4, i32 4>
  %448 = add <4 x i32> %447, <i32 2, i32 2, i32 2, i32 2>
  %449 = mul <4 x i32> %448, <i32 4, i32 4, i32 4, i32 4>
  %450 = add <4 x i32> %449, <i32 0, i32 1, i32 2, i32 3>
  %451 = extractelement <4 x i32> %450, i32 0
  %gather_ptr42 = getelementptr i32, i32* %415, i32 %451
  %452 = load i32, i32* %gather_ptr42, align 4
  %453 = insertelement <4 x i32> undef, i32 %452, i32 0
  %454 = extractelement <4 x i32> %450, i32 1
  %gather_ptr43 = getelementptr i32, i32* %415, i32 %454
  %455 = load i32, i32* %gather_ptr43, align 4
  %456 = insertelement <4 x i32> %453, i32 %455, i32 1
  %457 = extractelement <4 x i32> %450, i32 2
  %gather_ptr44 = getelementptr i32, i32* %415, i32 %457
  %458 = load i32, i32* %gather_ptr44, align 4
  %459 = insertelement <4 x i32> %456, i32 %458, i32 2
  %460 = extractelement <4 x i32> %450, i32 3
  %gather_ptr45 = getelementptr i32, i32* %415, i32 %460
  %461 = load i32, i32* %gather_ptr45, align 4
  %462 = insertelement <4 x i32> %459, i32 %461, i32 3
  %463 = mul <4 x i32> %414, <i32 4, i32 4, i32 4, i32 4>
  %464 = add <4 x i32> %463, <i32 3, i32 3, i32 3, i32 3>
  %465 = mul <4 x i32> %464, <i32 4, i32 4, i32 4, i32 4>
  %466 = add <4 x i32> %465, <i32 0, i32 1, i32 2, i32 3>
  %467 = extractelement <4 x i32> %466, i32 0
  %gather_ptr46 = getelementptr i32, i32* %415, i32 %467
  %468 = load i32, i32* %gather_ptr46, align 4
  %469 = insertelement <4 x i32> undef, i32 %468, i32 0
  %470 = extractelement <4 x i32> %466, i32 1
  %gather_ptr47 = getelementptr i32, i32* %415, i32 %470
  %471 = load i32, i32* %gather_ptr47, align 4
  %472 = insertelement <4 x i32> %469, i32 %471, i32 1
  %473 = extractelement <4 x i32> %466, i32 2
  %gather_ptr48 = getelementptr i32, i32* %415, i32 %473
  %474 = load i32, i32* %gather_ptr48, align 4
  %475 = insertelement <4 x i32> %472, i32 %474, i32 2
  %476 = extractelement <4 x i32> %466, i32 3
  %gather_ptr49 = getelementptr i32, i32* %415, i32 %476
  %477 = load i32, i32* %gather_ptr49, align 4
  %478 = insertelement <4 x i32> %475, i32 %477, i32 3
  %479 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %430, 0
  %480 = insertvalue [4 x <4 x i32>] %479, <4 x i32> %446, 1
  %481 = insertvalue [4 x <4 x i32>] %480, <4 x i32> %462, 2
  %482 = insertvalue [4 x <4 x i32>] %481, <4 x i32> %478, 3
  %483 = extractvalue [4 x <4 x i32>] %482, 0
  %484 = extractvalue [4 x <4 x i32>] %482, 1
  %485 = extractvalue [4 x <4 x i32>] %482, 2
  %486 = extractvalue [4 x <4 x i32>] %482, 3
  %487 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %483, 0
  %488 = insertvalue [4 x <4 x i32>] %487, <4 x i32> %484, 1
  %489 = insertvalue [4 x <4 x i32>] %488, <4 x i32> %485, 2
  %490 = insertvalue [4 x <4 x i32>] %489, <4 x i32> %486, 3
  %491 = extractvalue [4 x <4 x i32>] %490, 0
  %492 = extractvalue [4 x <4 x i32>] %490, 1
  %493 = extractvalue [4 x <4 x i32>] %490, 2
  %494 = extractvalue [4 x <4 x i32>] %490, 3
  %495 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %491, 0
  %496 = insertvalue [4 x <4 x i32>] %495, <4 x i32> %492, 1
  %497 = insertvalue [4 x <4 x i32>] %496, <4 x i32> %493, 2
  %498 = insertvalue [4 x <4 x i32>] %497, <4 x i32> %494, 3
  %499 = extractvalue [4 x <4 x i32>] %498, 0
  %500 = sitofp <4 x i32> %499 to <4 x float>
  %501 = extractvalue [4 x <4 x i32>] %498, 1
  %502 = sitofp <4 x i32> %501 to <4 x float>
  %503 = extractvalue [4 x <4 x i32>] %498, 2
  %504 = sitofp <4 x i32> %503 to <4 x float>
  %505 = extractvalue [4 x <4 x i32>] %498, 3
  %506 = sitofp <4 x i32> %505 to <4 x float>
  %507 = fdiv <4 x float> %402, %500
  %508 = call <4 x float> @llvm.floor.v4f32(<4 x float> %507) #1
  %509 = fmul <4 x float> %500, %508
  %510 = fneg <4 x float> %509
  %511 = fadd <4 x float> %402, %510
  %512 = fdiv <4 x float> %404, %502
  %513 = call <4 x float> @llvm.floor.v4f32(<4 x float> %512) #1
  %514 = fmul <4 x float> %502, %513
  %515 = fneg <4 x float> %514
  %516 = fadd <4 x float> %404, %515
  %517 = fdiv <4 x float> %406, %504
  %518 = call <4 x float> @llvm.floor.v4f32(<4 x float> %517) #1
  %519 = fmul <4 x float> %504, %518
  %520 = fneg <4 x float> %519
  %521 = fadd <4 x float> %406, %520
  %522 = fdiv <4 x float> %408, %506
  %523 = call <4 x float> @llvm.floor.v4f32(<4 x float> %522) #1
  %524 = fmul <4 x float> %506, %523
  %525 = fneg <4 x float> %524
  %526 = fadd <4 x float> %408, %525
  %527 = extractvalue [4 x <4 x i32>] %80, 0
  %528 = bitcast <4 x i32> %527 to <4 x float>
  store <4 x float> %528, <4 x float>* %output, align 16
  %529 = extractvalue [4 x <4 x i32>] %80, 1
  %530 = bitcast <4 x i32> %529 to <4 x float>
  store <4 x float> %530, <4 x float>* %output1, align 16
  %531 = extractvalue [4 x <4 x i32>] %80, 2
  %532 = bitcast <4 x i32> %531 to <4 x float>
  store <4 x float> %532, <4 x float>* %output2, align 16
  %533 = extractvalue [4 x <4 x i32>] %80, 3
  %534 = bitcast <4 x i32> %533 to <4 x float>
  store <4 x float> %534, <4 x float>* %output3, align 16
  store <4 x float> %511, <4 x float>* %output4, align 16
  store <4 x float> %516, <4 x float>* %output5, align 16
  store <4 x float> %521, <4 x float>* %output6, align 16
  store <4 x float> %526, <4 x float>* %output7, align 16
  %535 = load <4 x i32>, <4 x i32>* %total_emitted_vertices_ptr, align 16
  %536 = load <4 x i32>, <4 x i32>* %execution_mask, align 16
  %537 = icmp slt <4 x i32> %535, <i32 3, i32 3, i32 3, i32 3>
  %538 = sext <4 x i1> %537 to <4 x i32>
  %539 = and <4 x i32> %536, %538
  %540 = icmp ne <4 x i32> %539, zeroinitializer
  %541 = extractelement <4 x i32> %535, i32 0
  %542 = add i32 0, %541
  %543 = extractelement <4 x i1> %540, i32 0
  %544 = select i1 %543, i32 %542, i32 3
  %545 = extractelement <4 x i32> %535, i32 1
  %546 = add i32 4, %545
  %547 = extractelement <4 x i1> %540, i32 1
  %548 = select i1 %547, i32 %546, i32 3
  %549 = extractelement <4 x i32> %535, i32 2
  %550 = add i32 8, %549
  %551 = extractelement <4 x i1> %540, i32 2
  %552 = select i1 %551, i32 %550, i32 3
  %553 = extractelement <4 x i32> %535, i32 3
  %554 = add i32 12, %553
  %555 = extractelement <4 x i1> %540, i32 3
  %556 = select i1 %555, i32 %554, i32 3
  br i1 true, label %if-true-block51, label %endif-block50

if-true-block51:                                  ; preds = %endif-block
  %557 = getelementptr { i32, [4 x float], [2 x [4 x float]] }*, { i32, [4 x float], [2 x [4 x float]] }** %3, i32 0
  %558 = load { i32, [4 x float], [2 x [4 x float]] }*, { i32, [4 x float], [2 x [4 x float]] }** %557, align 8
  %559 = load <4 x float>, <4 x float>* %output, align 16
  %560 = load <4 x float>, <4 x float>* %output1, align 16
  %561 = load <4 x float>, <4 x float>* %output2, align 16
  %562 = load <4 x float>, <4 x float>* %output3, align 16
  %563 = shufflevector <4 x float> %559, <4 x float> %560, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
  %564 = shufflevector <4 x float> %559, <4 x float> %560, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
  %t052 = bitcast <4 x float> %563 to <2 x double>
  %t253 = bitcast <4 x float> %564 to <2 x double>
  %565 = shufflevector <4 x float> %561, <4 x float> %562, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
  %566 = shufflevector <4 x float> %561, <4 x float> %562, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
  %t154 = bitcast <4 x float> %565 to <2 x double>
  %t355 = bitcast <4 x float> %566 to <2 x double>
  %567 = shufflevector <2 x double> %t052, <2 x double> %t154, <2 x i32> <i32 0, i32 2>
  %568 = shufflevector <2 x double> %t052, <2 x double> %t154, <2 x i32> <i32 1, i32 3>
  %569 = shufflevector <2 x double> %t253, <2 x double> %t355, <2 x i32> <i32 0, i32 2>
  %570 = shufflevector <2 x double> %t253, <2 x double> %t355, <2 x i32> <i32 1, i32 3>
  %dst056 = bitcast <2 x double> %567 to <4 x float>
  %dst157 = bitcast <2 x double> %568 to <4 x float>
  %dst258 = bitcast <2 x double> %569 to <4 x float>
  %dst359 = bitcast <2 x double> %570 to <4 x float>
  %571 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %558, i32 %544
  %572 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %558, i32 %548
  %573 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %558, i32 %552
  %574 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %558, i32 %556
  %575 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %571, i32 0, i32 0
  store i32 -49152, i32* %575, align 4
  %576 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %572, i32 0, i32 0
  store i32 -49152, i32* %576, align 4
  %577 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %573, i32 0, i32 0
  store i32 -49152, i32* %577, align 4
  %578 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %574, i32 0, i32 0
  store i32 -49152, i32* %578, align 4
  %579 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %571, i32 0, i32 2
  %580 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %579, i32 0, i32 0, i32 0
  %581 = bitcast float* %580 to <4 x float>*
  store <4 x float> %dst056, <4 x float>* %581, align 4
  %582 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %572, i32 0, i32 2
  %583 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %582, i32 0, i32 0, i32 0
  %584 = bitcast float* %583 to <4 x float>*
  store <4 x float> %dst157, <4 x float>* %584, align 4
  %585 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %573, i32 0, i32 2
  %586 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %585, i32 0, i32 0, i32 0
  %587 = bitcast float* %586 to <4 x float>*
  store <4 x float> %dst258, <4 x float>* %587, align 4
  %588 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %574, i32 0, i32 2
  %589 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %588, i32 0, i32 0, i32 0
  %590 = bitcast float* %589 to <4 x float>*
  store <4 x float> %dst359, <4 x float>* %590, align 4
  %591 = load <4 x float>, <4 x float>* %output4, align 16
  %592 = load <4 x float>, <4 x float>* %output5, align 16
  %593 = load <4 x float>, <4 x float>* %output6, align 16
  %594 = load <4 x float>, <4 x float>* %output7, align 16
  %595 = shufflevector <4 x float> %591, <4 x float> %592, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
  %596 = shufflevector <4 x float> %591, <4 x float> %592, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
  %t060 = bitcast <4 x float> %595 to <2 x double>
  %t261 = bitcast <4 x float> %596 to <2 x double>
  %597 = shufflevector <4 x float> %593, <4 x float> %594, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
  %598 = shufflevector <4 x float> %593, <4 x float> %594, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
  %t162 = bitcast <4 x float> %597 to <2 x double>
  %t363 = bitcast <4 x float> %598 to <2 x double>
  %599 = shufflevector <2 x double> %t060, <2 x double> %t162, <2 x i32> <i32 0, i32 2>
  %600 = shufflevector <2 x double> %t060, <2 x double> %t162, <2 x i32> <i32 1, i32 3>
  %601 = shufflevector <2 x double> %t261, <2 x double> %t363, <2 x i32> <i32 0, i32 2>
  %602 = shufflevector <2 x double> %t261, <2 x double> %t363, <2 x i32> <i32 1, i32 3>
  %dst064 = bitcast <2 x double> %599 to <4 x float>
  %dst165 = bitcast <2 x double> %600 to <4 x float>
  %dst266 = bitcast <2 x double> %601 to <4 x float>
  %dst367 = bitcast <2 x double> %602 to <4 x float>
  %603 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %558, i32 %544
  %604 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %558, i32 %548
  %605 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %558, i32 %552
  %606 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %558, i32 %556
  %607 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %603, i32 0, i32 2
  %608 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %607, i32 0, i32 1, i32 0
  %609 = bitcast float* %608 to <4 x float>*
  store <4 x float> %dst064, <4 x float>* %609, align 4
  %610 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %604, i32 0, i32 2
  %611 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %610, i32 0, i32 1, i32 0
  %612 = bitcast float* %611 to <4 x float>*
  store <4 x float> %dst165, <4 x float>* %612, align 4
  %613 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %605, i32 0, i32 2
  %614 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %613, i32 0, i32 1, i32 0
  %615 = bitcast float* %614 to <4 x float>*
  store <4 x float> %dst266, <4 x float>* %615, align 4
  %616 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %606, i32 0, i32 2
  %617 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %616, i32 0, i32 1, i32 0
  %618 = bitcast float* %617 to <4 x float>*
  store <4 x float> %dst367, <4 x float>* %618, align 4
  br label %endif-block50

endif-block50:                                    ; preds = %endif-block, %if-true-block51
  %619 = load <4 x i32>, <4 x i32>* %emitted_vertices_ptr, align 16
  %620 = sub <4 x i32> %619, %539
  store <4 x i32> %620, <4 x i32>* %emitted_vertices_ptr, align 16
  %621 = load <4 x i32>, <4 x i32>* %total_emitted_vertices_ptr, align 16
  %622 = sub <4 x i32> %621, %539
  store <4 x i32> %622, <4 x i32>* %total_emitted_vertices_ptr, align 16
  %623 = bitcast <4 x float> %60 to <4 x i32>
  %624 = sitofp <4 x i32> %623 to <4 x float>
  %625 = bitcast <4 x float> %62 to <4 x i32>
  %626 = sitofp <4 x i32> %625 to <4 x float>
  %627 = bitcast <4 x float> %64 to <4 x i32>
  %628 = sitofp <4 x i32> %627 to <4 x float>
  %629 = bitcast <4 x float> %94 to <4 x i32>
  %630 = sitofp <4 x i32> %629 to <4 x float>
  %631 = bitcast <4 x float> %34 to <4 x i32>
  %632 = add <4 x i32> zeroinitializer, <4 x float> %34
  %633 = icmp ult <4 x i32> %632, <i32 2, i32 2, i32 2, i32 2>
  %634 = sext <4 x i1> %633 to <4 x i32>
  %635 = trunc <4 x i32> %634 to <4 x i1>
  %636 = select <4 x i1> %635, <4 x i32> %632, <4 x i32> <i32 2, i32 2, i32 2, i32 2>
  %637 = bitcast [3 x [4 x <4 x i32>]]* %reg to i32*
  %638 = mul <4 x i32> %636, <i32 4, i32 4, i32 4, i32 4>
  %639 = mul <4 x i32> %638, <i32 4, i32 4, i32 4, i32 4>
  %640 = add <4 x i32> %639, <i32 0, i32 1, i32 2, i32 3>
  %641 = extractelement <4 x i32> %640, i32 0
  %gather_ptr68 = getelementptr i32, i32* %637, i32 %641
  %642 = load i32, i32* %gather_ptr68, align 4
  %643 = insertelement <4 x i32> undef, i32 %642, i32 0
  %644 = extractelement <4 x i32> %640, i32 1
  %gather_ptr69 = getelementptr i32, i32* %637, i32 %644
  %645 = load i32, i32* %gather_ptr69, align 4
  %646 = insertelement <4 x i32> %643, i32 %645, i32 1
  %647 = extractelement <4 x i32> %640, i32 2
  %gather_ptr70 = getelementptr i32, i32* %637, i32 %647
  %648 = load i32, i32* %gather_ptr70, align 4
  %649 = insertelement <4 x i32> %646, i32 %648, i32 2
  %650 = extractelement <4 x i32> %640, i32 3
  %gather_ptr71 = getelementptr i32, i32* %637, i32 %650
  %651 = load i32, i32* %gather_ptr71, align 4
  %652 = insertelement <4 x i32> %649, i32 %651, i32 3
  %653 = mul <4 x i32> %636, <i32 4, i32 4, i32 4, i32 4>
  %654 = add <4 x i32> %653, <i32 1, i32 1, i32 1, i32 1>
  %655 = mul <4 x i32> %654, <i32 4, i32 4, i32 4, i32 4>
  %656 = add <4 x i32> %655, <i32 0, i32 1, i32 2, i32 3>
  %657 = extractelement <4 x i32> %656, i32 0
  %gather_ptr72 = getelementptr i32, i32* %637, i32 %657
  %658 = load i32, i32* %gather_ptr72, align 4
  %659 = insertelement <4 x i32> undef, i32 %658, i32 0
  %660 = extractelement <4 x i32> %656, i32 1
  %gather_ptr73 = getelementptr i32, i32* %637, i32 %660
  %661 = load i32, i32* %gather_ptr73, align 4
  %662 = insertelement <4 x i32> %659, i32 %661, i32 1
  %663 = extractelement <4 x i32> %656, i32 2
  %gather_ptr74 = getelementptr i32, i32* %637, i32 %663
  %664 = load i32, i32* %gather_ptr74, align 4
  %665 = insertelement <4 x i32> %662, i32 %664, i32 2
  %666 = extractelement <4 x i32> %656, i32 3
  %gather_ptr75 = getelementptr i32, i32* %637, i32 %666
  %667 = load i32, i32* %gather_ptr75, align 4
  %668 = insertelement <4 x i32> %665, i32 %667, i32 3
  %669 = mul <4 x i32> %636, <i32 4, i32 4, i32 4, i32 4>
  %670 = add <4 x i32> %669, <i32 2, i32 2, i32 2, i32 2>
  %671 = mul <4 x i32> %670, <i32 4, i32 4, i32 4, i32 4>
  %672 = add <4 x i32> %671, <i32 0, i32 1, i32 2, i32 3>
  %673 = extractelement <4 x i32> %672, i32 0
  %gather_ptr76 = getelementptr i32, i32* %637, i32 %673
  %674 = load i32, i32* %gather_ptr76, align 4
  %675 = insertelement <4 x i32> undef, i32 %674, i32 0
  %676 = extractelement <4 x i32> %672, i32 1
  %gather_ptr77 = getelementptr i32, i32* %637, i32 %676
  %677 = load i32, i32* %gather_ptr77, align 4
  %678 = insertelement <4 x i32> %675, i32 %677, i32 1
  %679 = extractelement <4 x i32> %672, i32 2
  %gather_ptr78 = getelementptr i32, i32* %637, i32 %679
  %680 = load i32, i32* %gather_ptr78, align 4
  %681 = insertelement <4 x i32> %678, i32 %680, i32 2
  %682 = extractelement <4 x i32> %672, i32 3
  %gather_ptr79 = getelementptr i32, i32* %637, i32 %682
  %683 = load i32, i32* %gather_ptr79, align 4
  %684 = insertelement <4 x i32> %681, i32 %683, i32 3
  %685 = mul <4 x i32> %636, <i32 4, i32 4, i32 4, i32 4>
  %686 = add <4 x i32> %685, <i32 3, i32 3, i32 3, i32 3>
  %687 = mul <4 x i32> %686, <i32 4, i32 4, i32 4, i32 4>
  %688 = add <4 x i32> %687, <i32 0, i32 1, i32 2, i32 3>
  %689 = extractelement <4 x i32> %688, i32 0
  %gather_ptr80 = getelementptr i32, i32* %637, i32 %689
  %690 = load i32, i32* %gather_ptr80, align 4
  %691 = insertelement <4 x i32> undef, i32 %690, i32 0
  %692 = extractelement <4 x i32> %688, i32 1
  %gather_ptr81 = getelementptr i32, i32* %637, i32 %692
  %693 = load i32, i32* %gather_ptr81, align 4
  %694 = insertelement <4 x i32> %691, i32 %693, i32 1
  %695 = extractelement <4 x i32> %688, i32 2
  %gather_ptr82 = getelementptr i32, i32* %637, i32 %695
  %696 = load i32, i32* %gather_ptr82, align 4
  %697 = insertelement <4 x i32> %694, i32 %696, i32 2
  %698 = extractelement <4 x i32> %688, i32 3
  %gather_ptr83 = getelementptr i32, i32* %637, i32 %698
  %699 = load i32, i32* %gather_ptr83, align 4
  %700 = insertelement <4 x i32> %697, i32 %699, i32 3
  %701 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %652, 0
  %702 = insertvalue [4 x <4 x i32>] %701, <4 x i32> %668, 1
  %703 = insertvalue [4 x <4 x i32>] %702, <4 x i32> %684, 2
  %704 = insertvalue [4 x <4 x i32>] %703, <4 x i32> %700, 3
  %705 = extractvalue [4 x <4 x i32>] %704, 0
  %706 = extractvalue [4 x <4 x i32>] %704, 1
  %707 = extractvalue [4 x <4 x i32>] %704, 2
  %708 = extractvalue [4 x <4 x i32>] %704, 3
  %709 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %705, 0
  %710 = insertvalue [4 x <4 x i32>] %709, <4 x i32> %706, 1
  %711 = insertvalue [4 x <4 x i32>] %710, <4 x i32> %707, 2
  %712 = insertvalue [4 x <4 x i32>] %711, <4 x i32> %708, 3
  %713 = extractvalue [4 x <4 x i32>] %712, 0
  %714 = extractvalue [4 x <4 x i32>] %712, 1
  %715 = extractvalue [4 x <4 x i32>] %712, 2
  %716 = extractvalue [4 x <4 x i32>] %712, 3
  %717 = insertvalue [4 x <4 x i32>] undef, <4 x i32> %713, 0
  %718 = insertvalue [4 x <4 x i32>] %717, <4 x i32> %714, 1
  %719 = insertvalue [4 x <4 x i32>] %718, <4 x i32> %715, 2
  %720 = insertvalue [4 x <4 x i32>] %719, <4 x i32> %716, 3
  %721 = extractvalue [4 x <4 x i32>] %720, 0
  %722 = sitofp <4 x i32> %721 to <4 x float>
  %723 = extractvalue [4 x <4 x i32>] %720, 1
  %724 = sitofp <4 x i32> %723 to <4 x float>
  %725 = extractvalue [4 x <4 x i32>] %720, 2
  %726 = sitofp <4 x i32> %725 to <4 x float>
  %727 = extractvalue [4 x <4 x i32>] %720, 3
  %728 = sitofp <4 x i32> %727 to <4 x float>
  %729 = fdiv <4 x float> %624, %722
  %730 = call <4 x float> @llvm.floor.v4f32(<4 x float> %729) #1
  %731 = fmul <4 x float> %722, %730
  %732 = fneg <4 x float> %731
  %733 = fadd <4 x float> %624, %732
  %734 = fdiv <4 x float> %626, %724
  %735 = call <4 x float> @llvm.floor.v4f32(<4 x float> %734) #1
  %736 = fmul <4 x float> %724, %735
  %737 = fneg <4 x float> %736
  %738 = fadd <4 x float> %626, %737
  %739 = fdiv <4 x float> %628, %726
  %740 = call <4 x float> @llvm.floor.v4f32(<4 x float> %739) #1
  %741 = fmul <4 x float> %726, %740
  %742 = fneg <4 x float> %741
  %743 = fadd <4 x float> %628, %742
  %744 = fdiv <4 x float> %630, %728
  %745 = call <4 x float> @llvm.floor.v4f32(<4 x float> %744) #1
  %746 = fmul <4 x float> %728, %745
  %747 = fneg <4 x float> %746
  %748 = fadd <4 x float> %630, %747
  %749 = extractvalue [4 x <4 x i32>] %88, 0
  %750 = bitcast <4 x i32> %749 to <4 x float>
  store <4 x float> %750, <4 x float>* %output, align 16
  %751 = extractvalue [4 x <4 x i32>] %88, 1
  %752 = bitcast <4 x i32> %751 to <4 x float>
  store <4 x float> %752, <4 x float>* %output1, align 16
  %753 = extractvalue [4 x <4 x i32>] %88, 2
  %754 = bitcast <4 x i32> %753 to <4 x float>
  store <4 x float> %754, <4 x float>* %output2, align 16
  %755 = extractvalue [4 x <4 x i32>] %88, 3
  %756 = bitcast <4 x i32> %755 to <4 x float>
  store <4 x float> %756, <4 x float>* %output3, align 16
  store <4 x float> %733, <4 x float>* %output4, align 16
  store <4 x float> %738, <4 x float>* %output5, align 16
  store <4 x float> %743, <4 x float>* %output6, align 16
  store <4 x float> %748, <4 x float>* %output7, align 16
  %757 = load <4 x i32>, <4 x i32>* %total_emitted_vertices_ptr, align 16
  %758 = load <4 x i32>, <4 x i32>* %execution_mask, align 16
  %759 = icmp slt <4 x i32> %757, <i32 3, i32 3, i32 3, i32 3>
  %760 = sext <4 x i1> %759 to <4 x i32>
  %761 = and <4 x i32> %758, %760
  %762 = icmp ne <4 x i32> %761, zeroinitializer
  %763 = extractelement <4 x i32> %757, i32 0
  %764 = add i32 0, %763
  %765 = extractelement <4 x i1> %762, i32 0
  %766 = select i1 %765, i32 %764, i32 3
  %767 = extractelement <4 x i32> %757, i32 1
  %768 = add i32 4, %767
  %769 = extractelement <4 x i1> %762, i32 1
  %770 = select i1 %769, i32 %768, i32 3
  %771 = extractelement <4 x i32> %757, i32 2
  %772 = add i32 8, %771
  %773 = extractelement <4 x i1> %762, i32 2
  %774 = select i1 %773, i32 %772, i32 3
  %775 = extractelement <4 x i32> %757, i32 3
  %776 = add i32 12, %775
  %777 = extractelement <4 x i1> %762, i32 3
  %778 = select i1 %777, i32 %776, i32 3
  br i1 true, label %if-true-block85, label %endif-block84

if-true-block85:                                  ; preds = %endif-block50
  %779 = getelementptr { i32, [4 x float], [2 x [4 x float]] }*, { i32, [4 x float], [2 x [4 x float]] }** %3, i32 0
  %780 = load { i32, [4 x float], [2 x [4 x float]] }*, { i32, [4 x float], [2 x [4 x float]] }** %779, align 8
  %781 = load <4 x float>, <4 x float>* %output, align 16
  %782 = load <4 x float>, <4 x float>* %output1, align 16
  %783 = load <4 x float>, <4 x float>* %output2, align 16
  %784 = load <4 x float>, <4 x float>* %output3, align 16
  %785 = shufflevector <4 x float> %781, <4 x float> %782, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
  %786 = shufflevector <4 x float> %781, <4 x float> %782, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
  %t086 = bitcast <4 x float> %785 to <2 x double>
  %t287 = bitcast <4 x float> %786 to <2 x double>
  %787 = shufflevector <4 x float> %783, <4 x float> %784, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
  %788 = shufflevector <4 x float> %783, <4 x float> %784, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
  %t188 = bitcast <4 x float> %787 to <2 x double>
  %t389 = bitcast <4 x float> %788 to <2 x double>
  %789 = shufflevector <2 x double> %t086, <2 x double> %t188, <2 x i32> <i32 0, i32 2>
  %790 = shufflevector <2 x double> %t086, <2 x double> %t188, <2 x i32> <i32 1, i32 3>
  %791 = shufflevector <2 x double> %t287, <2 x double> %t389, <2 x i32> <i32 0, i32 2>
  %792 = shufflevector <2 x double> %t287, <2 x double> %t389, <2 x i32> <i32 1, i32 3>
  %dst090 = bitcast <2 x double> %789 to <4 x float>
  %dst191 = bitcast <2 x double> %790 to <4 x float>
  %dst292 = bitcast <2 x double> %791 to <4 x float>
  %dst393 = bitcast <2 x double> %792 to <4 x float>
  %793 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %780, i32 %766
  %794 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %780, i32 %770
  %795 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %780, i32 %774
  %796 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %780, i32 %778
  %797 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %793, i32 0, i32 0
  store i32 -49152, i32* %797, align 4
  %798 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %794, i32 0, i32 0
  store i32 -49152, i32* %798, align 4
  %799 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %795, i32 0, i32 0
  store i32 -49152, i32* %799, align 4
  %800 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %796, i32 0, i32 0
  store i32 -49152, i32* %800, align 4
  %801 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %793, i32 0, i32 2
  %802 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %801, i32 0, i32 0, i32 0
  %803 = bitcast float* %802 to <4 x float>*
  store <4 x float> %dst090, <4 x float>* %803, align 4
  %804 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %794, i32 0, i32 2
  %805 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %804, i32 0, i32 0, i32 0
  %806 = bitcast float* %805 to <4 x float>*
  store <4 x float> %dst191, <4 x float>* %806, align 4
  %807 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %795, i32 0, i32 2
  %808 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %807, i32 0, i32 0, i32 0
  %809 = bitcast float* %808 to <4 x float>*
  store <4 x float> %dst292, <4 x float>* %809, align 4
  %810 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %796, i32 0, i32 2
  %811 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %810, i32 0, i32 0, i32 0
  %812 = bitcast float* %811 to <4 x float>*
  store <4 x float> %dst393, <4 x float>* %812, align 4
  %813 = load <4 x float>, <4 x float>* %output4, align 16
  %814 = load <4 x float>, <4 x float>* %output5, align 16
  %815 = load <4 x float>, <4 x float>* %output6, align 16
  %816 = load <4 x float>, <4 x float>* %output7, align 16
  %817 = shufflevector <4 x float> %813, <4 x float> %814, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
  %818 = shufflevector <4 x float> %813, <4 x float> %814, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
  %t094 = bitcast <4 x float> %817 to <2 x double>
  %t295 = bitcast <4 x float> %818 to <2 x double>
  %819 = shufflevector <4 x float> %815, <4 x float> %816, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
  %820 = shufflevector <4 x float> %815, <4 x float> %816, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
  %t196 = bitcast <4 x float> %819 to <2 x double>
  %t397 = bitcast <4 x float> %820 to <2 x double>
  %821 = shufflevector <2 x double> %t094, <2 x double> %t196, <2 x i32> <i32 0, i32 2>
  %822 = shufflevector <2 x double> %t094, <2 x double> %t196, <2 x i32> <i32 1, i32 3>
  %823 = shufflevector <2 x double> %t295, <2 x double> %t397, <2 x i32> <i32 0, i32 2>
  %824 = shufflevector <2 x double> %t295, <2 x double> %t397, <2 x i32> <i32 1, i32 3>
  %dst098 = bitcast <2 x double> %821 to <4 x float>
  %dst199 = bitcast <2 x double> %822 to <4 x float>
  %dst2100 = bitcast <2 x double> %823 to <4 x float>
  %dst3101 = bitcast <2 x double> %824 to <4 x float>
  %825 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %780, i32 %766
  %826 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %780, i32 %770
  %827 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %780, i32 %774
  %828 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %780, i32 %778
  %829 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %825, i32 0, i32 2
  %830 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %829, i32 0, i32 1, i32 0
  %831 = bitcast float* %830 to <4 x float>*
  store <4 x float> %dst098, <4 x float>* %831, align 4
  %832 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %826, i32 0, i32 2
  %833 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %832, i32 0, i32 1, i32 0
  %834 = bitcast float* %833 to <4 x float>*
  store <4 x float> %dst199, <4 x float>* %834, align 4
  %835 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %827, i32 0, i32 2
  %836 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %835, i32 0, i32 1, i32 0
  %837 = bitcast float* %836 to <4 x float>*
  store <4 x float> %dst2100, <4 x float>* %837, align 4
  %838 = getelementptr { i32, [4 x float], [2 x [4 x float]] }, { i32, [4 x float], [2 x [4 x float]] }* %828, i32 0, i32 2
  %839 = getelementptr [2 x [4 x float]], [2 x [4 x float]]* %838, i32 0, i32 1, i32 0
  %840 = bitcast float* %839 to <4 x float>*
  store <4 x float> %dst3101, <4 x float>* %840, align 4
  br label %endif-block84

endif-block84:                                    ; preds = %endif-block50, %if-true-block85
  %841 = load <4 x i32>, <4 x i32>* %emitted_vertices_ptr, align 16
  %842 = sub <4 x i32> %841, %761
  store <4 x i32> %842, <4 x i32>* %emitted_vertices_ptr, align 16
  %843 = load <4 x i32>, <4 x i32>* %total_emitted_vertices_ptr, align 16
  %844 = sub <4 x i32> %843, %761
  store <4 x i32> %844, <4 x i32>* %total_emitted_vertices_ptr, align 16
  %845 = load <4 x i32>, <4 x i32>* %execution_mask, align 16
  %846 = load <4 x i32>, <4 x i32>* %emitted_vertices_ptr, align 16
  %847 = load <4 x i32>, <4 x i32>* %emitted_prims_ptr, align 16
  %848 = load <4 x i32>, <4 x i32>* %total_emitted_vertices_ptr, align 16
  %849 = icmp ne <4 x i32> %846, zeroinitializer
  %850 = sext <4 x i1> %849 to <4 x i32>
  %851 = and <4 x i32> %845, %850
  %852 = getelementptr { [14 x [4 x float]]*, float*, i32**, <4 x i32>*, <4 x i32>* }, { [14 x [4 x float]]*, float*, i32**, <4 x i32>*, <4 x i32>* }* %0, i32 0, i32 2
  %853 = load i32**, i32*** %852, align 8
  %854 = icmp ne <4 x i32> %851, zeroinitializer
  %855 = extractelement <4 x i32> %847, i32 0
  %856 = extractelement <4 x i32> %846, i32 0
  %857 = extractelement <4 x i1> %854, i32 0
  br i1 %857, label %if-true-block103, label %endif-block102

if-true-block103:                                 ; preds = %endif-block84
  %858 = mul i32 %855, 1
  %859 = add i32 %858, 0
  %860 = getelementptr i32*, i32** %853, i32 %859
  %861 = load i32*, i32** %860, align 8
  %862 = getelementptr i32, i32* %861, i32 0
  store i32 %856, i32* %862, align 4
  br label %endif-block102

endif-block102:                                   ; preds = %endif-block84, %if-true-block103
  %863 = extractelement <4 x i32> %847, i32 1
  %864 = extractelement <4 x i32> %846, i32 1
  %865 = extractelement <4 x i1> %854, i32 1
  br i1 %865, label %if-true-block105, label %endif-block104

if-true-block105:                                 ; preds = %endif-block102
  %866 = mul i32 %863, 1
  %867 = add i32 %866, 0
  %868 = getelementptr i32*, i32** %853, i32 %867
  %869 = load i32*, i32** %868, align 8
  %870 = getelementptr i32, i32* %869, i32 1
  store i32 %864, i32* %870, align 4
  br label %endif-block104

endif-block104:                                   ; preds = %endif-block102, %if-true-block105
  %871 = extractelement <4 x i32> %847, i32 2
  %872 = extractelement <4 x i32> %846, i32 2
  %873 = extractelement <4 x i1> %854, i32 2
  br i1 %873, label %if-true-block107, label %endif-block106

if-true-block107:                                 ; preds = %endif-block104
  %874 = mul i32 %871, 1
  %875 = add i32 %874, 0
  %876 = getelementptr i32*, i32** %853, i32 %875
  %877 = load i32*, i32** %876, align 8
  %878 = getelementptr i32, i32* %877, i32 2
  store i32 %872, i32* %878, align 4
  br label %endif-block106

endif-block106:                                   ; preds = %endif-block104, %if-true-block107
  %879 = extractelement <4 x i32> %847, i32 3
  %880 = extractelement <4 x i32> %846, i32 3
  %881 = extractelement <4 x i1> %854, i32 3
  br i1 %881, label %if-true-block109, label %endif-block108

if-true-block109:                                 ; preds = %endif-block106
  %882 = mul i32 %879, 1
  %883 = add i32 %882, 0
  %884 = getelementptr i32*, i32** %853, i32 %883
  %885 = load i32*, i32** %884, align 8
  %886 = getelementptr i32, i32* %885, i32 3
  store i32 %880, i32* %886, align 4
  br label %endif-block108

endif-block108:                                   ; preds = %endif-block106, %if-true-block109
  %887 = load <4 x i32>, <4 x i32>* %emitted_prims_ptr, align 16
  %888 = sub <4 x i32> %887, %851
  store <4 x i32> %888, <4 x i32>* %emitted_prims_ptr, align 16
  %889 = load <4 x i32>, <4 x i32>* %emitted_vertices_ptr, align 16
  %890 = and <4 x i32> zeroinitializer, %851
  %891 = xor <4 x i32> %851, <i32 -1, i32 -1, i32 -1, i32 -1>
  %892 = and <4 x i32> %889, %891
  %893 = or <4 x i32> %890, %892
  store <4 x i32> %893, <4 x i32>* %emitted_vertices_ptr, align 16
  %894 = load <4 x i32>, <4 x i32>* %total_emitted_vertices_ptr, align 16
  %895 = load <4 x i32>, <4 x i32>* %emitted_prims_ptr, align 16
  %896 = getelementptr { [14 x [4 x float]]*, float*, i32**, <4 x i32>*, <4 x i32>* }, { [14 x [4 x float]]*, float*, i32**, <4 x i32>*, <4 x i32>* }* %0, i32 0, i32 3
  %897 = load <4 x i32>*, <4 x i32>** %896, align 8
  %898 = getelementptr { [14 x [4 x float]]*, float*, i32**, <4 x i32>*, <4 x i32>* }, { [14 x [4 x float]]*, float*, i32**, <4 x i32>*, <4 x i32>* }* %0, i32 0, i32 4
  %899 = load <4 x i32>*, <4 x i32>** %898, align 8
  %900 = getelementptr <4 x i32>, <4 x i32>* %897, i32 0
  %901 = getelementptr <4 x i32>, <4 x i32>* %899, i32 0
  store <4 x i32> %894, <4 x i32>* %900, align 16
  store <4 x i32> %895, <4 x i32>* %901, align 16
  br label %skip

skip:                                             ; preds = %endif-block108
  %902 = load <4 x i32>, <4 x i32>* %execution_mask, align 16
  ret i32 0
}
shader_runner: ../src/gallium/auxiliary/gallivm/lp_bld_init.c:530: gallivm_verify_function: Assertion `0' failed.