llvm/test/CodeGen/AMDGPU/si-sgpr-spill.ll

; RUN: llc -march=amdgcn -mcpu=SI < %s | FileCheck %s
; RUN: llc -march=amdgcn -mcpu=tonga < %s | FileCheck %s

; These tests check that the compiler won't crash when it needs to spill
; SGPRs.

@ddxy_lds = external addrspace(3) global [64 x i32]

; CHECK-LABEL: {{^}}main:
; CHECK: s_wqm

; Make sure not emitting unused scratch resource descriptor setup
; CHECK-NOT: s_mov_b32
; CHECK-NOT: s_mov_b32
; CHECK-NOT: s_mov_b32
; CHECK-NOT: s_mov_b32

; CHECK: s_mov_b32 m0


; Writing to M0 from an SMRD instruction will hang the GPU.
; CHECK-NOT: s_buffer_load_dword m0
; CHECK: s_endpgm
define void @main([17 x <16 x i8>] addrspace(2)* byval, [32 x <16 x i8>] addrspace(2)* byval, [16 x <32 x i8>] addrspace(2)* byval, float inreg, i32 inreg, <2 x i32>, <2 x i32>, <2 x i32>, <3 x i32>, <2 x i32>, <2 x i32>, <2 x i32>, float, float, float, float, float, float, float, float, float) #1 {
main_body:
  %21 = getelementptr [17 x <16 x i8>], [17 x <16 x i8>] addrspace(2)* %0, i64 0, i32 0
  %22 = load <16 x i8>, <16 x i8> addrspace(2)* %21, !tbaa !0
  %23 = call float @llvm.SI.load.const(<16 x i8> %22, i32 96)
  %24 = call float @llvm.SI.load.const(<16 x i8> %22, i32 100)
  %25 = call float @llvm.SI.load.const(<16 x i8> %22, i32 104)
  %26 = call float @llvm.SI.load.const(<16 x i8> %22, i32 112)
  %27 = call float @llvm.SI.load.const(<16 x i8> %22, i32 116)
  %28 = call float @llvm.SI.load.const(<16 x i8> %22, i32 120)
  %29 = call float @llvm.SI.load.const(<16 x i8> %22, i32 128)
  %30 = call float @llvm.SI.load.const(<16 x i8> %22, i32 132)
  %31 = call float @llvm.SI.load.const(<16 x i8> %22, i32 140)
  %32 = call float @llvm.SI.load.const(<16 x i8> %22, i32 144)
  %33 = call float @llvm.SI.load.const(<16 x i8> %22, i32 160)
  %34 = call float @llvm.SI.load.const(<16 x i8> %22, i32 176)
  %35 = call float @llvm.SI.load.const(<16 x i8> %22, i32 180)
  %36 = call float @llvm.SI.load.const(<16 x i8> %22, i32 184)
  %37 = call float @llvm.SI.load.const(<16 x i8> %22, i32 192)
  %38 = call float @llvm.SI.load.const(<16 x i8> %22, i32 196)
  %39 = call float @llvm.SI.load.const(<16 x i8> %22, i32 200)
  %40 = call float @llvm.SI.load.const(<16 x i8> %22, i32 208)
  %41 = call float @llvm.SI.load.const(<16 x i8> %22, i32 212)
  %42 = call float @llvm.SI.load.const(<16 x i8> %22, i32 216)
  %43 = call float @llvm.SI.load.const(<16 x i8> %22, i32 224)
  %44 = call float @llvm.SI.load.const(<16 x i8> %22, i32 240)
  %45 = call float @llvm.SI.load.const(<16 x i8> %22, i32 244)
  %46 = call float @llvm.SI.load.const(<16 x i8> %22, i32 248)
  %47 = call float @llvm.SI.load.const(<16 x i8> %22, i32 256)
  %48 = call float @llvm.SI.load.const(<16 x i8> %22, i32 272)
  %49 = call float @llvm.SI.load.const(<16 x i8> %22, i32 276)
  %50 = call float @llvm.SI.load.const(<16 x i8> %22, i32 280)
  %51 = call float @llvm.SI.load.const(<16 x i8> %22, i32 288)
  %52 = call float @llvm.SI.load.const(<16 x i8> %22, i32 292)
  %53 = call float @llvm.SI.load.const(<16 x i8> %22, i32 296)
  %54 = call float @llvm.SI.load.const(<16 x i8> %22, i32 304)
  %55 = call float @llvm.SI.load.const(<16 x i8> %22, i32 308)
  %56 = call float @llvm.SI.load.const(<16 x i8> %22, i32 312)
  %57 = call float @llvm.SI.load.const(<16 x i8> %22, i32 368)
  %58 = call float @llvm.SI.load.const(<16 x i8> %22, i32 372)
  %59 = call float @llvm.SI.load.const(<16 x i8> %22, i32 376)
  %60 = call float @llvm.SI.load.const(<16 x i8> %22, i32 384)
  %61 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 0
  %62 = load <32 x i8>, <32 x i8> addrspace(2)* %61, !tbaa !0
  %63 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 0
  %64 = load <16 x i8>, <16 x i8> addrspace(2)* %63, !tbaa !0
  %65 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 1
  %66 = load <32 x i8>, <32 x i8> addrspace(2)* %65, !tbaa !0
  %67 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 1
  %68 = load <16 x i8>, <16 x i8> addrspace(2)* %67, !tbaa !0
  %69 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 2
  %70 = load <32 x i8>, <32 x i8> addrspace(2)* %69, !tbaa !0
  %71 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 2
  %72 = load <16 x i8>, <16 x i8> addrspace(2)* %71, !tbaa !0
  %73 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 3
  %74 = load <32 x i8>, <32 x i8> addrspace(2)* %73, !tbaa !0
  %75 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 3
  %76 = load <16 x i8>, <16 x i8> addrspace(2)* %75, !tbaa !0
  %77 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 4
  %78 = load <32 x i8>, <32 x i8> addrspace(2)* %77, !tbaa !0
  %79 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 4
  %80 = load <16 x i8>, <16 x i8> addrspace(2)* %79, !tbaa !0
  %81 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 5
  %82 = load <32 x i8>, <32 x i8> addrspace(2)* %81, !tbaa !0
  %83 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 5
  %84 = load <16 x i8>, <16 x i8> addrspace(2)* %83, !tbaa !0
  %85 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 6
  %86 = load <32 x i8>, <32 x i8> addrspace(2)* %85, !tbaa !0
  %87 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 6
  %88 = load <16 x i8>, <16 x i8> addrspace(2)* %87, !tbaa !0
  %89 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 7
  %90 = load <32 x i8>, <32 x i8> addrspace(2)* %89, !tbaa !0
  %91 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 7
  %92 = load <16 x i8>, <16 x i8> addrspace(2)* %91, !tbaa !0
  %93 = call float @llvm.SI.fs.interp(i32 0, i32 0, i32 %4, <2 x i32> %6)
  %94 = call float @llvm.SI.fs.interp(i32 1, i32 0, i32 %4, <2 x i32> %6)
  %95 = call float @llvm.SI.fs.interp(i32 0, i32 1, i32 %4, <2 x i32> %6)
  %96 = call float @llvm.SI.fs.interp(i32 1, i32 1, i32 %4, <2 x i32> %6)
  %97 = call float @llvm.SI.fs.interp(i32 2, i32 1, i32 %4, <2 x i32> %6)
  %98 = call float @llvm.SI.fs.interp(i32 0, i32 2, i32 %4, <2 x i32> %6)
  %99 = call float @llvm.SI.fs.interp(i32 1, i32 2, i32 %4, <2 x i32> %6)
  %100 = call float @llvm.SI.fs.interp(i32 2, i32 2, i32 %4, <2 x i32> %6)
  %101 = call float @llvm.SI.fs.interp(i32 0, i32 3, i32 %4, <2 x i32> %6)
  %102 = call float @llvm.SI.fs.interp(i32 1, i32 3, i32 %4, <2 x i32> %6)
  %103 = call float @llvm.SI.fs.interp(i32 2, i32 3, i32 %4, <2 x i32> %6)
  %104 = call float @llvm.SI.fs.interp(i32 0, i32 4, i32 %4, <2 x i32> %6)
  %105 = call float @llvm.SI.fs.interp(i32 1, i32 4, i32 %4, <2 x i32> %6)
  %106 = call float @llvm.SI.fs.interp(i32 2, i32 4, i32 %4, <2 x i32> %6)
  %107 = call float @llvm.SI.fs.interp(i32 0, i32 5, i32 %4, <2 x i32> %6)
  %108 = call float @llvm.SI.fs.interp(i32 1, i32 5, i32 %4, <2 x i32> %6)
  %109 = call float @llvm.SI.fs.interp(i32 2, i32 5, i32 %4, <2 x i32> %6)
  %110 = call i32 @llvm.SI.tid()
  %111 = getelementptr [64 x i32], [64 x i32] addrspace(3)* @ddxy_lds, i32 0, i32 %110
  %112 = bitcast float %93 to i32
  store i32 %112, i32 addrspace(3)* %111
  %113 = bitcast float %94 to i32
  store i32 %113, i32 addrspace(3)* %111
  %114 = call i32 @llvm.SI.tid()
  %115 = getelementptr [64 x i32], [64 x i32] addrspace(3)* @ddxy_lds, i32 0, i32 %114
  %116 = and i32 %114, -4
  %117 = getelementptr [64 x i32], [64 x i32] addrspace(3)* @ddxy_lds, i32 0, i32 %116
  %118 = add i32 %116, 1
  %119 = getelementptr [64 x i32], [64 x i32] addrspace(3)* @ddxy_lds, i32 0, i32 %118
  %120 = bitcast float %93 to i32
  store i32 %120, i32 addrspace(3)* %115
  %121 = load i32, i32 addrspace(3)* %117
  %122 = bitcast i32 %121 to float
  %123 = load i32, i32 addrspace(3)* %119
  %124 = bitcast i32 %123 to float
  %125 = fsub float %124, %122
  %126 = bitcast float %94 to i32
  store i32 %126, i32 addrspace(3)* %115
  %127 = load i32, i32 addrspace(3)* %117
  %128 = bitcast i32 %127 to float
  %129 = load i32, i32 addrspace(3)* %119
  %130 = bitcast i32 %129 to float
  %131 = fsub float %130, %128
  %132 = insertelement <4 x float> undef, float %125, i32 0
  %133 = insertelement <4 x float> %132, float %131, i32 1
  %134 = insertelement <4 x float> %133, float %131, i32 2
  %135 = insertelement <4 x float> %134, float %131, i32 3
  %136 = extractelement <4 x float> %135, i32 0
  %137 = extractelement <4 x float> %135, i32 1
  %138 = fmul float %60, %93
  %139 = fmul float %60, %94
  %140 = fmul float %60, %94
  %141 = fmul float %60, %94
  %142 = call i32 @llvm.SI.tid()
  %143 = getelementptr [64 x i32], [64 x i32] addrspace(3)* @ddxy_lds, i32 0, i32 %142
  %144 = bitcast float %138 to i32
  store i32 %144, i32 addrspace(3)* %143
  %145 = bitcast float %139 to i32
  store i32 %145, i32 addrspace(3)* %143
  %146 = bitcast float %140 to i32
  store i32 %146, i32 addrspace(3)* %143
  %147 = bitcast float %141 to i32
  store i32 %147, i32 addrspace(3)* %143
  %148 = call i32 @llvm.SI.tid()
  %149 = getelementptr [64 x i32], [64 x i32] addrspace(3)* @ddxy_lds, i32 0, i32 %148
  %150 = and i32 %148, -4
  %151 = getelementptr [64 x i32], [64 x i32] addrspace(3)* @ddxy_lds, i32 0, i32 %150
  %152 = add i32 %150, 2
  %153 = getelementptr [64 x i32], [64 x i32] addrspace(3)* @ddxy_lds, i32 0, i32 %152
  %154 = bitcast float %138 to i32
  store i32 %154, i32 addrspace(3)* %149
  %155 = load i32, i32 addrspace(3)* %151
  %156 = bitcast i32 %155 to float
  %157 = load i32, i32 addrspace(3)* %153
  %158 = bitcast i32 %157 to float
  %159 = fsub float %158, %156
  %160 = bitcast float %139 to i32
  store i32 %160, i32 addrspace(3)* %149
  %161 = load i32, i32 addrspace(3)* %151
  %162 = bitcast i32 %161 to float
  %163 = load i32, i32 addrspace(3)* %153
  %164 = bitcast i32 %163 to float
  %165 = fsub float %164, %162
  %166 = bitcast float %140 to i32
  store i32 %166, i32 addrspace(3)* %149
  %167 = load i32, i32 addrspace(3)* %151
  %168 = bitcast i32 %167 to float
  %169 = load i32, i32 addrspace(3)* %153
  %170 = bitcast i32 %169 to float
  %171 = fsub float %170, %168
  %172 = bitcast float %141 to i32
  store i32 %172, i32 addrspace(3)* %149
  %173 = load i32, i32 addrspace(3)* %151
  %174 = bitcast i32 %173 to float
  %175 = load i32, i32 addrspace(3)* %153
  %176 = bitcast i32 %175 to float
  %177 = fsub float %176, %174
  %178 = insertelement <4 x float> undef, float %159, i32 0
  %179 = insertelement <4 x float> %178, float %165, i32 1
  %180 = insertelement <4 x float> %179, float %171, i32 2
  %181 = insertelement <4 x float> %180, float %177, i32 3
  %182 = extractelement <4 x float> %181, i32 0
  %183 = extractelement <4 x float> %181, i32 1
  %184 = fdiv float 1.000000e+00, %97
  %185 = fmul float %33, %184
  %186 = fcmp uge float 1.000000e+00, %185
  %187 = select i1 %186, float %185, float 1.000000e+00
  %188 = fmul float %187, %30
  %189 = call float @ceil(float %188)
  %190 = fcmp uge float 3.000000e+00, %189
  %191 = select i1 %190, float 3.000000e+00, float %189
  %192 = fdiv float 1.000000e+00, %191
  %193 = fdiv float 1.000000e+00, %30
  %194 = fmul float %191, %193
  %195 = fmul float %31, %194
  %196 = fmul float %95, %95
  %197 = fmul float %96, %96
  %198 = fadd float %197, %196
  %199 = fmul float %97, %97
  %200 = fadd float %198, %199
  %201 = call float @llvm.amdgcn.rsq.f32(float %200)
  %202 = fmul float %95, %201
  %203 = fmul float %96, %201
  %204 = fmul float %202, %29
  %205 = fmul float %203, %29
  %206 = fmul float %204, -1.000000e+00
  %207 = fmul float %205, 1.000000e+00
  %208 = fmul float %206, %32
  %209 = fmul float %207, %32
  %210 = fsub float -0.000000e+00, %208
  %211 = fadd float %93, %210
  %212 = fsub float -0.000000e+00, %209
  %213 = fadd float %94, %212
  %214 = fmul float %206, %192
  %215 = fmul float %207, %192
  %216 = fmul float -1.000000e+00, %192
  %217 = bitcast float %136 to i32
  %218 = bitcast float %182 to i32
  %219 = bitcast float %137 to i32
  %220 = bitcast float %183 to i32
  %221 = insertelement <8 x i32> undef, i32 %217, i32 0
  %222 = insertelement <8 x i32> %221, i32 %218, i32 1
  %223 = insertelement <8 x i32> %222, i32 %219, i32 2
  %224 = insertelement <8 x i32> %223, i32 %220, i32 3
  br label %LOOP

