; ModuleID = 'tgsi'
target triple = "amdgcn--"

define <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> @main([9 x <16 x i8>] addrspace(2)* byval, [17 x <16 x i8>] addrspace(2)* byval, [17 x <8 x i32>] addrspace(2)* byval, i32 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, i32, i32, float, i32) #0 {
main_body:
  %22 = getelementptr [17 x <16 x i8>], [17 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0
  %23 = load <16 x i8>, <16 x i8> addrspace(2)* %22, align 16, !tbaa !0
  %24 = call float @llvm.SI.load.const(<16 x i8> %23, i32 0)
  %25 = call float @llvm.SI.load.const(<16 x i8> %23, i32 4)
  %26 = call float @llvm.SI.load.const(<16 x i8> %23, i32 20)
  %27 = call float @llvm.SI.load.const(<16 x i8> %23, i32 32)
  %28 = call float @llvm.SI.load.const(<16 x i8> %23, i32 36)
  %29 = call float @llvm.SI.load.const(<16 x i8> %23, i32 40)
  %30 = call float @llvm.SI.load.const(<16 x i8> %23, i32 48)
  %31 = call float @llvm.SI.load.const(<16 x i8> %23, i32 52)
  %32 = call float @llvm.SI.load.const(<16 x i8> %23, i32 56)
  %33 = call float @llvm.SI.load.const(<16 x i8> %23, i32 64)
  %34 = call float @llvm.SI.load.const(<16 x i8> %23, i32 68)
  %35 = call float @llvm.SI.load.const(<16 x i8> %23, i32 72)
  %36 = call float @llvm.SI.load.const(<16 x i8> %23, i32 192)
  %37 = call float @llvm.SI.load.const(<16 x i8> %23, i32 196)
  %38 = call float @llvm.SI.load.const(<16 x i8> %23, i32 200)
  %39 = call float @llvm.SI.load.const(<16 x i8> %23, i32 204)
  %40 = call float @llvm.SI.load.const(<16 x i8> %23, i32 224)
  %41 = call float @llvm.SI.load.const(<16 x i8> %23, i32 240)
  %42 = getelementptr [17 x <8 x i32>], [17 x <8 x i32>] addrspace(2)* %2, i64 0, i64 0
  %43 = load <8 x i32>, <8 x i32> addrspace(2)* %42, align 32, !tbaa !0
  %44 = bitcast [17 x <8 x i32>] addrspace(2)* %2 to [0 x <4 x i32>] addrspace(2)*
  %45 = getelementptr [0 x <4 x i32>], [0 x <4 x i32>] addrspace(2)* %44, i64 0, i64 3
  %46 = load <4 x i32>, <4 x i32> addrspace(2)* %45, align 16, !tbaa !0
  %47 = getelementptr [17 x <8 x i32>], [17 x <8 x i32>] addrspace(2)* %2, i64 0, i64 2
  %48 = load <8 x i32>, <8 x i32> addrspace(2)* %47, align 32, !tbaa !0
  %49 = getelementptr [17 x <8 x i32>], [17 x <8 x i32>] addrspace(2)* %2, i64 0, i64 3
  %50 = load <8 x i32>, <8 x i32> addrspace(2)* %49, align 32, !tbaa !0
  %51 = getelementptr [17 x <8 x i32>], [17 x <8 x i32>] addrspace(2)* %2, i64 0, i64 5
  %52 = load <8 x i32>, <8 x i32> addrspace(2)* %51, align 32, !tbaa !0
  %53 = getelementptr [17 x <8 x i32>], [17 x <8 x i32>] addrspace(2)* %2, i64 0, i64 6
  %54 = load <8 x i32>, <8 x i32> addrspace(2)* %53, align 32, !tbaa !0
  %55 = getelementptr [17 x <8 x i32>], [17 x <8 x i32>] addrspace(2)* %2, i64 0, i64 7
  %56 = load <8 x i32>, <8 x i32> addrspace(2)* %55, align 32, !tbaa !0
  %57 = getelementptr [17 x <8 x i32>], [17 x <8 x i32>] addrspace(2)* %2, i64 0, i64 8
  %58 = load <8 x i32>, <8 x i32> addrspace(2)* %57, align 32, !tbaa !0
  %59 = bitcast [17 x <8 x i32>] addrspace(2)* %2 to [0 x <4 x i32>] addrspace(2)*
  %60 = getelementptr [0 x <4 x i32>], [0 x <4 x i32>] addrspace(2)* %59, i64 0, i64 19
  %61 = load <4 x i32>, <4 x i32> addrspace(2)* %60, align 16, !tbaa !0
  %62 = call float @llvm.SI.fs.interp(i32 0, i32 0, i32 %5, <2 x i32> %7)
  %63 = call float @llvm.SI.fs.interp(i32 1, i32 0, i32 %5, <2 x i32> %7)
  %64 = call float @llvm.SI.fs.interp(i32 0, i32 1, i32 %5, <2 x i32> %7)
  %65 = call float @llvm.SI.fs.interp(i32 1, i32 1, i32 %5, <2 x i32> %7)
  %66 = call float @llvm.SI.fs.interp(i32 2, i32 1, i32 %5, <2 x i32> %7)
  %67 = bitcast float %62 to i32
  %68 = bitcast float %63 to i32
  %69 = insertelement <2 x i32> undef, i32 %67, i32 0
  %70 = insertelement <2 x i32> %69, i32 %68, i32 1
  %71 = call <4 x float> @llvm.SI.image.sample.v2i32(<2 x i32> %70, <8 x i32> %43, <4 x i32> %46, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
  %72 = extractelement <4 x float> %71, i32 0
  %73 = extractelement <4 x float> %71, i32 1
  %74 = extractelement <4 x float> %71, i32 2
  %75 = extractelement <4 x float> %71, i32 3
  %76 = fmul float %62, %24
  %77 = fmul float %63, %25
  %78 = fptosi float %76 to i32
  %79 = fptosi float %77 to i32
  %80 = insertelement <4 x i32> undef, i32 %78, i32 0
  %81 = insertelement <4 x i32> %80, i32 %79, i32 1
  %82 = insertelement <4 x i32> %81, i32 0, i32 2
  %83 = call <4 x i32> @llvm.SI.image.load.v4i32(<4 x i32> %82, <8 x i32> %56, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
  %84 = extractelement <4 x i32> %83, i32 0
  %85 = and i32 %84, 15
  %86 = extractelement <8 x i32> %56, i32 1
  %87 = icmp ne i32 %86, 0
  %88 = select i1 %87, i32 %85, i32 0
  %89 = insertelement <4 x i32> undef, i32 %78, i32 0
  %90 = insertelement <4 x i32> %89, i32 %79, i32 1
  %91 = insertelement <4 x i32> %90, i32 %88, i32 2
  %92 = call <4 x i32> @llvm.SI.image.load.v4i32(<4 x i32> %91, <8 x i32> %54, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
  %bc = bitcast <4 x i32> %92 to <4 x float>
  %93 = extractelement <4 x float> %bc, i32 0
  %94 = fmul float %62, %24
  %95 = fmul float %63, %25
  %96 = fptosi float %94 to i32
  %97 = fptosi float %95 to i32
  %98 = insertelement <4 x i32> undef, i32 %96, i32 0
  %99 = insertelement <4 x i32> %98, i32 %97, i32 1
  %100 = insertelement <4 x i32> %99, i32 0, i32 2
  %101 = call <4 x i32> @llvm.SI.image.load.v4i32(<4 x i32> %100, <8 x i32> %50, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
  %102 = extractelement <4 x i32> %101, i32 0
  %103 = and i32 %102, 15
  %104 = extractelement <8 x i32> %50, i32 1
  %105 = icmp ne i32 %104, 0
  %106 = select i1 %105, i32 %103, i32 0
  %107 = insertelement <4 x i32> undef, i32 %96, i32 0
  %108 = insertelement <4 x i32> %107, i32 %97, i32 1
  %109 = insertelement <4 x i32> %108, i32 %106, i32 2
  %110 = call <4 x i32> @llvm.SI.image.load.v4i32(<4 x i32> %109, <8 x i32> %48, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
  %bc36 = bitcast <4 x i32> %110 to <4 x float>
  %111 = extractelement <4 x float> %bc36, i32 0
  %bc37 = bitcast <4 x i32> %110 to <4 x float>
  %112 = extractelement <4 x float> %bc37, i32 1
  %bc38 = bitcast <4 x i32> %110 to <4 x float>
  %113 = extractelement <4 x float> %bc38, i32 2
  %114 = fmul float %111, 0x3FFFE00000000000
  %115 = call float @llvm.floor.f32(float %114)
  %116 = fmul float %115, 0x3FE0101020000000
  %117 = fsub float %111, %116
  %118 = fmul float %117, 0x3FFFE00000000000
  %119 = fmul float %112, 0x3F7FE00000000000
  %120 = fadd float %119, %118
  %121 = fmul float %113, 0x3EFFE00000000000
  %122 = fadd float %120, %121
  %123 = fsub float 1.000000e+00, %122
  %124 = fmul float %123, %123
  %125 = fmul float %124, %26
  %126 = fcmp ogt float %93, 0.000000e+00
  %127 = fcmp olt float %125, %40
  %128 = and i1 %126, %127
  br i1 %128, label %IF, label %ENDIF

IF:                                               ; preds = %main_body
  %129 = bitcast [17 x <8 x i32>] addrspace(2)* %2 to [0 x <4 x i32>] addrspace(2)*
  %130 = getelementptr [0 x <4 x i32>], [0 x <4 x i32>] addrspace(2)* %129, i64 0, i64 23
  %131 = load <4 x i32>, <4 x i32> addrspace(2)* %130, align 16, !tbaa !0
  %132 = getelementptr [17 x <8 x i32>], [17 x <8 x i32>] addrspace(2)* %2, i64 0, i64 10
  %133 = load <8 x i32>, <8 x i32> addrspace(2)* %132, align 32, !tbaa !0
  %134 = getelementptr [17 x <8 x i32>], [17 x <8 x i32>] addrspace(2)* %2, i64 0, i64 4
  %135 = load <8 x i32>, <8 x i32> addrspace(2)* %134, align 32, !tbaa !0
  %136 = call float @llvm.SI.load.const(<16 x i8> %23, i32 320)
  %137 = call float @llvm.SI.load.const(<16 x i8> %23, i32 304)
  %138 = call float @llvm.SI.load.const(<16 x i8> %23, i32 288)
  %139 = call float @llvm.SI.load.const(<16 x i8> %23, i32 272)
  %140 = call float @llvm.SI.load.const(<16 x i8> %23, i32 264)
  %141 = call float @llvm.SI.load.const(<16 x i8> %23, i32 260)
  %142 = call float @llvm.SI.load.const(<16 x i8> %23, i32 256)
  %143 = call float @llvm.SI.load.const(<16 x i8> %23, i32 208)
  %144 = call float @llvm.SI.load.const(<16 x i8> %23, i32 88)
  %145 = call float @llvm.SI.load.const(<16 x i8> %23, i32 84)
  %146 = call float @llvm.SI.load.const(<16 x i8> %23, i32 80)
  %147 = call float @llvm.SI.load.const(<16 x i8> %23, i32 76)
  %148 = call float @llvm.SI.load.const(<16 x i8> %23, i32 60)
  %149 = call float @llvm.SI.load.const(<16 x i8> %23, i32 44)
  %150 = fmul float %64, %64
  %151 = fmul float %65, %65
  %152 = fadd float %151, %150
  %153 = fmul float %66, %66
  %154 = fadd float %152, %153
  %155 = call float @llvm.AMDGPU.rsq.clamped.f32(float %154)
  %156 = fmul float %64, %155
  %157 = fmul float %65, %155
  %158 = fmul float %66, %155
  %159 = fmul float %156, %125
  %160 = fmul float %157, %125
  %161 = fmul float %158, %125
  %162 = fmul float %27, %159
  %163 = fmul float %28, %159
  %164 = fmul float %29, %159
  %165 = fmul float %149, %159
  %166 = fmul float %30, %160
  %167 = fadd float %166, %162
  %168 = fmul float %31, %160
  %169 = fadd float %168, %163
  %170 = fmul float %32, %160
  %171 = fadd float %170, %164
  %172 = fmul float %148, %160
  %173 = fadd float %172, %165
  %174 = fmul float %33, %161
  %175 = fadd float %174, %167
  %176 = fmul float %34, %161
  %177 = fadd float %176, %169
  %178 = fmul float %35, %161
  %179 = fadd float %178, %171
  %180 = fmul float %147, %161
  %181 = fadd float %180, %173
  %182 = fadd float %175, %146
  %183 = fadd float %177, %145
  %184 = fadd float %179, %144
  %185 = fmul float %27, %156
  %186 = fmul float %28, %156
  %187 = fmul float %29, %156
  %188 = fmul float %30, %157
  %189 = fadd float %188, %185
  %190 = fmul float %31, %157
  %191 = fadd float %190, %186
  %192 = fmul float %32, %157
  %193 = fadd float %192, %187
  %194 = fmul float %33, %158
  %195 = fadd float %194, %189
  %196 = fmul float %34, %158
  %197 = fadd float %196, %191
  %198 = fmul float %35, %158
  %199 = fadd float %198, %193
  %200 = fmul float %62, %24
  %201 = fmul float %63, %25
  %202 = fptosi float %200 to i32
  %203 = fptosi float %201 to i32
  %204 = insertelement <4 x i32> undef, i32 %202, i32 0
  %205 = insertelement <4 x i32> %204, i32 %203, i32 1
  %206 = insertelement <4 x i32> %205, i32 0, i32 2
  %207 = call <4 x i32> @llvm.SI.image.load.v4i32(<4 x i32> %206, <8 x i32> %52, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
  %208 = extractelement <4 x i32> %207, i32 0
  %209 = and i32 %208, 15
  %210 = extractelement <8 x i32> %52, i32 1
  %211 = icmp ne i32 %210, 0
  %212 = select i1 %211, i32 %209, i32 0
  %213 = insertelement <4 x i32> undef, i32 %202, i32 0
  %214 = insertelement <4 x i32> %213, i32 %203, i32 1
  %215 = insertelement <4 x i32> %214, i32 %212, i32 2
  %216 = call <4 x i32> @llvm.SI.image.load.v4i32(<4 x i32> %215, <8 x i32> %135, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
  %bc39 = bitcast <4 x i32> %216 to <4 x float>
  %217 = extractelement <4 x float> %bc39, i32 0
  %bc40 = bitcast <4 x i32> %216 to <4 x float>
  %218 = extractelement <4 x float> %bc40, i32 1
  %bc41 = bitcast <4 x i32> %216 to <4 x float>
  %219 = extractelement <4 x float> %bc41, i32 2
  %220 = fmul float %217, 2.000000e+00
  %221 = fadd float %220, -1.000000e+00
  %222 = fmul float %218, 2.000000e+00
  %223 = fadd float %222, -1.000000e+00
  %224 = fmul float %219, 2.000000e+00
  %225 = fadd float %224, -1.000000e+00
  %226 = fmul float %27, %221
  %227 = fmul float %28, %221
  %228 = fmul float %29, %221
  %229 = fmul float %30, %223
  %230 = fadd float %229, %226
  %231 = fmul float %31, %223
  %232 = fadd float %231, %227
  %233 = fmul float %32, %223
  %234 = fadd float %233, %228
  %235 = fmul float %33, %225
  %236 = fadd float %235, %230
  %237 = fmul float %34, %225
  %238 = fadd float %237, %232
  %239 = fmul float %35, %225
  %240 = fadd float %239, %234
  %241 = fdiv float 1.000000e+00, %40
  %242 = fmul float %125, %241
  %243 = fsub float 1.000000e+00, %242
  %244 = fmul float %236, %236
  %245 = fmul float %238, %238
  %246 = fmul float %182, %36
  %247 = fadd float %246, %38
  %248 = fmul float %184, %37
  %249 = fadd float %248, %39
  %250 = bitcast float %247 to i32
  %251 = bitcast float %249 to i32
  %252 = insertelement <2 x i32> undef, i32 %250, i32 0
  %253 = insertelement <2 x i32> %252, i32 %251, i32 1
  %254 = call <4 x float> @llvm.SI.image.sample.v2i32(<2 x i32> %253, <8 x i32> %58, <4 x i32> %61, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
  %255 = extractelement <4 x float> %254, i32 0
  %256 = extractelement <4 x float> %254, i32 1
  %257 = fmul float %255, %255
  %258 = fmul float %256, %256
  %259 = fadd float %257, %258
  %260 = fsub float 1.000000e+00, %259
  %261 = call float @llvm.AMDGPU.clamp.(float %260, float 0.000000e+00, float 1.000000e+00)
  %262 = fmul float %255, %245
  %263 = fmul float %256, %245
  %264 = fmul float %183, %36
  %265 = fadd float %264, %38
  %266 = fmul float %184, %37
  %267 = fadd float %266, %39
  %268 = bitcast float %265 to i32
  %269 = bitcast float %267 to i32
  %270 = insertelement <2 x i32> undef, i32 %268, i32 0
  %271 = insertelement <2 x i32> %270, i32 %269, i32 1
  %272 = call <4 x float> @llvm.SI.image.sample.v2i32(<2 x i32> %271, <8 x i32> %58, <4 x i32> %61, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
  %273 = extractelement <4 x float> %272, i32 0
  %274 = extractelement <4 x float> %272, i32 1
  %275 = fmul float %273, %273
  %276 = fmul float %274, %274
  %277 = fadd float %275, %276
  %278 = fsub float 1.000000e+00, %277
  %279 = call float @llvm.AMDGPU.clamp.(float %278, float 0.000000e+00, float 1.000000e+00)
  %280 = fmul float %273, %244
  %281 = fmul float %274, %244
  %282 = fadd float %262, 0.000000e+00
  %283 = fadd float %280, 0.000000e+00
  %284 = fadd float %263, %281
  %285 = fmul float %282, %41
  %286 = fadd float %285, %236
  %287 = fmul float %283, %41
  %288 = fadd float %287, %238
  %289 = fmul float %284, %41
  %290 = fadd float %289, %240
  %291 = fmul float %286, %286
  %292 = fmul float %288, %288
  %293 = fadd float %292, %291
  %294 = fmul float %290, %290
  %295 = fadd float %293, %294
  %296 = call float @llvm.AMDGPU.rsq.clamped.f32(float %295)
  %297 = fmul float %286, %296
  %298 = fmul float %288, %296
  %299 = fmul float %290, %296
  %300 = fdiv float 1.000000e+00, %125
  %301 = fmul float %138, %300
  %302 = fmul float %282, %301
  %303 = fadd float %302, %62
  %304 = fmul float %283, %301
  %305 = fadd float %304, %63
  %306 = bitcast float %303 to i32
  %307 = bitcast float %305 to i32
  %308 = insertelement <2 x i32> undef, i32 %306, i32 0
  %309 = insertelement <2 x i32> %308, i32 %307, i32 1
  %310 = call <4 x float> @llvm.SI.image.sample.v2i32(<2 x i32> %309, <8 x i32> %43, <4 x i32> %46, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
  %311 = extractelement <4 x float> %310, i32 0
  %312 = extractelement <4 x float> %310, i32 1
  %313 = extractelement <4 x float> %310, i32 2
  %314 = extractelement <4 x float> %310, i32 3
  %315 = fmul float %297, %195
  %316 = fmul float %298, %197
  %317 = fadd float %316, %315
  %318 = fmul float %299, %199
  %319 = fadd float %317, %318
  %320 = fmul float %319, %297
  %321 = fmul float %319, %298
  %322 = fmul float %319, %299
  %323 = fmul float %320, 2.000000e+00
  %324 = fmul float %321, 2.000000e+00
  %325 = fmul float %322, 2.000000e+00
  %326 = fsub float %195, %323
  %327 = fsub float %197, %324
  %328 = fsub float %199, %325
  %329 = insertelement <4 x float> undef, float %326, i32 0
  %330 = insertelement <4 x float> %329, float %327, i32 1
  %331 = insertelement <4 x float> %330, float %328, i32 2
  %332 = insertelement <4 x float> %331, float %181, i32 3
  %333 = call <4 x float> @llvm.AMDGPU.cube(<4 x float> %332)
  %334 = extractelement <4 x float> %333, i32 0
  %335 = extractelement <4 x float> %333, i32 1
  %336 = extractelement <4 x float> %333, i32 2
  %337 = call float @llvm.fabs.f32(float %336)
  %338 = fdiv float 1.000000e+00, %337
  %339 = fmul float %334, %338
  %340 = fadd float %339, 1.500000e+00
  %341 = fmul float %335, %338
  %342 = fadd float %341, 1.500000e+00
  %343 = bitcast float %342 to i32
  %344 = bitcast float %340 to i32
  %bc42 = bitcast <4 x float> %333 to <4 x i32>
  %345 = insertelement <4 x i32> undef, i32 %343, i32 0
  %346 = insertelement <4 x i32> %345, i32 %344, i32 1
  %347 = shufflevector <4 x i32> %346, <4 x i32> %bc42, <4 x i32> <i32 0, i32 1, i32 7, i32 undef>
  %348 = call <4 x float> @llvm.SI.image.sample.v4i32(<4 x i32> %347, <8 x i32> %133, <4 x i32> %131, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
  %349 = extractelement <4 x float> %348, i32 0
  %350 = extractelement <4 x float> %348, i32 1
  %351 = extractelement <4 x float> %348, i32 2
  %352 = fmul float %349, %142
  %353 = fmul float %350, %141
  %354 = fmul float %351, %140
  %355 = fmul float %240, %143
  %356 = fadd float %355, 1.000000e+00
  %357 = call float @llvm.AMDGPU.clamp.(float %356, float 0.000000e+00, float 1.000000e+00)
  %358 = fmul float %139, %357
  %359 = fmul float %243, %243
  %360 = fmul float %195, %297
  %361 = fmul float %197, %298
  %362 = fadd float %361, %360
  %363 = fmul float %199, %299
  %364 = fadd float %362, %363
  %365 = call float @llvm.fabs.f32(float %364)
  %366 = fsub float 1.000000e+00, %365
  %367 = call float @llvm.AMDGPU.clamp.(float %366, float 0.000000e+00, float 1.000000e+00)
  %368 = call float @llvm.pow.f32(float %367, float %136)
  %369 = fsub float 1.000000e+00, %368
  %370 = fmul float %137, %369
  %371 = fadd float %368, %370
  %372 = call float @llvm.AMDGPU.clamp.(float %371, float 0.000000e+00, float 1.000000e+00)
  %373 = fmul float %359, %372
  %374 = fmul float %358, %373
  %375 = fmul float %352, %374
  %376 = fadd float %375, %311
  %377 = fmul float %353, %374
  %378 = fadd float %377, %312
  %379 = fmul float %354, %374
  %380 = fadd float %379, %313
  br label %ENDIF

ENDIF:                                            ; preds = %main_body, %IF
  %temp.0 = phi float [ %376, %IF ], [ %72, %main_body ]
  %temp1.0 = phi float [ %378, %IF ], [ %73, %main_body ]
  %temp2.0 = phi float [ %380, %IF ], [ %74, %main_body ]
  %temp3.0 = phi float [ %314, %IF ], [ %75, %main_body ]
  %381 = bitcast float %4 to i32
  %382 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> undef, i32 %381, 8
  %383 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %382, float %temp.0, 9
  %384 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %383, float %temp1.0, 10
  %385 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %384, float %temp2.0, 11
  %386 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %385, float %temp3.0, 12
  %387 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %386, float %20, 22
  ret <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %387
}

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

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

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

; Function Attrs: nounwind readnone
declare <4 x i32> @llvm.SI.image.load.v4i32(<4 x i32>, <8 x i32>, i32, i32, i32, i32, i32, i32, i32, i32) #1

; Function Attrs: nounwind readnone
declare float @llvm.floor.f32(float) #1

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

; Function Attrs: readnone
declare float @llvm.AMDGPU.clamp.(float, float, float) #2

; Function Attrs: nounwind readnone
declare float @llvm.sqrt.f32(float) #1

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

; Function Attrs: nounwind readnone
declare float @llvm.fabs.f32(float) #1

; Function Attrs: nounwind readnone
declare <4 x float> @llvm.SI.image.sample.v4i32(<4 x i32>, <8 x i32>, <4 x i32>, i32, i32, i32, i32, i32, i32, i32, i32) #1

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

attributes #0 = { "InitialPSInputAddr"="36983" "ShaderType"="0" }
attributes #1 = { nounwind readnone }
attributes #2 = { readnone }

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