LOOP:                                             ; preds = %ENDIF, %main_body
  %temp24.0 = phi float [ 1.000000e+00, %main_body ], [ %258, %ENDIF ]
  %temp28.0 = phi float [ %211, %main_body ], [ %253, %ENDIF ]
  %temp29.0 = phi float [ %213, %main_body ], [ %255, %ENDIF ]
  %temp30.0 = phi float [ 1.000000e+00, %main_body ], [ %257, %ENDIF ]
  %225 = fcmp oge float %temp24.0, %191
  %226 = sext i1 %225 to i32
  %227 = bitcast i32 %226 to float
  %228 = bitcast float %227 to i32
  %229 = icmp ne i32 %228, 0
  br i1 %229, label %IF, label %ENDIF

IF:                                               ; preds = %LOOP
  %230 = bitcast float %136 to i32
  %231 = bitcast float %182 to i32
  %232 = bitcast float %137 to i32
  %233 = bitcast float %183 to i32
  %234 = insertelement <8 x i32> undef, i32 %230, i32 0
  %235 = insertelement <8 x i32> %234, i32 %231, i32 1
  %236 = insertelement <8 x i32> %235, i32 %232, i32 2
  %237 = insertelement <8 x i32> %236, i32 %233, i32 3
  br label %LOOP65

ENDIF:                                            ; preds = %LOOP
  %238 = bitcast float %temp28.0 to i32
  %239 = bitcast float %temp29.0 to i32
  %240 = insertelement <8 x i32> %224, i32 %238, i32 4
  %241 = insertelement <8 x i32> %240, i32 %239, i32 5
  %242 = insertelement <8 x i32> %241, i32 undef, i32 6
  %243 = insertelement <8 x i32> %242, i32 undef, i32 7
  %244 = call <4 x float> @llvm.SI.sampled.v8i32(<8 x i32> %243, <32 x i8> %62, <16 x i8> %64, i32 2)
  %245 = extractelement <4 x float> %244, i32 3
  %246 = fcmp oge float %temp30.0, %245
  %247 = sext i1 %246 to i32
  %248 = bitcast i32 %247 to float
  %249 = bitcast float %248 to i32
  %250 = and i32 %249, 1065353216
  %251 = bitcast i32 %250 to float
  %252 = fmul float %214, %251
  %253 = fadd float %252, %temp28.0
  %254 = fmul float %215, %251
  %255 = fadd float %254, %temp29.0
  %256 = fmul float %216, %251
  %257 = fadd float %256, %temp30.0
  %258 = fadd float %temp24.0, 1.000000e+00
  br label %LOOP

LOOP65:                                           ; preds = %ENDIF66, %IF
  %temp24.1 = phi float [ 0.000000e+00, %IF ], [ %610, %ENDIF66 ]
  %temp28.1 = phi float [ %temp28.0, %IF ], [ %605, %ENDIF66 ]
  %temp29.1 = phi float [ %temp29.0, %IF ], [ %607, %ENDIF66 ]
  %temp30.1 = phi float [ %temp30.0, %IF ], [ %609, %ENDIF66 ]
  %temp32.0 = phi float [ 1.000000e+00, %IF ], [ %611, %ENDIF66 ]
  %259 = fcmp oge float %temp24.1, %195
  %260 = sext i1 %259 to i32
  %261 = bitcast i32 %260 to float
  %262 = bitcast float %261 to i32
  %263 = icmp ne i32 %262, 0
  br i1 %263, label %IF67, label %ENDIF66

IF67:                                             ; preds = %LOOP65
  %264 = bitcast float %136 to i32
  %265 = bitcast float %182 to i32
  %266 = bitcast float %137 to i32
  %267 = bitcast float %183 to i32
  %268 = bitcast float %temp28.1 to i32
  %269 = bitcast float %temp29.1 to i32
  %270 = insertelement <8 x i32> undef, i32 %264, i32 0
  %271 = insertelement <8 x i32> %270, i32 %265, i32 1
  %272 = insertelement <8 x i32> %271, i32 %266, i32 2
  %273 = insertelement <8 x i32> %272, i32 %267, i32 3
  %274 = insertelement <8 x i32> %273, i32 %268, i32 4
  %275 = insertelement <8 x i32> %274, i32 %269, i32 5
  %276 = insertelement <8 x i32> %275, i32 undef, i32 6
  %277 = insertelement <8 x i32> %276, i32 undef, i32 7
  %278 = call <4 x float> @llvm.SI.sampled.v8i32(<8 x i32> %277, <32 x i8> %66, <16 x i8> %68, i32 2)
  %279 = extractelement <4 x float> %278, i32 0
  %280 = extractelement <4 x float> %278, i32 1
  %281 = extractelement <4 x float> %278, i32 2
  %282 = extractelement <4 x float> %278, i32 3
  %283 = fmul float %282, %47
  %284 = bitcast float %136 to i32
  %285 = bitcast float %182 to i32
  %286 = bitcast float %137 to i32
  %287 = bitcast float %183 to i32
  %288 = bitcast float %temp28.1 to i32
  %289 = bitcast float %temp29.1 to i32
  %290 = insertelement <8 x i32> undef, i32 %284, i32 0
  %291 = insertelement <8 x i32> %290, i32 %285, i32 1
  %292 = insertelement <8 x i32> %291, i32 %286, i32 2
  %293 = insertelement <8 x i32> %292, i32 %287, i32 3
  %294 = insertelement <8 x i32> %293, i32 %288, i32 4
  %295 = insertelement <8 x i32> %294, i32 %289, i32 5
  %296 = insertelement <8 x i32> %295, i32 undef, i32 6
  %297 = insertelement <8 x i32> %296, i32 undef, i32 7
  %298 = call <4 x float> @llvm.SI.sampled.v8i32(<8 x i32> %297, <32 x i8> %82, <16 x i8> %84, i32 2)
  %299 = extractelement <4 x float> %298, i32 0
  %300 = extractelement <4 x float> %298, i32 1
  %301 = extractelement <4 x float> %298, i32 2
  %302 = bitcast float %136 to i32
  %303 = bitcast float %182 to i32
  %304 = bitcast float %137 to i32
  %305 = bitcast float %183 to i32
  %306 = bitcast float %temp28.1 to i32
  %307 = bitcast float %temp29.1 to i32
  %308 = insertelement <8 x i32> undef, i32 %302, i32 0
  %309 = insertelement <8 x i32> %308, i32 %303, i32 1
  %310 = insertelement <8 x i32> %309, i32 %304, i32 2
  %311 = insertelement <8 x i32> %310, i32 %305, i32 3
  %312 = insertelement <8 x i32> %311, i32 %306, i32 4
  %313 = insertelement <8 x i32> %312, i32 %307, i32 5
  %314 = insertelement <8 x i32> %313, i32 undef, i32 6
  %315 = insertelement <8 x i32> %314, i32 undef, i32 7
  %316 = call <4 x float> @llvm.SI.sampled.v8i32(<8 x i32> %315, <32 x i8> %78, <16 x i8> %80, i32 2)
  %317 = extractelement <4 x float> %316, i32 0
  %318 = extractelement <4 x float> %316, i32 1
  %319 = extractelement <4 x float> %316, i32 2
  %320 = fmul float %317, %23
  %321 = fmul float %318, %24
  %322 = fmul float %319, %25
  %323 = fmul float %299, %26
  %324 = fadd float %323, %320
  %325 = fmul float %300, %27
  %326 = fadd float %325, %321
  %327 = fmul float %301, %28
  %328 = fadd float %327, %322
  %329 = fadd float %279, %324
  %330 = fadd float %280, %326
  %331 = fadd float %281, %328
  %332 = bitcast float %136 to i32
  %333 = bitcast float %182 to i32
  %334 = bitcast float %137 to i32
  %335 = bitcast float %183 to i32
  %336 = bitcast float %temp28.1 to i32
  %337 = bitcast float %temp29.1 to i32
  %338 = insertelement <8 x i32> undef, i32 %332, i32 0
  %339 = insertelement <8 x i32> %338, i32 %333, i32 1
  %340 = insertelement <8 x i32> %339, i32 %334, i32 2
  %341 = insertelement <8 x i32> %340, i32 %335, i32 3
  %342 = insertelement <8 x i32> %341, i32 %336, i32 4
  %343 = insertelement <8 x i32> %342, i32 %337, i32 5
  %344 = insertelement <8 x i32> %343, i32 undef, i32 6
  %345 = insertelement <8 x i32> %344, i32 undef, i32 7
  %346 = call <4 x float> @llvm.SI.sampled.v8i32(<8 x i32> %345, <32 x i8> %62, <16 x i8> %64, i32 2)
  %347 = extractelement <4 x float> %346, i32 0
  %348 = extractelement <4 x float> %346, i32 1
  %349 = extractelement <4 x float> %346, i32 2
  %350 = fadd float %347, -5.000000e-01
  %351 = fadd float %348, -5.000000e-01
  %352 = fadd float %349, -5.000000e-01
  %353 = fmul float %350, %350
  %354 = fmul float %351, %351
  %355 = fadd float %354, %353
  %356 = fmul float %352, %352
  %357 = fadd float %355, %356
  %358 = call float @llvm.amdgcn.rsq.f32(float %357)
  %359 = fmul float %350, %358
  %360 = fmul float %351, %358
  %361 = fmul float %352, %358
  %362 = bitcast float %136 to i32
  %363 = bitcast float %182 to i32
  %364 = bitcast float %137 to i32
  %365 = bitcast float %183 to i32
  %366 = bitcast float %temp28.1 to i32
  %367 = bitcast float %temp29.1 to i32
  %368 = insertelement <8 x i32> undef, i32 %362, i32 0
  %369 = insertelement <8 x i32> %368, i32 %363, i32 1
  %370 = insertelement <8 x i32> %369, i32 %364, i32 2
  %371 = insertelement <8 x i32> %370, i32 %365, i32 3
  %372 = insertelement <8 x i32> %371, i32 %366, i32 4
  %373 = insertelement <8 x i32> %372, i32 %367, i32 5
  %374 = insertelement <8 x i32> %373, i32 undef, i32 6
  %375 = insertelement <8 x i32> %374, i32 undef, i32 7
  %376 = call <4 x float> @llvm.SI.sampled.v8i32(<8 x i32> %375, <32 x i8> %70, <16 x i8> %72, i32 2)
  %377 = extractelement <4 x float> %376, i32 0
  %378 = extractelement <4 x float> %376, i32 1
  %379 = extractelement <4 x float> %376, i32 2
  %380 = extractelement <4 x float> %376, i32 3
  %381 = fsub float -0.000000e+00, %95
  %382 = fsub float -0.000000e+00, %96
  %383 = fsub float -0.000000e+00, %97
  %384 = fmul float %359, %381
  %385 = fmul float %360, %382
  %386 = fadd float %385, %384
  %387 = fmul float %361, %383
  %388 = fadd float %386, %387
  %389 = fmul float %388, %359
  %390 = fmul float %388, %360
  %391 = fmul float %388, %361
  %392 = fmul float 2.000000e+00, %389
  %393 = fmul float 2.000000e+00, %390
  %394 = fmul float 2.000000e+00, %391
  %395 = fsub float -0.000000e+00, %392
  %396 = fadd float %381, %395
  %397 = fsub float -0.000000e+00, %393
  %398 = fadd float %382, %397
  %399 = fsub float -0.000000e+00, %394
  %400 = fadd float %383, %399
  %401 = fmul float %396, %98
  %402 = fmul float %396, %99
  %403 = fmul float %396, %100
  %404 = fmul float %398, %101
  %405 = fadd float %404, %401
  %406 = fmul float %398, %102
  %407 = fadd float %406, %402
  %408 = fmul float %398, %103
  %409 = fadd float %408, %403
  %410 = fmul float %400, %104
  %411 = fadd float %410, %405
  %412 = fmul float %400, %105
  %413 = fadd float %412, %407
  %414 = fmul float %400, %106
  %415 = fadd float %414, %409
  %416 = bitcast float %136 to i32
  %417 = bitcast float %182 to i32
  %418 = bitcast float %137 to i32
  %419 = bitcast float %183 to i32
  %420 = bitcast float %temp28.1 to i32
  %421 = bitcast float %temp29.1 to i32
  %422 = insertelement <8 x i32> undef, i32 %416, i32 0
  %423 = insertelement <8 x i32> %422, i32 %417, i32 1
  %424 = insertelement <8 x i32> %423, i32 %418, i32 2
  %425 = insertelement <8 x i32> %424, i32 %419, i32 3
  %426 = insertelement <8 x i32> %425, i32 %420, i32 4
  %427 = insertelement <8 x i32> %426, i32 %421, i32 5
  %428 = insertelement <8 x i32> %427, i32 undef, i32 6
  %429 = insertelement <8 x i32> %428, i32 undef, i32 7
  %430 = call <4 x float> @llvm.SI.sampled.v8i32(<8 x i32> %429, <32 x i8> %86, <16 x i8> %88, i32 2)
  %431 = extractelement <4 x float> %430, i32 0
  %432 = extractelement <4 x float> %430, i32 1
  %433 = extractelement <4 x float> %430, i32 2
  %434 = fmul float %48, %411
  %435 = fmul float %49, %411
  %436 = fmul float %50, %411
  %437 = fmul float %51, %413
  %438 = fadd float %437, %434
  %439 = fmul float %52, %413
  %440 = fadd float %439, %435
  %441 = fmul float %53, %413
  %442 = fadd float %441, %436
  %443 = fmul float %54, %415
  %444 = fadd float %443, %438
  %445 = fmul float %55, %415
  %446 = fadd float %445, %440
  %447 = fmul float %56, %415
  %448 = fadd float %447, %442
  %449 = insertelement <4 x float> undef, float %444, i32 0
  %450 = insertelement <4 x float> %449, float %446, i32 1
  %451 = insertelement <4 x float> %450, float %448, i32 2
  %452 = insertelement <4 x float> %451, float %195, i32 3
  %453 = call <4 x float> @llvm.AMDGPU.cube(<4 x float> %452)
  %454 = extractelement <4 x float> %453, i32 0
  %455 = extractelement <4 x float> %453, i32 1
  %456 = extractelement <4 x float> %453, i32 2
  %457 = extractelement <4 x float> %453, i32 3
  %458 = call float @fabs(float %456)
  %459 = fdiv float 1.000000e+00, %458
  %460 = fmul float %454, %459
  %461 = fadd float %460, 1.500000e+00
  %462 = fmul float %455, %459
  %463 = fadd float %462, 1.500000e+00
  %464 = bitcast float %463 to i32
  %465 = bitcast float %461 to i32
  %466 = bitcast float %457 to i32
  %467 = insertelement <4 x i32> undef, i32 %464, i32 0
  %468 = insertelement <4 x i32> %467, i32 %465, i32 1
  %469 = insertelement <4 x i32> %468, i32 %466, i32 2
  %470 = insertelement <4 x i32> %469, i32 undef, i32 3
  %471 = call <4 x float> @llvm.SI.sample.v4i32(<4 x i32> %470, <32 x i8> %90, <16 x i8> %92, i32 4)
  %472 = extractelement <4 x float> %471, i32 0
  %473 = extractelement <4 x float> %471, i32 1
  %474 = extractelement <4 x float> %471, i32 2
  %475 = fmul float %431, %472
  %476 = fadd float %475, %329
  %477 = fmul float %432, %473
  %478 = fadd float %477, %330
  %479 = fmul float %433, %474
  %480 = fadd float %479, %331
  %481 = fmul float %107, %107
  %482 = fmul float %108, %108
  %483 = fadd float %482, %481
  %484 = fmul float %109, %109
  %485 = fadd float %483, %484
  %486 = call float @llvm.amdgcn.rsq.f32(float %485)
  %487 = fmul float %107, %486
  %488 = fmul float %108, %486
  %489 = fmul float %109, %486
  %490 = fmul float %377, %40
  %491 = fmul float %378, %41
  %492 = fmul float %379, %42
  %493 = fmul float %359, %487
  %494 = fmul float %360, %488
  %495 = fadd float %494, %493
  %496 = fmul float %361, %489
  %497 = fadd float %495, %496
  %498 = fmul float %497, %359
  %499 = fmul float %497, %360
  %500 = fmul float %497, %361
  %501 = fmul float 2.000000e+00, %498
  %502 = fmul float 2.000000e+00, %499
  %503 = fmul float 2.000000e+00, %500
  %504 = fsub float -0.000000e+00, %501
  %505 = fadd float %487, %504
  %506 = fsub float -0.000000e+00, %502
  %507 = fadd float %488, %506
  %508 = fsub float -0.000000e+00, %503
  %509 = fadd float %489, %508
  %510 = fmul float %95, %95
  %511 = fmul float %96, %96
  %512 = fadd float %511, %510
  %513 = fmul float %97, %97
  %514 = fadd float %512, %513
  %515 = call float @llvm.amdgcn.rsq.f32(float %514)
  %516 = fmul float %95, %515
  %517 = fmul float %96, %515
  %518 = fmul float %97, %515
  %519 = fmul float %505, %516
  %520 = fmul float %507, %517
  %521 = fadd float %520, %519
  %522 = fmul float %509, %518
  %523 = fadd float %521, %522
  %524 = fsub float -0.000000e+00, %523
  %525 = fcmp uge float %524, 0.000000e+00
  %526 = select i1 %525, float %524, float 0.000000e+00
  %527 = fmul float %43, %380
  %528 = fadd float %527, 1.000000e+00
  %529 = call float @llvm.pow.f32(float %526, float %528)
  %530 = fmul float %476, %37
  %531 = fmul float %478, %38
  %532 = fmul float %480, %39
  %533 = fmul float %359, %487
  %534 = fmul float %360, %488
  %535 = fadd float %534, %533
  %536 = fmul float %361, %489
  %537 = fadd float %535, %536
  %538 = fcmp uge float %537, 0.000000e+00
  %539 = select i1 %538, float %537, float 0.000000e+00
  %540 = fmul float %530, %539
  %541 = fmul float %531, %539
  %542 = fmul float %532, %539
  %543 = fmul float %490, %529
  %544 = fadd float %543, %540
  %545 = fmul float %491, %529
  %546 = fadd float %545, %541
  %547 = fmul float %492, %529
  %548 = fadd float %547, %542
  %549 = fmul float %476, %34
  %550 = fmul float %478, %35
  %551 = fmul float %480, %36
  %552 = fmul float %544, %57
  %553 = fadd float %552, %549
  %554 = fmul float %546, %58
  %555 = fadd float %554, %550
  %556 = fmul float %548, %59
  %557 = fadd float %556, %551
  %558 = bitcast float %136 to i32
  %559 = bitcast float %182 to i32
  %560 = bitcast float %137 to i32
  %561 = bitcast float %183 to i32
  %562 = bitcast float %temp28.1 to i32
  %563 = bitcast float %temp29.1 to i32
  %564 = insertelement <8 x i32> undef, i32 %558, i32 0
  %565 = insertelement <8 x i32> %564, i32 %559, i32 1
  %566 = insertelement <8 x i32> %565, i32 %560, i32 2
  %567 = insertelement <8 x i32> %566, i32 %561, i32 3
  %568 = insertelement <8 x i32> %567, i32 %562, i32 4
  %569 = insertelement <8 x i32> %568, i32 %563, i32 5
  %570 = insertelement <8 x i32> %569, i32 undef, i32 6
  %571 = insertelement <8 x i32> %570, i32 undef, i32 7
  %572 = call <4 x float> @llvm.SI.sampled.v8i32(<8 x i32> %571, <32 x i8> %74, <16 x i8> %76, i32 2)
  %573 = extractelement <4 x float> %572, i32 0
  %574 = extractelement <4 x float> %572, i32 1
  %575 = extractelement <4 x float> %572, i32 2
  %576 = fmul float %573, %44
  %577 = fadd float %576, %553
  %578 = fmul float %574, %45
  %579 = fadd float %578, %555
  %580 = fmul float %575, %46
  %581 = fadd float %580, %557
  %582 = call i32 @llvm.SI.packf16(float %577, float %579)
  %583 = bitcast i32 %582 to float
  %584 = call i32 @llvm.SI.packf16(float %581, float %283)
  %585 = bitcast i32 %584 to float
  call void @llvm.SI.export(i32 15, i32 1, i32 1, i32 0, i32 1, float %583, float %585, float %583, float %585)
  ret void

ENDIF66:                                          ; preds = %LOOP65
  %586 = bitcast float %temp28.1 to i32
  %587 = bitcast float %temp29.1 to i32
  %588 = insertelement <8 x i32> %237, i32 %586, i32 4
  %589 = insertelement <8 x i32> %588, i32 %587, i32 5
  %590 = insertelement <8 x i32> %589, i32 undef, i32 6
  %591 = insertelement <8 x i32> %590, i32 undef, i32 7
  %592 = call <4 x float> @llvm.SI.sampled.v8i32(<8 x i32> %591, <32 x i8> %62, <16 x i8> %64, i32 2)
  %593 = extractelement <4 x float> %592, i32 3
  %594 = fcmp oge float %temp30.1, %593
  %595 = sext i1 %594 to i32
  %596 = bitcast i32 %595 to float
  %597 = bitcast float %596 to i32
  %598 = and i32 %597, 1065353216
  %599 = bitcast i32 %598 to float
  %600 = fmul float 5.000000e-01, %temp32.0
  %601 = fsub float -0.000000e+00, %600
  %602 = fmul float %599, %temp32.0
  %603 = fadd float %602, %601
  %604 = fmul float %214, %603
  %605 = fadd float %604, %temp28.1
  %606 = fmul float %215, %603
  %607 = fadd float %606, %temp29.1
  %608 = fmul float %216, %603
  %609 = fadd float %608, %temp30.1
  %610 = fadd float %temp24.1, 1.000000e+00
  %611 = fmul float %temp32.0, 5.000000e-01
  br label %LOOP65
}

; CHECK-LABEL: {{^}}main1:
; CHECK: s_endpgm
define void @main1([17 x <16 x i8>] addrspace(2)* byval, [32 x <16 x i8>] addrspace(2)* byval, [16 x <32 x i8>] addrspace(2)* byval, float inreg, i32 inreg, <2 x i32>, <2 x i32>, <2 x i32>, <3 x i32>, <2 x i32>, <2 x i32>, <2 x i32>, float, float, float, float, float, float, float, float, float) #1 {
main_body:
  %21 = getelementptr [17 x <16 x i8>], [17 x <16 x i8>] addrspace(2)* %0, i64 0, i32 0
  %22 = load <16 x i8>, <16 x i8> addrspace(2)* %21, !tbaa !0
  %23 = call float @llvm.SI.load.const(<16 x i8> %22, i32 0)
  %24 = call float @llvm.SI.load.const(<16 x i8> %22, i32 4)
  %25 = call float @llvm.SI.load.const(<16 x i8> %22, i32 8)
  %26 = call float @llvm.SI.load.const(<16 x i8> %22, i32 12)
  %27 = call float @llvm.SI.load.const(<16 x i8> %22, i32 28)
  %28 = call float @llvm.SI.load.const(<16 x i8> %22, i32 48)
  %29 = call float @llvm.SI.load.const(<16 x i8> %22, i32 52)
  %30 = call float @llvm.SI.load.const(<16 x i8> %22, i32 56)
  %31 = call float @llvm.SI.load.const(<16 x i8> %22, i32 64)
  %32 = call float @llvm.SI.load.const(<16 x i8> %22, i32 68)
  %33 = call float @llvm.SI.load.const(<16 x i8> %22, i32 72)
  %34 = call float @llvm.SI.load.const(<16 x i8> %22, i32 76)
  %35 = call float @llvm.SI.load.const(<16 x i8> %22, i32 128)
  %36 = call float @llvm.SI.load.const(<16 x i8> %22, i32 132)
  %37 = call float @llvm.SI.load.const(<16 x i8> %22, i32 144)
  %38 = call float @llvm.SI.load.const(<16 x i8> %22, i32 148)
  %39 = call float @llvm.SI.load.const(<16 x i8> %22, i32 152)
  %40 = call float @llvm.SI.load.const(<16 x i8> %22, i32 160)
  %41 = call float @llvm.SI.load.const(<16 x i8> %22, i32 164)
  %42 = call float @llvm.SI.load.const(<16 x i8> %22, i32 168)
  %43 = call float @llvm.SI.load.const(<16 x i8> %22, i32 172)
  %44 = call float @llvm.SI.load.const(<16 x i8> %22, i32 176)
  %45 = call float @llvm.SI.load.const(<16 x i8> %22, i32 180)
  %46 = call float @llvm.SI.load.const(<16 x i8> %22, i32 184)
  %47 = call float @llvm.SI.load.const(<16 x i8> %22, i32 192)
  %48 = call float @llvm.SI.load.const(<16 x i8> %22, i32 196)
  %49 = call float @llvm.SI.load.const(<16 x i8> %22, i32 200)
  %50 = call float @llvm.SI.load.const(<16 x i8> %22, i32 208)
  %51 = call float @llvm.SI.load.const(<16 x i8> %22, i32 212)
  %52 = call float @llvm.SI.load.const(<16 x i8> %22, i32 216)
  %53 = call float @llvm.SI.load.const(<16 x i8> %22, i32 220)
  %54 = call float @llvm.SI.load.const(<16 x i8> %22, i32 236)
  %55 = call float @llvm.SI.load.const(<16 x i8> %22, i32 240)
  %56 = call float @llvm.SI.load.const(<16 x i8> %22, i32 244)
  %57 = call float @llvm.SI.load.const(<16 x i8> %22, i32 248)
  %58 = call float @llvm.SI.load.const(<16 x i8> %22, i32 252)
  %59 = call float @llvm.SI.load.const(<16 x i8> %22, i32 256)
  %60 = call float @llvm.SI.load.const(<16 x i8> %22, i32 260)
  %61 = call float @llvm.SI.load.const(<16 x i8> %22, i32 264)
  %62 = call float @llvm.SI.load.const(<16 x i8> %22, i32 268)
  %63 = call float @llvm.SI.load.const(<16 x i8> %22, i32 272)
  %64 = call float @llvm.SI.load.const(<16 x i8> %22, i32 276)
  %65 = call float @llvm.SI.load.const(<16 x i8> %22, i32 280)
  %66 = call float @llvm.SI.load.const(<16 x i8> %22, i32 284)
  %67 = call float @llvm.SI.load.const(<16 x i8> %22, i32 288)
  %68 = call float @llvm.SI.load.const(<16 x i8> %22, i32 292)
  %69 = call float @llvm.SI.load.const(<16 x i8> %22, i32 464)
  %70 = call float @llvm.SI.load.const(<16 x i8> %22, i32 468)
  %71 = call float @llvm.SI.load.const(<16 x i8> %22, i32 472)
  %72 = call float @llvm.SI.load.const(<16 x i8> %22, i32 496)
  %73 = call float @llvm.SI.load.const(<16 x i8> %22, i32 500)
  %74 = call float @llvm.SI.load.const(<16 x i8> %22, i32 504)
  %75 = call float @llvm.SI.load.const(<16 x i8> %22, i32 512)
  %76 = call float @llvm.SI.load.const(<16 x i8> %22, i32 516)
  %77 = call float @llvm.SI.load.const(<16 x i8> %22, i32 524)
  %78 = call float @llvm.SI.load.const(<16 x i8> %22, i32 532)
  %79 = call float @llvm.SI.load.const(<16 x i8> %22, i32 536)
  %80 = call float @llvm.SI.load.const(<16 x i8> %22, i32 540)
  %81 = call float @llvm.SI.load.const(<16 x i8> %22, i32 544)
  %82 = call float @llvm.SI.load.const(<16 x i8> %22, i32 548)
  %83 = call float @llvm.SI.load.const(<16 x i8> %22, i32 552)
  %84 = call float @llvm.SI.load.const(<16 x i8> %22, i32 556)
  %85 = call float @llvm.SI.load.const(<16 x i8> %22, i32 560)
  %86 = call float @llvm.SI.load.const(<16 x i8> %22, i32 564)
  %87 = call float @llvm.SI.load.const(<16 x i8> %22, i32 568)
  %88 = call float @llvm.SI.load.const(<16 x i8> %22, i32 572)
  %89 = call float @llvm.SI.load.const(<16 x i8> %22, i32 576)
  %90 = call float @llvm.SI.load.const(<16 x i8> %22, i32 580)
  %91 = call float @llvm.SI.load.const(<16 x i8> %22, i32 584)
  %92 = call float @llvm.SI.load.const(<16 x i8> %22, i32 588)
  %93 = call float @llvm.SI.load.const(<16 x i8> %22, i32 592)
  %94 = call float @llvm.SI.load.const(<16 x i8> %22, i32 596)
  %95 = call float @llvm.SI.load.const(<16 x i8> %22, i32 600)
  %96 = call float @llvm.SI.load.const(<16 x i8> %22, i32 604)
  %97 = call float @llvm.SI.load.const(<16 x i8> %22, i32 608)
  %98 = call float @llvm.SI.load.const(<16 x i8> %22, i32 612)
  %99 = call float @llvm.SI.load.const(<16 x i8> %22, i32 616)
  %100 = call float @llvm.SI.load.const(<16 x i8> %22, i32 624)
  %101 = call float @llvm.SI.load.const(<16 x i8> %22, i32 628)
  %102 = call float @llvm.SI.load.const(<16 x i8> %22, i32 632)
  %103 = call float @llvm.SI.load.const(<16 x i8> %22, i32 636)
  %104 = call float @llvm.SI.load.const(<16 x i8> %22, i32 640)
  %105 = call float @llvm.SI.load.const(<16 x i8> %22, i32 644)
  %106 = call float @llvm.SI.load.const(<16 x i8> %22, i32 648)
  %107 = call float @llvm.SI.load.const(<16 x i8> %22, i32 652)
  %108 = call float @llvm.SI.load.const(<16 x i8> %22, i32 656)
  %109 = call float @llvm.SI.load.const(<16 x i8> %22, i32 660)
  %110 = call float @llvm.SI.load.const(<16 x i8> %22, i32 664)
  %111 = call float @llvm.SI.load.const(<16 x i8> %22, i32 668)
  %112 = call float @llvm.SI.load.const(<16 x i8> %22, i32 672)
  %113 = call float @llvm.SI.load.const(<16 x i8> %22, i32 676)
  %114 = call float @llvm.SI.load.const(<16 x i8> %22, i32 680)
  %115 = call float @llvm.SI.load.const(<16 x i8> %22, i32 684)
  %116 = call float @llvm.SI.load.const(<16 x i8> %22, i32 688)
  %117 = call float @llvm.SI.load.const(<16 x i8> %22, i32 692)
  %118 = call float @llvm.SI.load.const(<16 x i8> %22, i32 696)
  %119 = call float @llvm.SI.load.const(<16 x i8> %22, i32 700)
  %120 = call float @llvm.SI.load.const(<16 x i8> %22, i32 704)
  %121 = call float @llvm.SI.load.const(<16 x i8> %22, i32 708)
  %122 = call float @llvm.SI.load.const(<16 x i8> %22, i32 712)
  %123 = call float @llvm.SI.load.const(<16 x i8> %22, i32 716)
  %124 = call float @llvm.SI.load.const(<16 x i8> %22, i32 864)
  %125 = call float @llvm.SI.load.const(<16 x i8> %22, i32 868)
  %126 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 0
  %127 = load <32 x i8>, <32 x i8> addrspace(2)* %126, !tbaa !0
  %128 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 0
  %129 = load <16 x i8>, <16 x i8> addrspace(2)* %128, !tbaa !0
  %130 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 1
  %131 = load <32 x i8>, <32 x i8> addrspace(2)* %130, !tbaa !0
  %132 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 1
  %133 = load <16 x i8>, <16 x i8> addrspace(2)* %132, !tbaa !0
  %134 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 2
  %135 = load <32 x i8>, <32 x i8> addrspace(2)* %134, !tbaa !0
  %136 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 2
  %137 = load <16 x i8>, <16 x i8> addrspace(2)* %136, !tbaa !0
  %138 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 3
  %139 = load <32 x i8>, <32 x i8> addrspace(2)* %138, !tbaa !0
  %140 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 3
  %141 = load <16 x i8>, <16 x i8> addrspace(2)* %140, !tbaa !0
  %142 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 4
  %143 = load <32 x i8>, <32 x i8> addrspace(2)* %142, !tbaa !0
  %144 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 4
  %145 = load <16 x i8>, <16 x i8> addrspace(2)* %144, !tbaa !0
  %146 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 5
  %147 = load <32 x i8>, <32 x i8> addrspace(2)* %146, !tbaa !0
  %148 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 5
  %149 = load <16 x i8>, <16 x i8> addrspace(2)* %148, !tbaa !0
  %150 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 6
  %151 = load <32 x i8>, <32 x i8> addrspace(2)* %150, !tbaa !0
  %152 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 6
  %153 = load <16 x i8>, <16 x i8> addrspace(2)* %152, !tbaa !0
  %154 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 7
  %155 = load <32 x i8>, <32 x i8> addrspace(2)* %154, !tbaa !0
  %156 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 7
  %157 = load <16 x i8>, <16 x i8> addrspace(2)* %156, !tbaa !0
  %158 = getelementptr [16 x <32 x i8>], [16 x <32 x i8>] addrspace(2)* %2, i64 0, i32 8
  %159 = load <32 x i8>, <32 x i8> addrspace(2)* %158, !tbaa !0
  %160 = getelementptr [32 x <16 x i8>], [32 x <16 x i8>] addrspace(2)* %1, i64 0, i32 8
  %161 = load <16 x i8>, <16 x i8> addrspace(2)* %160, !tbaa !0
  %162 = fcmp ugt float %17, 0.000000e+00
  %163 = select i1 %162, float 1.000000e+00, float 0.000000e+00
  %164 = call float @llvm.SI.fs.interp(i32 0, i32 0, i32 %4, <2 x i32> %6)
  %165 = call float @llvm.SI.fs.interp(i32 1, i32 0, i32 %4, <2 x i32> %6)
  %166 = call float @llvm.SI.fs.interp(i32 2, i32 0, i32 %4, <2 x i32> %6)
  %167 = call float @llvm.SI.fs.interp(i32 3, i32 0, i32 %4, <2 x i32> %6)
  %168 = call float @llvm.SI.fs.interp(i32 0, i32 1, i32 %4, <2 x i32> %6)
  %169 = call float @llvm.SI.fs.interp(i32 1, i32 1, i32 %4, <2 x i32> %6)
  %170 = call float @llvm.SI.fs.interp(i32 2, i32 1, i32 %4, <2 x i32> %6)
  %171 = call float @llvm.SI.fs.interp(i32 3, i32 1, i32 %4, <2 x i32> %6)
  %172 = call float @llvm.SI.fs.interp(i32 0, i32 2, i32 %4, <2 x i32> %6)
  %173 = call float @llvm.SI.fs.interp(i32 1, i32 2, i32 %4, <2 x i32> %6)
  %174 = call float @llvm.SI.fs.interp(i32 2, i32 2, i32 %4, <2 x i32> %6)
  %175 = call float @llvm.SI.fs.interp(i32 3, i32 2, i32 %4, <2 x i32> %6)
  %176 = call float @llvm.SI.fs.interp(i32 0, i32 3, i32 %4, <2 x i32> %6)
  %177 = call float @llvm.SI.fs.interp(i32 1, i32 3, i32 %4, <2 x i32> %6)
  %178 = call float @llvm.SI.fs.interp(i32 2, i32 3, i32 %4, <2 x i32> %6)
  %179 = call float @llvm.SI.fs.interp(i32 3, i32 3, i32 %4, <2 x i32> %6)
  %180 = call float @llvm.SI.fs.interp(i32 0, i32 4, i32 %4, <2 x i32> %6)
  %181 = call float @llvm.SI.fs.interp(i32 1, i32 4, i32 %4, <2 x i32> %6)
  %182 = call float @llvm.SI.fs.interp(i32 2, i32 4, i32 %4, <2 x i32> %6)
  %183 = call float @llvm.SI.fs.interp(i32 3, i32 4, i32 %4, <2 x i32> %6)
  %184 = call float @llvm.SI.fs.interp(i32 0, i32 5, i32 %4, <2 x i32> %6)
  %185 = call float @llvm.SI.fs.interp(i32 1, i32 5, i32 %4, <2 x i32> %6)
  %186 = call float @llvm.SI.fs.interp(i32 2, i32 5, i32 %4, <2 x i32> %6)
  %187 = call float @llvm.SI.fs.interp(i32 3, i32 5, i32 %4, <2 x i32> %6)
  %188 = call float @llvm.SI.fs.interp(i32 0, i32 6, i32 %4, <2 x i32> %6)
  %189 = call float @llvm.SI.fs.interp(i32 1, i32 6, i32 %4, <2 x i32> %6)
  %190 = call float @llvm.SI.fs.interp(i32 2, i32 6, i32 %4, <2 x i32> %6)
  %191 = call float @llvm.SI.fs.interp(i32 3, i32 6, i32 %4, <2 x i32> %6)
  %192 = call float @llvm.SI.fs.interp(i32 0, i32 7, i32 %4, <2 x i32> %6)
  %193 = call float @llvm.SI.fs.interp(i32 1, i32 7, i32 %4, <2 x i32> %6)
  %194 = call float @llvm.SI.fs.interp(i32 2, i32 7, i32 %4, <2 x i32> %6)
  %195 = call float @llvm.SI.fs.interp(i32 3, i32 7, i32 %4, <2 x i32> %6)
  %196 = fmul float %14, %124
  %197 = fadd float %196, %125
  %198 = call float @llvm.AMDIL.clamp.(float %163, float 0.000000e+00, float 1.000000e+00)
  %199 = call float @llvm.AMDIL.clamp.(float 0.000000e+00, float 0.000000e+00, float 1.000000e+00)
  %200 = call float @llvm.AMDIL.clamp.(float 0.000000e+00, float 0.000000e+00, float 1.000000e+00)
  %201 = call float @llvm.AMDIL.clamp.(float 1.000000e+00, float 0.000000e+00, float 1.000000e+00)
  %202 = bitcast float %198 to i32
  %203 = icmp ne i32 %202, 0
  %. = select i1 %203, float -1.000000e+00, float 1.000000e+00
  %204 = fsub float -0.000000e+00, %164
  %205 = fadd float %44, %204
  %206 = fsub float -0.000000e+00, %165
  %207 = fadd float %45, %206
  %208 = fsub float -0.000000e+00, %166
  %209 = fadd float %46, %208
  %210 = fmul float %205, %205
  %211 = fmul float %207, %207
  %212 = fadd float %211, %210
  %213 = fmul float %209, %209
  %214 = fadd float %212, %213
  %215 = call float @llvm.amdgcn.rsq.f32(float %214)
  %216 = fmul float %205, %215
  %217 = fmul float %207, %215
  %218 = fmul float %209, %215
  %219 = fmul float %., %54
  %220 = fmul float %13, %47
  %221 = fmul float %197, %48
  %222 = bitcast float %174 to i32
  %223 = bitcast float %175 to i32
  %224 = insertelement <2 x i32> undef, i32 %222, i32 0
  %225 = insertelement <2 x i32> %224, i32 %223, i32 1
  %226 = call <4 x float> @llvm.SI.sample.v2i32(<2 x i32> %225, <32 x i8> %131, <16 x i8> %133, i32 2)
  %227 = extractelement <4 x float> %226, i32 0
  %228 = extractelement <4 x float> %226, i32 1
  %229 = extractelement <4 x float> %226, i32 2
  %230 = extractelement <4 x float> %226, i32 3
  %231 = fmul float %227, 0x4012611180000000
  %232 = fmul float %228, 0x4012611180000000
  %233 = fmul float %229, 0x4012611180000000
  %one.sub.a.i = fsub float 1.000000e+00, %27
  %result.i = fadd float %231, %one.sub.a.i
  %one.sub.a.i43 = fsub float 1.000000e+00, %27
  %result.i44 = fadd float %232, %one.sub.a.i43
  %one.sub.a.i41 = fsub float 1.000000e+00, %27
  %result.i42 = fadd float %233, %one.sub.a.i41
  %234 = fmul float %216, %184
  %235 = fmul float %217, %185
  %236 = fadd float %235, %234
  %237 = fmul float %218, %186
  %238 = fadd float %236, %237
  %239 = fmul float %216, %187
  %240 = fmul float %217, %188
  %241 = fadd float %240, %239
  %242 = fmul float %218, %189
  %243 = fadd float %241, %242
  %244 = fmul float %216, %190
  %245 = fmul float %217, %191
  %246 = fadd float %245, %244
  %247 = fmul float %218, %192
  %248 = fadd float %246, %247
  %249 = call float @llvm.AMDIL.clamp.(float %248, float 0.000000e+00, float 1.000000e+00)
  %250 = fmul float %214, 0x3F5A36E2E0000000
  %251 = call float @llvm.AMDIL.clamp.(float %250, float 0.000000e+00, float 1.000000e+00)
  %252 = fsub float -0.000000e+00, %251
  %253 = fadd float 1.000000e+00, %252
  %254 = call float @llvm.pow.f32(float %249, float 2.500000e-01)
  %255 = fmul float %39, %254
  %256 = fmul float %238, %255
  %257 = fmul float %243, %255
  %258 = fmul float %256, %230
  %259 = fmul float %257, %230
  %260 = fadd float %249, 0x3EE4F8B580000000
  %261 = fsub float -0.000000e+00, %249
  %262 = fadd float 1.000000e+00, %261
  %263 = fmul float 1.200000e+01, %262
  %264 = fadd float %263, 4.000000e+00
  %265 = fsub float -0.000000e+00, %264
  %266 = fmul float %265, %260
  %267 = fsub float -0.000000e+00, %264
  %268 = fmul float %267, %260
  %269 = fsub float -0.000000e+00, %264
  %270 = fmul float %269, %260
  %271 = fdiv float 1.000000e+00, %266
  %272 = fdiv float 1.000000e+00, %268
  %273 = fdiv float 1.000000e+00, %270
  %274 = fmul float %258, %271
  %275 = fmul float %259, %272
  %276 = fmul float %260, %273
  br label %LOOP

LOOP:                                             ; preds = %LOOP, %main_body
  %temp144.0 = phi float [ 1.000000e+00, %main_body ], [ %289, %LOOP ]
  %temp168.0 = phi float [ %176, %main_body ], [ %285, %LOOP ]
  %temp169.0 = phi float [ %177, %main_body ], [ %286, %LOOP ]
  %temp170.0 = phi float [ %253, %main_body ], [ %287, %LOOP ]
  %277 = bitcast float %temp168.0 to i32
  %278 = bitcast float %temp169.0 to i32
  %279 = insertelement <4 x i32> undef, i32 %277, i32 0
  %280 = insertelement <4 x i32> %279, i32 %278, i32 1
  %281 = insertelement <4 x i32> %280, i32 0, i32 2
  %282 = insertelement <4 x i32> %281, i32 undef, i32 3
  %283 = call <4 x float> @llvm.SI.samplel.v4i32(<4 x i32> %282, <32 x i8> %147, <16 x i8> %149, i32 2)
  %284 = extractelement <4 x float> %283, i32 3
  %285 = fadd float %temp168.0, %274
  %286 = fadd float %temp169.0, %275
  %287 = fadd float %temp170.0, %276
  %288 = fsub float -0.000000e+00, %284
  %289 = fadd float %287, %288
  %290 = fcmp oge float 0.000000e+00, %289
  %291 = sext i1 %290 to i32
  %292 = bitcast i32 %291 to float
  %293 = bitcast float %292 to i32
  %294 = icmp ne i32 %293, 0
  br i1 %294, label %IF189, label %LOOP

IF189:                                            ; preds = %LOOP
  %295 = extractelement <4 x float> %283, i32 0
  %296 = extractelement <4 x float> %283, i32 1
  %297 = extractelement <4 x float> %283, i32 2
  %298 = fsub float -0.000000e+00, %289
  %299 = fadd float %temp144.0, %298
  %300 = fdiv float 1.000000e+00, %299
  %301 = fmul float %289, %300
  %302 = fadd float %301, -1.000000e+00
  %303 = fmul float %302, %274
  %304 = fadd float %303, %285
  %305 = fmul float %302, %275
  %306 = fadd float %305, %286
  %307 = fsub float -0.000000e+00, %176
  %308 = fadd float %304, %307
  %309 = fsub float -0.000000e+00, %177
  %310 = fadd float %306, %309
  %311 = fadd float %176, %308
  %312 = fadd float %177, %310
  %313 = fmul float %308, %67
  %314 = fmul float %310, %68
  %315 = fmul float %313, %55
  %316 = fmul float %313, %56
  %317 = fmul float %314, %57
  %318 = fadd float %317, %315
  %319 = fmul float %314, %58
  %320 = fadd float %319, %316
  %321 = fadd float %178, %318
  %322 = fadd float %179, %320
  %323 = fmul float %313, %59
  %324 = fmul float %313, %60
  %325 = fmul float %313, %61
  %326 = fmul float %313, %62
  %327 = fmul float %314, %63
  %328 = fadd float %327, %323
  %329 = fmul float %314, %64
  %330 = fadd float %329, %324
  %331 = fmul float %314, %65
  %332 = fadd float %331, %325
  %333 = fmul float %314, %66
  %334 = fadd float %333, %326
  %335 = fadd float %168, %328
  %336 = fadd float %169, %330
  %337 = fadd float %170, %332
  %338 = fadd float %171, %334
  %339 = bitcast float %335 to i32
  %340 = bitcast float %336 to i32
  %341 = insertelement <2 x i32> undef, i32 %339, i32 0
  %342 = insertelement <2 x i32> %341, i32 %340, i32 1
  %343 = call <4 x float> @llvm.SI.sample.v2i32(<2 x i32> %342, <32 x i8> %135, <16 x i8> %137, i32 2)
  %344 = extractelement <4 x float> %343, i32 0
  %345 = extractelement <4 x float> %343, i32 1
  %346 = extractelement <4 x float> %343, i32 2
  %347 = extractelement <4 x float> %343, i32 3
  %348 = fmul float %344, %23
  %349 = fmul float %345, %24
  %350 = fmul float %346, %25
  %351 = fmul float %347, %26
  %352 = fmul float %348, %180
  %353 = fmul float %349, %181
  %354 = fmul float %350, %182
  %355 = fmul float %351, %183
  %356 = fsub float -0.000000e+00, %347
  %357 = fadd float 1.000000e+00, %356
  %358 = fmul float %357, %49
  %one.sub.a.i37 = fsub float 1.000000e+00, %358
  %one.sub.ac.i38 = fmul float %one.sub.a.i37, %352
  %mul.i39 = fmul float %344, %352
  %result.i40 = fadd float %mul.i39, %one.sub.ac.i38
  %one.sub.a.i33 = fsub float 1.000000e+00, %358
  %one.sub.ac.i34 = fmul float %one.sub.a.i33, %353
  %mul.i35 = fmul float %345, %353
  %result.i36 = fadd float %mul.i35, %one.sub.ac.i34
  %one.sub.a.i29 = fsub float 1.000000e+00, %358
  %one.sub.ac.i30 = fmul float %one.sub.a.i29, %354
  %mul.i31 = fmul float %346, %354
  %result.i32 = fadd float %mul.i31, %one.sub.ac.i30
  %359 = bitcast float %337 to i32
  %360 = bitcast float %338 to i32
  %361 = insertelement <2 x i32> undef, i32 %359, i32 0
  %362 = insertelement <2 x i32> %361, i32 %360, i32 1
  %363 = call <4 x float> @llvm.SI.sample.v2i32(<2 x i32> %362, <32 x i8> %151, <16 x i8> %153, i32 2)
  %364 = extractelement <4 x float> %363, i32 2
  %365 = fmul float %result.i40, %result.i
  %366 = fmul float %result.i36, %result.i44
  %367 = fmul float %result.i32, %result.i42
  %368 = fmul float %355, %230
  %369 = bitcast float %311 to i32
  %370 = bitcast float %312 to i32
  %371 = insertelement <2 x i32> undef, i32 %369, i32 0
  %372 = insertelement <2 x i32> %371, i32 %370, i32 1
  %373 = call <4 x float> @llvm.SI.sample.v2i32(<2 x i32> %372, <32 x i8> %139, <16 x i8> %141, i32 2)
  %374 = extractelement <4 x float> %373, i32 0
  %375 = extractelement <4 x float> %373, i32 1
  %376 = extractelement <4 x float> %373, i32 2
  %377 = extractelement <4 x float> %373, i32 3
  %378 = fcmp olt float 0.000000e+00, %376
  %379 = sext i1 %378 to i32
  %380 = bitcast i32 %379 to float
  %381 = bitcast float %380 to i32
  %382 = icmp ne i32 %381, 0
  %.224 = select i1 %382, float %375, float %374
  %.225 = select i1 %382, float %377, float %375
  %383 = bitcast float %321 to i32
  %384 = bitcast float %322 to i32
  %385 = insertelement <2 x i32> undef, i32 %383, i32 0
  %386 = insertelement <2 x i32> %385, i32 %384, i32 1
  %387 = call <4 x float> @llvm.SI.sample.v2i32(<2 x i32> %386, <32 x i8> %143, <16 x i8> %145, i32 2)
  %388 = extractelement <4 x float> %387, i32 0
  %389 = extractelement <4 x float> %387, i32 1
  %390 = extractelement <4 x float> %387, i32 2
  %391 = extractelement <4 x float> %387, i32 3
  %392 = fcmp olt float 0.000000e+00, %390
  %393 = sext i1 %392 to i32
  %394 = bitcast i32 %393 to float
  %395 = bitcast float %394 to i32
  %396 = icmp ne i32 %395, 0
  %temp112.1 = select i1 %396, float %389, float %388
  %temp113.1 = select i1 %396, float %391, float %389
  %397 = fmul float %.224, 2.000000e+00
  %398 = fadd float %397, -1.000000e+00
  %399 = fmul float %.225, 2.000000e+00
  %400 = fadd float %399, -1.000000e+00
  %401 = fmul float %temp112.1, 2.000000e+00
  %402 = fadd float %401, -1.000000e+00
  %403 = fmul float %temp113.1, 2.000000e+00
  %404 = fadd float %403, -1.000000e+00
  %405 = fsub float -0.000000e+00, %398
  %406 = fmul float %405, %35
  %407 = fsub float -0.000000e+00, %400
  %408 = fmul float %407, %35
  %409 = fsub float -0.000000e+00, %402
  %410 = fmul float %409, %36
  %411 = fsub float -0.000000e+00, %404
  %412 = fmul float %411, %36
  %413 = fmul float %410, %364
  %414 = fmul float %412, %364
  %415 = call float @fabs(float %406)
  %416 = call float @fabs(float %408)
  %417 = fsub float -0.000000e+00, %415
  %418 = fadd float 1.000000e+00, %417
  %419 = fsub float -0.000000e+00, %416
  %420 = fadd float 1.000000e+00, %419
  %421 = fmul float %418, %413
  %422 = fadd float %421, %406
  %423 = fmul float %420, %414
  %424 = fadd float %423, %408
  %425 = fmul float %422, %422
  %426 = fmul float %424, %424
  %427 = fadd float %425, %426
  %428 = fsub float -0.000000e+00, %427
  %429 = fadd float 0x3FF00068E0000000, %428
  %430 = call float @llvm.AMDIL.clamp.(float %429, float 0.000000e+00, float 1.000000e+00)
  %431 = call float @llvm.amdgcn.rsq.f32(float %430)
  %432 = fmul float %431, %430
  %433 = fsub float -0.000000e+00, %430
  %cmp = fcmp ogt float 0.000000e+00, %433
  %434 = select i1 %cmp, float %432, float 0.000000e+00
  %435 = fmul float %184, %422
  %436 = fmul float %185, %422
  %437 = fmul float %186, %422
  %438 = fmul float %187, %424
  %439 = fadd float %438, %435
  %440 = fmul float %188, %424
  %441 = fadd float %440, %436
  %442 = fmul float %189, %424
  %443 = fadd float %442, %437
  %444 = fmul float %190, %434
  %445 = fadd float %444, %439
  %446 = fmul float %191, %434
  %447 = fadd float %446, %441
  %448 = fmul float %192, %434
  %449 = fadd float %448, %443
  %450 = fmul float %445, %445
  %451 = fmul float %447, %447
  %452 = fadd float %451, %450
  %453 = fmul float %449, %449
  %454 = fadd float %452, %453
  %455 = call float @llvm.amdgcn.rsq.f32(float %454)
  %456 = fmul float %445, %455
  %457 = fmul float %447, %455
  %458 = fmul float %449, %455
  %459 = fcmp olt float 0.000000e+00, %219
  %460 = sext i1 %459 to i32
  %461 = bitcast i32 %460 to float
  %462 = bitcast float %461 to i32
  %463 = icmp ne i32 %462, 0
  br i1 %463, label %IF198, label %ENDIF197

IF198:                                            ; preds = %IF189
  %464 = fsub float -0.000000e+00, %456
  %465 = fsub float -0.000000e+00, %457
  %466 = fsub float -0.000000e+00, %458
  br label %ENDIF197

ENDIF197:                                         ; preds = %IF198, %IF189
  %temp14.0 = phi float [ %466, %IF198 ], [ %458, %IF189 ]
  %temp13.0 = phi float [ %465, %IF198 ], [ %457, %IF189 ]
  %temp12.0 = phi float [ %464, %IF198 ], [ %456, %IF189 ]
  %467 = bitcast float %220 to i32
  %468 = bitcast float %221 to i32
  %469 = insertelement <2 x i32> undef, i32 %467, i32 0
  %470 = insertelement <2 x i32> %469, i32 %468, i32 1
  %471 = call <4 x float> @llvm.SI.sample.v2i32(<2 x i32> %470, <32 x i8> %159, <16 x i8> %161, i32 2)
  %472 = extractelement <4 x float> %471, i32 0
  %473 = extractelement <4 x float> %471, i32 1
  %474 = extractelement <4 x float> %471, i32 2
  %475 = extractelement <4 x float> %471, i32 3
  %476 = fmul float %472, %40
  %477 = fadd float %476, %41
  %478 = fmul float %473, %40
  %479 = fadd float %478, %41
  %480 = fmul float %474, %40
  %481 = fadd float %480, %41
  %482 = fmul float %475, %42
  %483 = fadd float %482, %43
  %484 = bitcast float %172 to i32
  %485 = bitcast float %173 to i32
  %486 = insertelement <2 x i32> undef, i32 %484, i32 0
  %487 = insertelement <2 x i32> %486, i32 %485, i32 1
  %488 = call <4 x float> @llvm.SI.sample.v2i32(<2 x i32> %487, <32 x i8> %155, <16 x i8> %157, i32 2)
  %489 = extractelement <4 x float> %488, i32 0
  %490 = extractelement <4 x float> %488, i32 1
  %491 = extractelement <4 x float> %488, i32 2
  %492 = extractelement <4 x float> %488, i32 3
  %493 = fmul float %492, 3.200000e+01
  %494 = fadd float %493, -1.600000e+01
  %495 = call float @llvm.AMDIL.exp.(float %494)
  %496 = fmul float %489, %495
  %497 = fmul float %490, %495
  %498 = fmul float %491, %495
  %499 = fmul float %28, %496
  %500 = fadd float %499, %193
  %501 = fmul float %29, %497
  %502 = fadd float %501, %194
  %503 = fmul float %30, %498
  %504 = fadd float %503, %195
  %505 = fmul float %500, %483
  %506 = fmul float %502, %483
  %507 = fmul float %504, %483
  %508 = fmul float %483, 5.000000e-01
  %509 = fadd float %508, 5.000000e-01
  %510 = fmul float %477, %509
  %511 = fadd float %510, %505
  %512 = fmul float %479, %509
  %513 = fadd float %512, %506
  %514 = fmul float %481, %509
  %515 = fadd float %514, %507
  %516 = fmul float %511, %365
  %517 = fmul float %513, %366
  %518 = fmul float %515, %367
  %519 = fmul float %422, 0x3FDB272440000000
  %520 = fmul float %424, 0xBFDB272440000000
  %521 = fadd float %520, %519
  %522 = fmul float %434, 0x3FE99999A0000000
  %523 = fadd float %521, %522
  %524 = fmul float %523, 5.000000e-01
  %525 = fadd float %524, 0x3FE3333340000000
  %526 = fmul float %525, %525
  %527 = fmul float %516, %526
  %528 = fmul float %517, %526
  %529 = fmul float %518, %526
  %530 = fsub float -0.000000e+00, %72
  %531 = fsub float -0.000000e+00, %73
  %532 = fsub float -0.000000e+00, %74
  %533 = fmul float %temp12.0, %530
  %534 = fmul float %temp13.0, %531
  %535 = fadd float %534, %533
  %536 = fmul float %temp14.0, %532
  %537 = fadd float %535, %536
  %538 = call float @llvm.AMDIL.clamp.(float %537, float 0.000000e+00, float 1.000000e+00)
  %539 = fmul float %365, %538
  %540 = fmul float %366, %538
  %541 = fmul float %367, %538
  %542 = fmul float %539, %69
  %543 = fmul float %540, %70
  %544 = fmul float %541, %71
  %545 = fsub float -0.000000e+00, %164
  %546 = fadd float %97, %545
  %547 = fsub float -0.000000e+00, %165
  %548 = fadd float %98, %547
  %549 = fsub float -0.000000e+00, %166
  %550 = fadd float %99, %549
  %551 = fmul float %546, %546
  %552 = fmul float %548, %548
  %553 = fadd float %552, %551
  %554 = fmul float %550, %550
  %555 = fadd float %553, %554
  %556 = call float @llvm.amdgcn.rsq.f32(float %555)
  %557 = fmul float %556, %555
  %558 = fsub float -0.000000e+00, %555
  %cmp1 = fcmp ogt float %558, 0.000000e+00
  %559 = select i1 %cmp1, float %557, float 0.000000e+00
  %560 = fsub float -0.000000e+00, %84
  %561 = fadd float %559, %560
  %562 = fsub float -0.000000e+00, %83
  %563 = fadd float %559, %562
  %564 = fsub float -0.000000e+00, %82
  %565 = fadd float %559, %564
  %566 = fsub float -0.000000e+00, %84
  %567 = fadd float %83, %566
  %568 = fsub float -0.000000e+00, %83
  %569 = fadd float %82, %568
  %570 = fsub float -0.000000e+00, %82
  %571 = fadd float %81, %570
  %572 = fdiv float 1.000000e+00, %567
  %573 = fdiv float 1.000000e+00, %569
  %574 = fdiv float 1.000000e+00, %571
  %575 = fmul float %561, %572
  %576 = fmul float %563, %573
  %577 = fmul float %565, %574
  %578 = fcmp olt float %559, %83
  %579 = sext i1 %578 to i32
  %580 = bitcast i32 %579 to float
  %581 = bitcast float %580 to i32
  %582 = icmp ne i32 %581, 0
  br i1 %582, label %ENDIF200, label %ELSE202

ELSE202:                                          ; preds = %ENDIF197
  %583 = fcmp olt float %559, %82
  %584 = sext i1 %583 to i32
  %585 = bitcast i32 %584 to float
  %586 = bitcast float %585 to i32
  %587 = icmp ne i32 %586, 0
  br i1 %587, label %ENDIF200, label %ELSE205

ENDIF200:                                         ; preds = %ELSE205, %ELSE202, %ENDIF197
  %temp80.0 = phi float [ %575, %ENDIF197 ], [ %.226, %ELSE205 ], [ %576, %ELSE202 ]
  %temp88.0 = phi float [ %122, %ENDIF197 ], [ %.227, %ELSE205 ], [ %120, %ELSE202 ]
  %temp89.0 = phi float [ %123, %ENDIF197 ], [ %.228, %ELSE205 ], [ %121, %ELSE202 ]
  %temp90.0 = phi float [ %120, %ENDIF197 ], [ %116, %ELSE205 ], [ %118, %ELSE202 ]
  %temp91.0 = phi float [ %121, %ENDIF197 ], [ %117, %ELSE205 ], [ %119, %ELSE202 ]
  %588 = fcmp olt float %559, %83
  %589 = sext i1 %588 to i32
  %590 = bitcast i32 %589 to float
  %591 = bitcast float %590 to i32
  %592 = icmp ne i32 %591, 0
  br i1 %592, label %ENDIF209, label %ELSE211

ELSE205:                                          ; preds = %ELSE202
  %593 = fcmp olt float %559, %81
  %594 = sext i1 %593 to i32
  %595 = bitcast i32 %594 to float
  %596 = bitcast float %595 to i32
  %597 = icmp ne i32 %596, 0
  %.226 = select i1 %597, float %577, float 1.000000e+00
  %.227 = select i1 %597, float %118, float %116
  %.228 = select i1 %597, float %119, float %117
  br label %ENDIF200

ELSE211:                                          ; preds = %ENDIF200
  %598 = fcmp olt float %559, %82
  %599 = sext i1 %598 to i32
  %600 = bitcast i32 %599 to float
  %601 = bitcast float %600 to i32
  %602 = icmp ne i32 %601, 0
  br i1 %602, label %ENDIF209, label %ELSE214

ENDIF209:                                         ; preds = %ELSE214, %ELSE211, %ENDIF200
  %temp52.0 = phi float [ %108, %ENDIF200 ], [ %100, %ELSE214 ], [ %104, %ELSE211 ]
  %temp53.0 = phi float [ %109, %ENDIF200 ], [ %101, %ELSE214 ], [ %105, %ELSE211 ]
  %temp54.0 = phi float [ %110, %ENDIF200 ], [ %102, %ELSE214 ], [ %106, %ELSE211 ]
  %temp55.0 = phi float [ %111, %ENDIF200 ], [ %103, %ELSE214 ], [ %107, %ELSE211 ]
  %temp68.0 = phi float [ %112, %ENDIF200 ], [ %.230, %ELSE214 ], [ %108, %ELSE211 ]
  %temp69.0 = phi float [ %113, %ENDIF200 ], [ %.231, %ELSE214 ], [ %109, %ELSE211 ]
  %temp70.0 = phi float [ %114, %ENDIF200 ], [ %.232, %ELSE214 ], [ %110, %ELSE211 ]
  %temp71.0 = phi float [ %115, %ENDIF200 ], [ %.233, %ELSE214 ], [ %111, %ELSE211 ]
  %603 = fmul float %164, %85
  %604 = fmul float %165, %86
  %605 = fadd float %603, %604
  %606 = fmul float %166, %87
  %607 = fadd float %605, %606
  %608 = fmul float %167, %88
  %609 = fadd float %607, %608
  %610 = fmul float %164, %89
  %611 = fmul float %165, %90
  %612 = fadd float %610, %611
  %613 = fmul float %166, %91
  %614 = fadd float %612, %613
  %615 = fmul float %167, %92
  %616 = fadd float %614, %615
  %617 = fmul float %164, %93
  %618 = fmul float %165, %94
  %619 = fadd float %617, %618
  %620 = fmul float %166, %95
  %621 = fadd float %619, %620
  %622 = fmul float %167, %96
  %623 = fadd float %621, %622
  %624 = fsub float -0.000000e+00, %78
  %625 = fadd float 1.000000e+00, %624
  %626 = call float @fabs(float %609)
  %627 = call float @fabs(float %616)
  %628 = fcmp oge float %625, %626
  %629 = sext i1 %628 to i32
  %630 = bitcast i32 %629 to float
  %631 = bitcast float %630 to i32
  %632 = and i32 %631, 1065353216
  %633 = bitcast i32 %632 to float
  %634 = fcmp oge float %625, %627
  %635 = sext i1 %634 to i32
  %636 = bitcast i32 %635 to float
  %637 = bitcast float %636 to i32
  %638 = and i32 %637, 1065353216
  %639 = bitcast i32 %638 to float
  %640 = fmul float %633, %639
  %641 = fmul float %623, %640
  %642 = fmul float %609, %temp68.0
  %643 = fadd float %642, %temp70.0
  %644 = fmul float %616, %temp69.0
  %645 = fadd float %644, %temp71.0
  %646 = fmul float %609, %temp52.0
  %647 = fadd float %646, %temp54.0
  %648 = fmul float %616, %temp53.0
  %649 = fadd float %648, %temp55.0
  %650 = fadd float %temp80.0, -1.000000e+00
  %651 = fmul float %650, %77
  %652 = fadd float %651, 1.000000e+00
  %653 = call float @llvm.AMDIL.clamp.(float %652, float 0.000000e+00, float 1.000000e+00)
  %654 = bitcast float %643 to i32
  %655 = bitcast float %645 to i32
  %656 = bitcast float 0.000000e+00 to i32
  %657 = insertelement <4 x i32> undef, i32 %654, i32 0
  %658 = insertelement <4 x i32> %657, i32 %655, i32 1
  %659 = insertelement <4 x i32> %658, i32 %656, i32 2
  %660 = insertelement <4 x i32> %659, i32 undef, i32 3
  %661 = call <4 x float> @llvm.SI.samplel.v4i32(<4 x i32> %660, <32 x i8> %127, <16 x i8> %129, i32 2)
  %662 = extractelement <4 x float> %661, i32 0
  %663 = extractelement <4 x float> %661, i32 1
  %664 = bitcast float %647 to i32
  %665 = bitcast float %649 to i32
  %666 = bitcast float 0.000000e+00 to i32
  %667 = insertelement <4 x i32> undef, i32 %664, i32 0
  %668 = insertelement <4 x i32> %667, i32 %665, i32 1
  %669 = insertelement <4 x i32> %668, i32 %666, i32 2
  %670 = insertelement <4 x i32> %669, i32 undef, i32 3
  %671 = call <4 x float> @llvm.SI.samplel.v4i32(<4 x i32> %670, <32 x i8> %127, <16 x i8> %129, i32 2)
  %672 = extractelement <4 x float> %671, i32 0
  %673 = extractelement <4 x float> %671, i32 1
  %674 = fsub float -0.000000e+00, %663
  %675 = fadd float 1.000000e+00, %674
  %676 = fsub float -0.000000e+00, %673
  %677 = fadd float 1.000000e+00, %676
  %678 = fmul float %675, 2.500000e-01
  %679 = fmul float %677, 2.500000e-01
  %680 = fsub float -0.000000e+00, %678
  %681 = fadd float %662, %680
  %682 = fsub float -0.000000e+00, %679
  %683 = fadd float %672, %682
  %684 = fmul float %641, %temp88.0
  %685 = fadd float %684, %temp89.0
  %686 = fmul float %641, %temp90.0
  %687 = fadd float %686, %temp91.0
  %688 = call float @llvm.AMDIL.clamp.(float %685, float 0.000000e+00, float 1.000000e+00)
  %689 = call float @llvm.AMDIL.clamp.(float %687, float 0.000000e+00, float 1.000000e+00)
  %690 = fsub float -0.000000e+00, %688
  %691 = fadd float %662, %690
  %692 = fsub float -0.000000e+00, %689
  %693 = fadd float %672, %692
  %694 = fmul float %662, %662
  %695 = fmul float %672, %672
  %696 = fsub float -0.000000e+00, %694
  %697 = fadd float %681, %696
  %698 = fsub float -0.000000e+00, %695
  %699 = fadd float %683, %698
  %700 = fcmp uge float %697, %75
  %701 = select i1 %700, float %697, float %75
  %702 = fcmp uge float %699, %75
  %703 = select i1 %702, float %699, float %75
  %704 = fmul float %691, %691
  %705 = fadd float %704, %701
  %706 = fmul float %693, %693
  %707 = fadd float %706, %703
  %708 = fdiv float 1.000000e+00, %705
  %709 = fdiv float 1.000000e+00, %707
  %710 = fmul float %701, %708
  %711 = fmul float %703, %709
  %712 = fcmp oge float %691, 0.000000e+00
  %713 = sext i1 %712 to i32
  %714 = bitcast i32 %713 to float
  %715 = bitcast float %714 to i32
  %716 = icmp ne i32 %715, 0
  %.229 = select i1 %716, float 1.000000e+00, float %710
  %717 = fcmp oge float %693, 0.000000e+00
  %718 = sext i1 %717 to i32
  %719 = bitcast i32 %718 to float
  %720 = bitcast float %719 to i32
  %721 = icmp ne i32 %720, 0
  %temp28.0 = select i1 %721, float 1.000000e+00, float %711
  %one.sub.a.i25 = fsub float 1.000000e+00, %653
  %one.sub.ac.i26 = fmul float %one.sub.a.i25, %.229
  %mul.i27 = fmul float %temp28.0, %.229
  %result.i28 = fadd float %mul.i27, %one.sub.ac.i26
  %722 = call float @llvm.pow.f32(float %result.i28, float %76)
  %723 = fmul float %722, %79
  %724 = fadd float %723, %80
  %725 = call float @llvm.AMDIL.clamp.(float %724, float 0.000000e+00, float 1.000000e+00)
  %726 = fmul float %725, %725
  %727 = fmul float 2.000000e+00, %725
  %728 = fsub float -0.000000e+00, %727
  %729 = fadd float 3.000000e+00, %728
  %730 = fmul float %726, %729
  %731 = fmul float %542, %730
  %732 = fmul float %543, %730
  %733 = fmul float %544, %730
  %734 = fmul float %731, %509
  %735 = fadd float %734, %527
  %736 = fmul float %732, %509
  %737 = fadd float %736, %528
  %738 = fmul float %733, %509
  %739 = fadd float %738, %529
  %one.sub.a.i23 = fsub float 1.000000e+00, %230
  %result.i24 = fadd float %284, %one.sub.a.i23
  %one.sub.a.i21 = fsub float 1.000000e+00, %37
  %result.i22 = fadd float %295, %one.sub.a.i21
  %one.sub.a.i19 = fsub float 1.000000e+00, %37
  %result.i20 = fadd float %296, %one.sub.a.i19
  %one.sub.a.i17 = fsub float 1.000000e+00, %37
  %result.i18 = fadd float %297, %one.sub.a.i17
  %one.sub.a.i15 = fsub float 1.000000e+00, %38
  %result.i16 = fadd float %result.i24, %one.sub.a.i15
  %740 = fmul float %result.i22, %result.i16
  %741 = fmul float %result.i20, %result.i16
  %742 = fmul float %result.i18, %result.i16
  %743 = fmul float %735, %740
  %744 = fmul float %737, %741
  %745 = fmul float %739, %742
  %746 = fmul float %temp12.0, %216
  %747 = fmul float %temp13.0, %217
  %748 = fadd float %747, %746
  %749 = fmul float %temp14.0, %218
  %750 = fadd float %748, %749
  %751 = call float @fabs(float %750)
  %752 = fmul float %751, %751
  %753 = fmul float %752, %50
  %754 = fadd float %753, %51
  %755 = call float @llvm.AMDIL.clamp.(float %754, float 0.000000e+00, float 1.000000e+00)
  %756 = fsub float -0.000000e+00, %755
  %757 = fadd float 1.000000e+00, %756
  %758 = fmul float %33, %757
  %759 = fmul float %33, %757
  %760 = fmul float %33, %757
  %761 = fmul float %34, %757
  %one.sub.a.i11 = fsub float 1.000000e+00, %758
  %one.sub.ac.i12 = fmul float %one.sub.a.i11, %743
  %mul.i13 = fmul float %31, %743
  %result.i14 = fadd float %mul.i13, %one.sub.ac.i12
  %one.sub.a.i7 = fsub float 1.000000e+00, %759
  %one.sub.ac.i8 = fmul float %one.sub.a.i7, %744
  %mul.i9 = fmul float %31, %744
  %result.i10 = fadd float %mul.i9, %one.sub.ac.i8
  %one.sub.a.i3 = fsub float 1.000000e+00, %760
  %one.sub.ac.i4 = fmul float %one.sub.a.i3, %745
  %mul.i5 = fmul float %31, %745
  %result.i6 = fadd float %mul.i5, %one.sub.ac.i4
  %one.sub.a.i1 = fsub float 1.000000e+00, %761
  %one.sub.ac.i = fmul float %one.sub.a.i1, %368
  %mul.i = fmul float %32, %368
  %result.i2 = fadd float %mul.i, %one.sub.ac.i
  %762 = fcmp uge float %result.i14, 0x3E6FFFFE60000000
  %763 = select i1 %762, float %result.i14, float 0x3E6FFFFE60000000
  %764 = fcmp uge float %result.i10, 0x3E6FFFFE60000000
  %765 = select i1 %764, float %result.i10, float 0x3E6FFFFE60000000
  %766 = fcmp uge float %result.i6, 0x3E6FFFFE60000000
  %767 = select i1 %766, float %result.i6, float 0x3E6FFFFE60000000
  %768 = fcmp uge float %763, 6.550400e+04
  %769 = select i1 %768, float 6.550400e+04, float %763
  %770 = fcmp uge float %765, 6.550400e+04
  %771 = select i1 %770, float 6.550400e+04, float %765
  %772 = fcmp uge float %767, 6.550400e+04
  %773 = select i1 %772, float 6.550400e+04, float %767
  %774 = fmul float %result.i2, %52
  %775 = fadd float %774, %53
  %776 = call float @llvm.AMDIL.clamp.(float %775, float 0.000000e+00, float 1.000000e+00)
  %777 = call i32 @llvm.SI.packf16(float %769, float %771)
  %778 = bitcast i32 %777 to float
  %779 = call i32 @llvm.SI.packf16(float %773, float %776)
  %780 = bitcast i32 %779 to float
  call void @llvm.SI.export(i32 15, i32 1, i32 1, i32 0, i32 1, float %778, float %780, float %778, float %780)
  ret void

ELSE214:                                          ; preds = %ELSE211
  %781 = fcmp olt float %559, %81
  %782 = sext i1 %781 to i32
  %783 = bitcast i32 %782 to float
  %784 = bitcast float %783 to i32
  %785 = icmp ne i32 %784, 0
  %.230 = select i1 %785, float %104, float %100
  %.231 = select i1 %785, float %105, float %101
  %.232 = select i1 %785, float %106, float %102
  %.233 = select i1 %785, float %107, float %103
  br label %ENDIF209
}

; Function Attrs: readnone
declare float @llvm.AMDIL.clamp.(float, float, float) #3

; Function Attrs: nounwind readnone
declare <4 x float> @llvm.SI.sample.v2i32(<2 x i32>, <32 x i8>, <16 x i8>, i32) #2

; Function Attrs: nounwind readnone
declare <4 x float> @llvm.SI.samplel.v4i32(<4 x i32>, <32 x i8>, <16 x i8>, i32) #2

; Function Attrs: readnone
declare float @llvm.AMDIL.exp.(float) #3

; Function Attrs: nounwind readnone
declare float @llvm.SI.load.const(<16 x i8>, i32) #2

; Function Attrs: nounwind readnone
declare float @llvm.SI.fs.interp(i32, i32, i32, <2 x i32>) #2

; Function Attrs: readnone
declare i32 @llvm.SI.tid() #3

; Function Attrs: nounwind readonly
declare float @ceil(float) #4

; Function Attrs: nounwind readnone
declare float @llvm.amdgcn.rsq.f32(float) #2

; Function Attrs: nounwind readnone
declare <4 x float> @llvm.SI.sampled.v8i32(<8 x i32>, <32 x i8>, <16 x i8>, i32) #2

; Function Attrs: readnone
declare <4 x float> @llvm.AMDGPU.cube(<4 x float>) #3

; Function Attrs: readnone
declare float @fabs(float) #3

; Function Attrs: nounwind readnone
declare <4 x float> @llvm.SI.sample.v4i32(<4 x i32>, <32 x i8>, <16 x i8>, i32) #2

; Function Attrs: nounwind readnone
declare float @llvm.pow.f32(float, float) #2

; Function Attrs: nounwind readnone
declare i32 @llvm.SI.packf16(float, float) #2

declare void @llvm.SI.export(i32, i32, i32, i32, i32, float, float, float, float)



attributes #0 = { alwaysinline nounwind readnone }
attributes #1 = { "ShaderType"="0" }
attributes #2 = { nounwind readnone }
attributes #3 = { readnone }
attributes #4 = { nounwind readonly }

!0 = !{!1, !1, i64 0, i32 1}
!1 = !{!"const", null}