Attachment 126700 Details for Bug 97887 – stderr output with R600_DEBUG=vs,tcs,tes,gs,ps,cs

stderr output with R600_DEBUG=vs,tcs,tes,gs,ps,cs

err.txt (text/plain), 161.21 KB, created by Christoph Haag on 2016-09-21 11:24:38 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Christoph Haag

Created: 2016-09-21 11:24:38 UTC

Size: 161.21 KB

patch

obsolete

>CookieJar::ReadFromDisk(): Read 0 cookies.
>Using breakpad crash handler
>Setting breakpad minidump AppID = 250820
>Forcing breakpad minidump interfaces to load
>Looking up breakpad interfaces from steamclient
>Calling BreakpadMiniDumpSystemInit
>[1mSept 21 13:16:03.671 info [OSVR]: 0x7f3b24b7fefa/home/chris/.local/share/Steam/SteamApps/common/SteamVR/bin/linux64/vrserver
>[00m[1mSept 21 13:16:03.671 info [OSVR: org.osvr.SteamVR]: OSVR client context initialized for org.osvr.SteamVR
>[00m[1mSept 21 13:16:03.672 info [OSVR: org.osvr.SteamVR]: 0x7f3b24e027c0
>[00m[1mSept 21 13:16:03.726 info [OSVR: org.osvr.SteamVR]: Connected 0 of 0 unconnected paths successfully
>[00m[1mSept 21 13:16:03.727 info [OSVR: org.osvr.SteamVR]: Connection process took 55ms: have connection to server, have path tree
>[00m[1mSept 21 13:16:03.728 info [OSVR]: /home/chris/build/osvr-core/src/osvr-core/src/osvr/Common/ClientInterface.cpp:38: Interface initialized for /me/head
>[00m[1mSept 21 13:16:03.729 info [OSVR]: /home/chris/build/osvr-core/src/osvr-core/src/osvr/Client/TrackerRemoteFactory.cpp:93: Constructed a TrackerHandler for org_osvr_filter_videoimufusion/HeadFusion@localhost:3883 sensor 0
>[00m[1mSept 21 13:16:03.729 info [OSVR: org.osvr.SteamVR]: Successfully produced handler for /me/head
>[00m[1mSept 21 13:16:03.729 info [OSVR]: /home/chris/build/osvr-core/src/osvr-core/src/osvr/Common/ClientInterface.cpp:38: Interface initialized for /me/head
>[00m[1mSept 21 13:16:03.729 info [OSVR]: /home/chris/build/osvr-core/src/osvr-core/src/osvr/Common/ClientInterface.cpp:38: Interface initialized for /me/head
>[00m[1mSept 21 13:16:03.729 info [OSVR]: /home/chris/build/osvr-core/src/osvr-core/src/osvr/Client/DisplayConfig.cpp:195: Display: OSVR HDK (Version 2.0) [Display descriptor note: OSVR HDK 2.0]
>[00m[1mSept 21 13:16:03.729 info [OSVR]: /home/chris/build/osvr-core/src/osvr-core/src/osvr/ClientKit/DisplayC.cpp:47: Created an OSVR_DisplayConfigObject!
>[00m[1mSept 21 13:16:03.731 info [OSVR]: /home/chris/build/osvr-core/src/osvr-core/src/osvr/Common/ClientInterface.cpp:38: Interface initialized for /me/head
>[00m[1mSept 21 13:16:03.783 info [OSVR]: /home/chris/build/osvr-core/src/osvr-core/src/osvr/Common/ClientInterface.cpp:38: Interface initialized for /org_osvr_filter_videoimufusion/HeadFusion/semantic/camera
>[00m[1mSept 21 13:16:03.783 info [OSVR]: /home/chris/build/osvr-core/src/osvr-core/src/osvr/Client/TrackerRemoteFactory.cpp:93: Constructed a TrackerHandler for org_osvr_filter_videoimufusion/HeadFusion@localhost:3883 sensor 2
>[00m[1mSept 21 13:16:03.783 info [OSVR: org.osvr.SteamVR]: Successfully produced handler for /org_osvr_filter_videoimufusion/HeadFusion/semantic/camera
>[00mViveRenderer::Initialize() - HMD string has zero length
>INFO: Vertex shader compiled sucessfully: "assets/shaders/fullScreenQuad_vert.txt"
>Shader Info Log: /n
>INFO: Fragmentshader compiled sucessfully: "assets/shaders/fullScreenQuad_frag.txt"
>Shader Info Log: /n
>VERT
>PROPERTY NEXT_SHADER FRAG
>DCL IN[0]
>DCL OUT[0], POSITION
>DCL TEMP[0], LOCAL
>IMM[0] FLT32 {    0.0000,     1.0000,     0.0000,     0.0000}
>  0: MOV TEMP[0].zw, IMM[0].yyxy
>  1: MOV TEMP[0].xy, IN[0].xyxx
>  2: MOV OUT[0], TEMP[0]
>  3: END
>radeonsi: Compiling shader 1
>TGSI shader LLVM IR:
>
>; ModuleID = 'tgsi'
>source_filename = "tgsi"
>target triple = "amdgcn--"
>
>define amdgpu_vs <{ float, float, float }> @main([17 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), [32 x <8 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <8 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <4 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32, i32, i32, i32, i32) {
>main_body:
>  %15 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 0, !amdgpu.uniform !0
>  %16 = load <16 x i8>, <16 x i8> addrspace(2)* %15, align 16, !invariant.load !0
>  %17 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %16, i32 0, i32 %14)
>  %18 = extractelement <4 x float> %17, i32 0
>  %19 = extractelement <4 x float> %17, i32 1
>  %20 = bitcast i32 %12 to float
>  %21 = insertvalue <{ float, float, float }> undef, float %20, 2
>  call void @llvm.SI.export(i32 15, i32 0, i32 1, i32 12, i32 0, float %18, float %19, float 0.000000e+00, float 1.000000e+00)
>  ret <{ float, float, float }> %21
>}
>
>; Function Attrs: nounwind readnone
>declare <4 x float> @llvm.SI.vs.load.input(<16 x i8>, i32, i32) #0
>
>; Function Attrs: nounwind
>declare void @llvm.SI.export(i32, i32, i32, i32, i32, float, float, float, float) #1
>
>attributes #0 = { nounwind readnone }
>attributes #1 = { nounwind }
>
>!0 = !{}
>
>FRAG
>DCL SV[0], POSITION
>DCL OUT[0], POSITION
>DCL OUT[1], COLOR
>DCL SAMP[0]
>DCL SAMP[1]
>DCL SVIEW[0], 2D, FLOAT
>DCL SVIEW[1], 2D, FLOAT
>DCL CONST[2]
>DCL TEMP[0]
>DCL TEMP[1..3], LOCAL
>IMM[0] INT32 {0, 1, 2, 3}
>IMM[1] FLT32 {    0.2500,     0.0000,     0.0000,     0.0000}
>  0: MOV TEMP[0], SV[0]
>  1: MAD TEMP[0].y, SV[0], CONST[2].xxxx, CONST[2].yyyy
>  2: F2I TEMP[1].x, TEMP[0].xxxx
>  3: F2I TEMP[2].x, TEMP[0].yyyy
>  4: MOV TEMP[1].y, TEMP[2].xxxx
>  5: MOV TEMP[2].xy, TEMP[1].xyyy
>  6: MOV TEMP[2].w, IMM[0].xxxx
>  7: TXF TEMP[2], TEMP[2], SAMP[0], 2D
>  8: MOV TEMP[3].xy, TEMP[1].xyyy
>  9: MOV TEMP[3].w, IMM[0].yyyy
> 10: TXF TEMP[3], TEMP[3], SAMP[0], 2D
> 11: ADD TEMP[2], TEMP[2], TEMP[3]
> 12: MOV TEMP[3].xy, TEMP[1].xyyy
> 13: MOV TEMP[3].w, IMM[0].zzzz
> 14: TXF TEMP[3], TEMP[3], SAMP[0], 2D
> 15: ADD TEMP[2], TEMP[2], TEMP[3]
> 16: MOV TEMP[3].xy, TEMP[1].xyyy
> 17: MOV TEMP[3].w, IMM[0].wwww
> 18: TXF TEMP[3], TEMP[3], SAMP[0], 2D
> 19: ADD TEMP[2], TEMP[2], TEMP[3]
> 20: MUL TEMP[2], TEMP[2], IMM[1].xxxx
> 21: MOV TEMP[1].xy, TEMP[1].xyyy
> 22: MOV TEMP[1].w, IMM[0].xxxx
> 23: TXF TEMP[1].x, TEMP[1], SAMP[1], 2D
> 24: MOV OUT[0].z, TEMP[1].xxxx
> 25: MOV OUT[1], TEMP[2]
> 26: END
>radeonsi: Compiling shader 2
>TGSI shader LLVM IR:
>
>; ModuleID = 'tgsi'
>source_filename = "tgsi"
>target triple = "amdgcn--"
>
>define amdgpu_ps <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> @main([17 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), [32 x <8 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <8 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <4 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), 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:
>  %23 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %24 = load <16 x i8>, <16 x i8> addrspace(2)* %23, align 16, !invariant.load !0
>  %25 = call float @llvm.SI.load.const(<16 x i8> %24, i32 32)
>  %26 = call float @llvm.SI.load.const(<16 x i8> %24, i32 36)
>  %27 = fmul float %25, %16
>  %28 = fadd float %27, %26
>  %29 = fptosi float %15 to i32
>  %30 = fptosi float %28 to i32
>  %31 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 0, !amdgpu.uniform !0
>  %32 = load <8 x i32>, <8 x i32> addrspace(2)* %31, align 32, !invariant.load !0
>  %33 = insertelement <4 x i32> undef, i32 %29, i32 0
>  %34 = insertelement <4 x i32> %33, i32 %30, i32 1
>  %35 = insertelement <4 x i32> %34, i32 0, i32 2
>  %36 = call <4 x i32> @llvm.SI.image.load.mip.v4i32(<4 x i32> %35, <8 x i32> %32, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %bc = bitcast <4 x i32> %36 to <4 x float>
>  %37 = extractelement <4 x float> %bc, i32 0
>  %bc1 = bitcast <4 x i32> %36 to <4 x float>
>  %38 = extractelement <4 x float> %bc1, i32 1
>  %bc2 = bitcast <4 x i32> %36 to <4 x float>
>  %39 = extractelement <4 x float> %bc2, i32 2
>  %bc3 = bitcast <4 x i32> %36 to <4 x float>
>  %40 = extractelement <4 x float> %bc3, i32 3
>  %41 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 0, !amdgpu.uniform !0
>  %42 = load <8 x i32>, <8 x i32> addrspace(2)* %41, align 32, !invariant.load !0
>  %43 = insertelement <4 x i32> undef, i32 %29, i32 0
>  %44 = insertelement <4 x i32> %43, i32 %30, i32 1
>  %45 = insertelement <4 x i32> %44, i32 1, i32 2
>  %46 = call <4 x i32> @llvm.SI.image.load.mip.v4i32(<4 x i32> %45, <8 x i32> %42, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %bc4 = bitcast <4 x i32> %46 to <4 x float>
>  %47 = extractelement <4 x float> %bc4, i32 0
>  %bc5 = bitcast <4 x i32> %46 to <4 x float>
>  %48 = extractelement <4 x float> %bc5, i32 1
>  %bc6 = bitcast <4 x i32> %46 to <4 x float>
>  %49 = extractelement <4 x float> %bc6, i32 2
>  %bc7 = bitcast <4 x i32> %46 to <4 x float>
>  %50 = extractelement <4 x float> %bc7, i32 3
>  %51 = fadd float %37, %47
>  %52 = fadd float %38, %48
>  %53 = fadd float %39, %49
>  %54 = fadd float %40, %50
>  %55 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 0, !amdgpu.uniform !0
>  %56 = load <8 x i32>, <8 x i32> addrspace(2)* %55, align 32, !invariant.load !0
>  %57 = insertelement <4 x i32> undef, i32 %29, i32 0
>  %58 = insertelement <4 x i32> %57, i32 %30, i32 1
>  %59 = insertelement <4 x i32> %58, i32 2, i32 2
>  %60 = call <4 x i32> @llvm.SI.image.load.mip.v4i32(<4 x i32> %59, <8 x i32> %56, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %bc8 = bitcast <4 x i32> %60 to <4 x float>
>  %61 = extractelement <4 x float> %bc8, i32 0
>  %bc9 = bitcast <4 x i32> %60 to <4 x float>
>  %62 = extractelement <4 x float> %bc9, i32 1
>  %bc10 = bitcast <4 x i32> %60 to <4 x float>
>  %63 = extractelement <4 x float> %bc10, i32 2
>  %bc11 = bitcast <4 x i32> %60 to <4 x float>
>  %64 = extractelement <4 x float> %bc11, i32 3
>  %65 = fadd float %51, %61
>  %66 = fadd float %52, %62
>  %67 = fadd float %53, %63
>  %68 = fadd float %54, %64
>  %69 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 0, !amdgpu.uniform !0
>  %70 = load <8 x i32>, <8 x i32> addrspace(2)* %69, align 32, !invariant.load !0
>  %71 = insertelement <4 x i32> undef, i32 %29, i32 0
>  %72 = insertelement <4 x i32> %71, i32 %30, i32 1
>  %73 = insertelement <4 x i32> %72, i32 3, i32 2
>  %74 = call <4 x i32> @llvm.SI.image.load.mip.v4i32(<4 x i32> %73, <8 x i32> %70, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %bc12 = bitcast <4 x i32> %74 to <4 x float>
>  %75 = extractelement <4 x float> %bc12, i32 0
>  %bc13 = bitcast <4 x i32> %74 to <4 x float>
>  %76 = extractelement <4 x float> %bc13, i32 1
>  %bc14 = bitcast <4 x i32> %74 to <4 x float>
>  %77 = extractelement <4 x float> %bc14, i32 2
>  %bc15 = bitcast <4 x i32> %74 to <4 x float>
>  %78 = extractelement <4 x float> %bc15, i32 3
>  %79 = fadd float %65, %75
>  %80 = fadd float %66, %76
>  %81 = fadd float %67, %77
>  %82 = fadd float %68, %78
>  %83 = fmul float %79, 2.500000e-01
>  %84 = fmul float %80, 2.500000e-01
>  %85 = fmul float %81, 2.500000e-01
>  %86 = fmul float %82, 2.500000e-01
>  %87 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 2, !amdgpu.uniform !0
>  %88 = load <8 x i32>, <8 x i32> addrspace(2)* %87, align 32, !invariant.load !0
>  %89 = insertelement <4 x i32> undef, i32 %29, i32 0
>  %90 = insertelement <4 x i32> %89, i32 %30, i32 1
>  %91 = insertelement <4 x i32> %90, i32 0, i32 2
>  %92 = call <4 x i32> @llvm.SI.image.load.mip.v4i32(<4 x i32> %91, <8 x i32> %88, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %bc16 = bitcast <4 x i32> %92 to <4 x float>
>  %93 = extractelement <4 x float> %bc16, i32 0
>  %94 = bitcast float %5 to i32
>  %95 = insertvalue <{ i32, i32, 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 %94, 10
>  %96 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %95, float %83, 11
>  %97 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %96, float %84, 12
>  %98 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %97, float %85, 13
>  %99 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %98, float %86, 14
>  %100 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %99, float %93, 15
>  %101 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %100, float %21, 24
>  ret <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %101
>}
>
>; Function Attrs: nounwind readnone
>declare float @llvm.SI.load.const(<16 x i8>, i32) #1
>
>; Function Attrs: nounwind readnone
>declare <4 x i32> @llvm.SI.image.load.mip.v4i32(<4 x i32>, <8 x i32>, i32, i32, i32, i32, i32, i32, i32, i32) #1
>
>attributes #0 = { "InitialPSInputAddr"="36983" }
>attributes #1 = { nounwind readnone }
>
>!0 = !{}
>
>INFO: Program linked sucessfully: 3
>BookmarkManager::LoadBookmarks() - Loaded 14 bookmarks.
>qt.network.ssl: QSslSocket: cannot resolve SSLv3_client_method
>qt.network.ssl: QSslSocket: cannot resolve SSLv3_server_method
>MultiPlayerManager::MultiPlayerManager() - SSL enabled?  true
>Menu::LoadSettings(): File  "/home/chris/Dokumente/janusvr/appdata/settings.json"  can't be loaded, generating file.
>MainWindow::InitializeGame() - Anisotropic filtering supported, set to x 16
>FRAG
>DCL IN[0], GENERIC[0], LINEAR
>DCL OUT[0], COLOR
>DCL SAMP[0]
>DCL SVIEW[0], 2D, FLOAT
>  0: TEX OUT[0], IN[0], SAMP[0], 2D
>  1: END
>radeonsi: Compiling shader 3
>TGSI shader LLVM IR:
>
>; ModuleID = 'tgsi'
>source_filename = "tgsi"
>target triple = "amdgcn--"
>
>define amdgpu_ps <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> @main([17 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), [32 x <8 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <8 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <4 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), 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:
>  %23 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 0, !amdgpu.uniform !0
>  %24 = load <8 x i32>, <8 x i32> addrspace(2)* %23, align 32, !invariant.load !0
>  %25 = bitcast [32 x <8 x i32>] addrspace(2)* %2 to [0 x <4 x i32>] addrspace(2)*
>  %26 = getelementptr [0 x <4 x i32>], [0 x <4 x i32>] addrspace(2)* %25, i64 0, i64 3, !amdgpu.uniform !0
>  %27 = load <4 x i32>, <4 x i32> addrspace(2)* %26, align 16, !invariant.load !0
>  %28 = call float @llvm.SI.fs.interp(i32 0, i32 0, i32 %6, <2 x i32> %12)
>  %29 = call float @llvm.SI.fs.interp(i32 1, i32 0, i32 %6, <2 x i32> %12)
>  %30 = bitcast float %28 to i32
>  %31 = bitcast float %29 to i32
>  %32 = insertelement <2 x i32> undef, i32 %30, i32 0
>  %33 = insertelement <2 x i32> %32, i32 %31, i32 1
>  %34 = call <4 x float> @llvm.SI.image.sample.v2i32(<2 x i32> %33, <8 x i32> %24, <4 x i32> %27, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %35 = extractelement <4 x float> %34, i32 0
>  %36 = extractelement <4 x float> %34, i32 1
>  %37 = extractelement <4 x float> %34, i32 2
>  %38 = extractelement <4 x float> %34, i32 3
>  %39 = bitcast float %5 to i32
>  %40 = insertvalue <{ i32, i32, 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 %39, 10
>  %41 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %40, float %35, 11
>  %42 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %41, float %36, 12
>  %43 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %42, float %37, 13
>  %44 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %43, float %38, 14
>  %45 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %44, float %21, 24
>  ret <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> %45
>}
>
>; 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
>
>attributes #0 = { "InitialPSInputAddr"="36983" }
>attributes #1 = { nounwind readnone }
>
>!0 = !{}
>
>VERT
>PROPERTY NEXT_SHADER FRAG
>DCL IN[0]
>DCL IN[1]
>DCL OUT[0], POSITION
>DCL OUT[1], GENERIC[0]
>  0: MOV OUT[0], IN[0]
>  1: MOV OUT[1], IN[1]
>  2: END
>radeonsi: Compiling shader 4
>TGSI shader LLVM IR:
>
>; ModuleID = 'tgsi'
>source_filename = "tgsi"
>target triple = "amdgcn--"
>
>define amdgpu_vs <{ float, float, float }> @main([17 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), [32 x <8 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <8 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <4 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32, i32, i32, i32, i32, i32) {
>main_body:
>  %16 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 0, !amdgpu.uniform !0
>  %17 = load <16 x i8>, <16 x i8> addrspace(2)* %16, align 16, !invariant.load !0
>  %18 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %17, i32 0, i32 %14)
>  %19 = extractelement <4 x float> %18, i32 0
>  %20 = extractelement <4 x float> %18, i32 1
>  %21 = extractelement <4 x float> %18, i32 2
>  %22 = extractelement <4 x float> %18, i32 3
>  %23 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 1, !amdgpu.uniform !0
>  %24 = load <16 x i8>, <16 x i8> addrspace(2)* %23, align 16, !invariant.load !0
>  %25 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %24, i32 0, i32 %15)
>  %26 = extractelement <4 x float> %25, i32 0
>  %27 = extractelement <4 x float> %25, i32 1
>  %28 = extractelement <4 x float> %25, i32 2
>  %29 = extractelement <4 x float> %25, i32 3
>  %30 = bitcast i32 %12 to float
>  %31 = insertvalue <{ float, float, float }> undef, float %30, 2
>  call void @llvm.SI.export(i32 15, i32 0, i32 0, i32 32, i32 0, float %26, float %27, float %28, float %29)
>  call void @llvm.SI.export(i32 15, i32 0, i32 1, i32 12, i32 0, float %19, float %20, float %21, float %22)
>  ret <{ float, float, float }> %31
>}
>
>; Function Attrs: nounwind readnone
>declare <4 x float> @llvm.SI.vs.load.input(<16 x i8>, i32, i32) #0
>
>; Function Attrs: nounwind
>declare void @llvm.SI.export(i32, i32, i32, i32, i32, float, float, float, float) #1
>
>attributes #0 = { nounwind readnone }
>attributes #1 = { nounwind }
>
>!0 = !{}
>
>radeonsi: Compiling shader 5
>Vertex Shader Prolog LLVM IR:
>
>; ModuleID = 'tgsi'
>source_filename = "tgsi"
>target triple = "amdgcn--"
>
>define amdgpu_vs <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> @main(i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32, i32, i32, i32) {
>main_body:
>  %20 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> undef, i32 %0, 0
>  %21 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %20, i32 %1, 1
>  %22 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %21, i32 %2, 2
>  %23 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %22, i32 %3, 3
>  %24 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %23, i32 %4, 4
>  %25 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %24, i32 %5, 5
>  %26 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %25, i32 %6, 6
>  %27 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %26, i32 %7, 7
>  %28 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %27, i32 %8, 8
>  %29 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %28, i32 %9, 9
>  %30 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %29, i32 %10, 10
>  %31 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %30, i32 %11, 11
>  %32 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %31, i32 %12, 12
>  %33 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %32, i32 %13, 13
>  %34 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %33, i32 %14, 14
>  %35 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %34, i32 %15, 15
>  %36 = bitcast i32 %16 to float
>  %37 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %35, float %36, 16
>  %38 = bitcast i32 %17 to float
>  %39 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %37, float %38, 17
>  %40 = bitcast i32 %18 to float
>  %41 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %39, float %40, 18
>  %42 = bitcast i32 %19 to float
>  %43 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %41, float %42, 19
>  %44 = add i32 %16, %12
>  %45 = bitcast i32 %44 to float
>  %46 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %43, float %45, 20
>  %47 = add i32 %16, %12
>  %48 = bitcast i32 %47 to float
>  %49 = insertvalue <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %46, float %48, 21
>  ret <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float }> %49
>}
>
>radeonsi: Compiling shader 6
>Vertex Shader Epilog LLVM IR:
>
>; ModuleID = 'tgsi'
>source_filename = "tgsi"
>target triple = "amdgcn--"
>
>define amdgpu_vs void @main() {
>main_body:
>  ret void
>}
>
>SHADER KEY
>  instance_divisors = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
>  as_es = 0
>  as_ls = 0
>  export_prim_id = 0
>
>Vertex Shader as VS:
>Shader prolog disassembly:
>	v_add_i32_e32 v4, vcc, s12, v0 ; 3208000C
>	v_mov_b32_e32 v5, v4           ; 7E0A0304
>Shader main disassembly:
>	s_load_dwordx4 s[0:3], s[10:11], 0x0                  ; C00A0005 00000000
>	s_load_dwordx4 s[4:7], s[10:11], 0x10                 ; C00A0105 00000010
>	s_waitcnt lgkmcnt(0)                                  ; BF8C007F
>	buffer_load_format_xyzw v[6:9], v4, s[0:3], 0 idxen   ; E00C2000 80000604
>	s_nop 0                                               ; BF800000
>	buffer_load_format_xyzw v[10:13], v5, s[4:7], 0 idxen ; E00C2000 80010A05
>	s_waitcnt vmcnt(0)                                    ; BF8C0F70
>	exp 15, 32, 0, 0, 0, v10, v11, v12, v13               ; C400020F 0D0C0B0A
>	exp 15, 12, 0, 1, 0, v6, v7, v8, v9                   ; C40008CF 09080706
>	s_waitcnt expcnt(0)                                   ; BF8C0F0F
>Shader epilog disassembly:
>	s_endpgm ; BF810000
>
>*** SHADER STATS ***
>SGPRS: 24
>VGPRS: 16
>Spilled SGPRs: 0
>Spilled VGPRs: 0
>Code Size: 76 bytes
>LDS: 0 blocks
>Scratch: 0 bytes per wave
>Max Waves: 10
>********************
>
>
>radeonsi: Compiling shader 7
>Fragment Shader Epilog LLVM IR:
>
>; ModuleID = 'tgsi'
>source_filename = "tgsi"
>target triple = "amdgcn--"
>
>define amdgpu_ps void @main(i64 inreg, i64 inreg, i64 inreg, i64 inreg, i64 inreg, float inreg, float, float, float, float, float, float, float, float, float, float, float, float, float, float) #0 {
>main_body:
>  %20 = call i32 @llvm.SI.packf16(float %6, float %7)
>  %21 = bitcast i32 %20 to float
>  %22 = call i32 @llvm.SI.packf16(float %8, float %9)
>  %23 = bitcast i32 %22 to float
>  call void @llvm.SI.export(i32 15, i32 1, i32 1, i32 0, i32 1, float %21, float %23, float undef, float undef)
>  ret void
>}
>
>; Function Attrs: nounwind readnone
>declare i32 @llvm.SI.packf16(float, float) #1
>
>; Function Attrs: nounwind
>declare void @llvm.SI.export(i32, i32, i32, i32, i32, float, float, float, float) #2
>
>attributes #0 = { "InitialPSInputAddr"="16777215" }
>attributes #1 = { nounwind readnone }
>attributes #2 = { nounwind }
>
>SHADER KEY
>  prolog.color_two_side = 0
>  prolog.flatshade_colors = 0
>  prolog.poly_stipple = 0
>  prolog.force_persp_sample_interp = 0
>  prolog.force_linear_sample_interp = 0
>  prolog.force_persp_center_interp = 0
>  prolog.force_linear_center_interp = 0
>  prolog.bc_optimize_for_persp = 0
>  prolog.bc_optimize_for_linear = 0
>  epilog.spi_shader_col_format = 0x4
>  epilog.color_is_int8 = 0x0
>  epilog.last_cbuf = 0
>  epilog.alpha_func = 7
>  epilog.alpha_to_one = 0
>  epilog.poly_line_smoothing = 0
>  epilog.clamp_color = 0
>
>Pixel Shader:
>Shader main disassembly:
>	s_mov_b64 s[6:7], exec                                  ; BE86017E
>	s_wqm_b64 exec, exec                                    ; BEFE077E
>	s_load_dwordx8 s[12:19], s[4:5], 0x0                    ; C00E0302 00000000
>	s_load_dwordx4 s[0:3], s[4:5], 0x30                     ; C00A0002 00000030
>	s_mov_b32 m0, s11                                       ; BEFC000B
>	v_interp_p1_f32 v0, v8, 0, 0, [m0]                      ; D4000008
>	v_interp_p2_f32 v0, [v0], v9, 0, 0, [m0]                ; D4010009
>	v_interp_p1_f32 v1, v8, 1, 0, [m0]                      ; D4040108
>	v_interp_p2_f32 v1, [v1], v9, 1, 0, [m0]                ; D4050109
>	s_and_b64 exec, exec, s[6:7]                            ; 86FE067E
>	s_waitcnt lgkmcnt(0)                                    ; BF8C007F
>	image_sample v[0:3], v[0:1], s[12:19], s[0:3] dmask:0xf ; F0800F00 00030000
>	s_waitcnt vmcnt(0)                                      ; BF8C0F70
>Shader epilog disassembly:
>	v_cvt_pkrtz_f16_f32_e64 v0, v0, v1 ; D2960000 00020300
>	v_cvt_pkrtz_f16_f32_e64 v1, v2, v3 ; D2960001 00020702
>	exp 15, 0, 1, 1, 1, v0, v1, v0, v0 ; C4001C0F 00000100
>	s_endpgm                           ; BF810000
>
>*** SHADER CONFIG ***
>SPI_PS_INPUT_ADDR = 0xd077
>SPI_PS_INPUT_ENA  = 0x0020
>*** SHADER STATS ***
>SGPRS: 24
>VGPRS: 16
>Spilled SGPRs: 0
>Spilled VGPRs: 0
>Code Size: 92 bytes
>LDS: 0 blocks
>Scratch: 0 bytes per wave
>Max Waves: 10
>********************
>
>
>HMD/render type: ""
>GLWidget::initializeGL - Initializing sound manager...
>Cannot connect to server socket err = Datei oder Verzeichnis nicht gefunden
>Cannot connect to server request channel
>jack server is not running or cannot be started
>SoundManager::Load() - No errors
>GLWidget::initializeGL - Done!
>main(): writing settings to path "/home/chris/Dokumente/janusvr/appdata/"
>Janus VR version: "53.5" Version online: "53.5" WebKit version: "538.1"
>VERT
>PROPERTY NEXT_SHADER FRAG
>DCL IN[0]
>DCL IN[1]
>DCL IN[2]
>DCL IN[3]
>DCL IN[4]
>DCL IN[5]
>DCL IN[6]
>DCL IN[7]
>DCL IN[8]
>DCL IN[9]
>DCL IN[10]
>DCL IN[11]
>DCL OUT[0], POSITION
>DCL OUT[1], GENERIC[0]
>DCL OUT[2], GENERIC[1]
>DCL OUT[3], GENERIC[2]
>DCL OUT[4], GENERIC[3]
>DCL OUT[5], GENERIC[4]
>DCL OUT[6], GENERIC[5]
>DCL CONST[0..533]
>DCL TEMP[0..8], LOCAL
>DCL ADDR[0]
>IMM[0] FLT32 {    1.0000,     0.0000,     0.0000,     0.0000}
>IMM[1] INT32 {0, 4, 0, 0}
>  0: MOV TEMP[0].xyz, IN[0].xyzx
>  1: MOV TEMP[1].xyz, IN[1].xyzx
>  2: FSEQ TEMP[2].x, CONST[21].xxxx, IMM[0].xxxx
>  3: UIF TEMP[2].xxxx :0
>  4:   F2I TEMP[2].x, IN[10].xxxx
>  5:   ISGE TEMP[3].x, TEMP[2].xxxx, IMM[1].xxxx
>  6:   UIF TEMP[3].xxxx :0
>  7:     UMUL TEMP[3].x, TEMP[2].xxxx, IMM[1].yyyy
>  8:     UMUL TEMP[4].x, TEMP[2].xxxx, IMM[1].yyyy
>  9:     UMUL TEMP[5].x, TEMP[2].xxxx, IMM[1].yyyy
> 10:     UARL ADDR[0].x, TEMP[5].xxxx
> 11:     MUL TEMP[5], CONST[ADDR[0].x+22], IN[0].xxxx
> 12:     UARL ADDR[0].x, TEMP[4].xxxx
> 13:     MAD TEMP[4], CONST[ADDR[0].x+23], IN[0].yyyy, TEMP[5]
> 14:     UARL ADDR[0].x, TEMP[3].xxxx
> 15:     MAD TEMP[3], CONST[ADDR[0].x+24], IN[0].zzzz, TEMP[4]
> 16:     UMUL TEMP[4].x, TEMP[2].xxxx, IMM[1].yyyy
> 17:     UARL ADDR[0].x, TEMP[4].xxxx
> 18:     ADD TEMP[3].xyz, TEMP[3], CONST[ADDR[0].x+25]
> 19:     MUL TEMP[0].xyz, TEMP[3].xyzz, IN[11].xxxx
> 20:     UMUL TEMP[3].x, TEMP[2].xxxx, IMM[1].yyyy
> 21:     UMUL TEMP[4].x, TEMP[2].xxxx, IMM[1].yyyy
> 22:     UMUL TEMP[5].x, TEMP[2].xxxx, IMM[1].yyyy
> 23:     UARL ADDR[0].x, TEMP[5].xxxx
> 24:     MUL TEMP[5], CONST[ADDR[0].x+22], IN[1].xxxx
> 25:     UARL ADDR[0].x, TEMP[4].xxxx
> 26:     MAD TEMP[4], CONST[ADDR[0].x+23], IN[1].yyyy, TEMP[5]
> 27:     UARL ADDR[0].x, TEMP[3].xxxx
> 28:     MAD TEMP[3].xyz, CONST[ADDR[0].x+24], IN[1].zzzz, TEMP[4]
> 29:     MUL TEMP[1].xyz, TEMP[3].xyzz, IN[11].xxxx
> 30:   ENDIF
> 31:   F2I TEMP[2].x, IN[10].yyyy
> 32:   ISGE TEMP[3].x, TEMP[2].xxxx, IMM[1].xxxx
> 33:   UIF TEMP[3].xxxx :0
> 34:     UMUL TEMP[3].x, TEMP[2].xxxx, IMM[1].yyyy
> 35:     UMUL TEMP[4].x, TEMP[2].xxxx, IMM[1].yyyy
> 36:     UMUL TEMP[5].x, TEMP[2].xxxx, IMM[1].yyyy
> 37:     UARL ADDR[0].x, TEMP[5].xxxx
> 38:     MUL TEMP[5], CONST[ADDR[0].x+22], IN[0].xxxx
> 39:     UARL ADDR[0].x, TEMP[4].xxxx
> 40:     MAD TEMP[4], CONST[ADDR[0].x+23], IN[0].yyyy, TEMP[5]
> 41:     UARL ADDR[0].x, TEMP[3].xxxx
> 42:     MAD TEMP[3], CONST[ADDR[0].x+24], IN[0].zzzz, TEMP[4]
> 43:     UMUL TEMP[4].x, TEMP[2].xxxx, IMM[1].yyyy
> 44:     UARL ADDR[0].x, TEMP[4].xxxx
> 45:     ADD TEMP[3].xyz, TEMP[3], CONST[ADDR[0].x+25]
> 46:     MAD TEMP[0].xyz, TEMP[3].xyzz, IN[11].yyyy, TEMP[0].xyzz
> 47:     UMUL TEMP[3].x, TEMP[2].xxxx, IMM[1].yyyy
> 48:     UMUL TEMP[4].x, TEMP[2].xxxx, IMM[1].yyyy
> 49:     UMUL TEMP[5].x, TEMP[2].xxxx, IMM[1].yyyy
> 50:     UARL ADDR[0].x, TEMP[5].xxxx
> 51:     MUL TEMP[5], CONST[ADDR[0].x+22], IN[1].xxxx
> 52:     UARL ADDR[0].x, TEMP[4].xxxx
> 53:     MAD TEMP[4], CONST[ADDR[0].x+23], IN[1].yyyy, TEMP[5]
> 54:     UARL ADDR[0].x, TEMP[3].xxxx
> 55:     MAD TEMP[3].xyz, CONST[ADDR[0].x+24], IN[1].zzzz, TEMP[4]
> 56:     MAD TEMP[1].xyz, TEMP[3].xyzz, IN[11].yyyy, TEMP[1].xyzz
> 57:   ENDIF
> 58:   F2I TEMP[2].x, IN[10].zzzz
> 59:   ISGE TEMP[3].x, TEMP[2].xxxx, IMM[1].xxxx
> 60:   UIF TEMP[3].xxxx :0
> 61:     UMUL TEMP[3].x, TEMP[2].xxxx, IMM[1].yyyy
> 62:     UMUL TEMP[4].x, TEMP[2].xxxx, IMM[1].yyyy
> 63:     UMUL TEMP[5].x, TEMP[2].xxxx, IMM[1].yyyy
> 64:     UARL ADDR[0].x, TEMP[5].xxxx
> 65:     MUL TEMP[5], CONST[ADDR[0].x+22], IN[0].xxxx
> 66:     UARL ADDR[0].x, TEMP[4].xxxx
> 67:     MAD TEMP[4], CONST[ADDR[0].x+23], IN[0].yyyy, TEMP[5]
> 68:     UARL ADDR[0].x, TEMP[3].xxxx
> 69:     MAD TEMP[3], CONST[ADDR[0].x+24], IN[0].zzzz, TEMP[4]
> 70:     UMUL TEMP[4].x, TEMP[2].xxxx, IMM[1].yyyy
> 71:     UARL ADDR[0].x, TEMP[4].xxxx
> 72:     ADD TEMP[3].xyz, TEMP[3], CONST[ADDR[0].x+25]
> 73:     MAD TEMP[0].xyz, TEMP[3].xyzz, IN[11].zzzz, TEMP[0].xyzz
> 74:     UMUL TEMP[3].x, TEMP[2].xxxx, IMM[1].yyyy
> 75:     UMUL TEMP[4].x, TEMP[2].xxxx, IMM[1].yyyy
> 76:     UMUL TEMP[5].x, TEMP[2].xxxx, IMM[1].yyyy
> 77:     UARL ADDR[0].x, TEMP[5].xxxx
> 78:     MUL TEMP[5], CONST[ADDR[0].x+22], IN[1].xxxx
> 79:     UARL ADDR[0].x, TEMP[4].xxxx
> 80:     MAD TEMP[4], CONST[ADDR[0].x+23], IN[1].yyyy, TEMP[5]
> 81:     UARL ADDR[0].x, TEMP[3].xxxx
> 82:     MAD TEMP[3].xyz, CONST[ADDR[0].x+24], IN[1].zzzz, TEMP[4]
> 83:     MAD TEMP[1].xyz, TEMP[3].xyzz, IN[11].zzzz, TEMP[1].xyzz
> 84:   ENDIF
> 85:   F2I TEMP[2].x, IN[10].wwww
> 86:   ISGE TEMP[3].x, TEMP[2].xxxx, IMM[1].xxxx
> 87:   UIF TEMP[3].xxxx :0
> 88:     UMUL TEMP[3].x, TEMP[2].xxxx, IMM[1].yyyy
> 89:     UMUL TEMP[4].x, TEMP[2].xxxx, IMM[1].yyyy
> 90:     UMUL TEMP[5].x, TEMP[2].xxxx, IMM[1].yyyy
> 91:     UARL ADDR[0].x, TEMP[5].xxxx
> 92:     MUL TEMP[5], CONST[ADDR[0].x+22], IN[0].xxxx
> 93:     UARL ADDR[0].x, TEMP[4].xxxx
> 94:     MAD TEMP[4], CONST[ADDR[0].x+23], IN[0].yyyy, TEMP[5]
> 95:     UARL ADDR[0].x, TEMP[3].xxxx
> 96:     MAD TEMP[3], CONST[ADDR[0].x+24], IN[0].zzzz, TEMP[4]
> 97:     UMUL TEMP[4].x, TEMP[2].xxxx, IMM[1].yyyy
> 98:     UARL ADDR[0].x, TEMP[4].xxxx
> 99:     ADD TEMP[3].xyz, TEMP[3], CONST[ADDR[0].x+25]
>100:     MAD TEMP[0].xyz, TEMP[3].xyzz, IN[11].wwww, TEMP[0].xyzz
>101:     UMUL TEMP[3].x, TEMP[2].xxxx, IMM[1].yyyy
>102:     UMUL TEMP[4].x, TEMP[2].xxxx, IMM[1].yyyy
>103:     UMUL TEMP[2].x, TEMP[2].xxxx, IMM[1].yyyy
>104:     UARL ADDR[0].x, TEMP[2].xxxx
>105:     MUL TEMP[2], CONST[ADDR[0].x+22], IN[1].xxxx
>106:     UARL ADDR[0].x, TEMP[4].xxxx
>107:     MAD TEMP[2], CONST[ADDR[0].x+23], IN[1].yyyy, TEMP[2]
>108:     UARL ADDR[0].x, TEMP[3].xxxx
>109:     MAD TEMP[2].xyz, CONST[ADDR[0].x+24], IN[1].zzzz, TEMP[2]
>110:     MAD TEMP[1].xyz, TEMP[2].xyzz, IN[11].wwww, TEMP[1].xyzz
>111:   ENDIF
>112: ELSE :0
>113:   ADD TEMP[2].xyz, IN[4].xyzz, -IN[0].xyzz
>114:   MAD TEMP[0].xyz, TEMP[2].xyzz, CONST[20].xxxx, TEMP[0].xyzz
>115:   ADD TEMP[2].xyz, IN[7].xyzz, -IN[1].xyzz
>116:   MAD TEMP[1].xyz, TEMP[2].xyzz, CONST[20].xxxx, TEMP[1].xyzz
>117:   ADD TEMP[2].xyz, IN[5].xyzz, -IN[0].xyzz
>118:   MAD TEMP[0].xyz, TEMP[2].xyzz, CONST[20].yyyy, TEMP[0].xyzz
>119:   ADD TEMP[2].xyz, IN[8].xyzz, -IN[1].xyzz
>120:   MAD TEMP[1].xyz, TEMP[2].xyzz, CONST[20].yyyy, TEMP[1].xyzz
>121:   ADD TEMP[2].xyz, IN[6].xyzz, -IN[0].xyzz
>122:   MAD TEMP[0].xyz, TEMP[2].xyzz, CONST[20].zzzz, TEMP[0].xyzz
>123:   ADD TEMP[2].xyz, IN[9].xyzz, -IN[1].xyzz
>124:   MAD TEMP[1].xyz, TEMP[2].xyzz, CONST[20].zzzz, TEMP[1].xyzz
>125: ENDIF
>126: DP3 TEMP[2].x, TEMP[1].xyzz, TEMP[1].xyzz
>127: RSQ TEMP[2].x, TEMP[2].xxxx
>128: MUL TEMP[1].xyz, TEMP[1].xyzz, TEMP[2].xxxx
>129: MUL TEMP[2], CONST[0], TEMP[0].xxxx
>130: MAD TEMP[2], CONST[1], TEMP[0].yyyy, TEMP[2]
>131: MAD TEMP[2], CONST[2], TEMP[0].zzzz, TEMP[2]
>132: ADD TEMP[2].xyz, TEMP[2], CONST[3]
>133: MUL TEMP[3], CONST[12], TEMP[1].xxxx
>134: MAD TEMP[3], CONST[13], TEMP[1].yyyy, TEMP[3]
>135: MAD TEMP[3].xyz, CONST[14], TEMP[1].zzzz, TEMP[3]
>136: MUL TEMP[4], CONST[16], TEMP[1].xxxx
>137: MAD TEMP[4], CONST[17], TEMP[1].yyyy, TEMP[4]
>138: MAD TEMP[4].xyz, CONST[18], TEMP[1].zzzz, TEMP[4]
>139: MOV TEMP[5].x, IN[2].xxxx
>140: ADD TEMP[6].x, IMM[0].xxxx, -IN[2].yyyy
>141: MOV TEMP[5].y, TEMP[6].xxxx
>142: MOV TEMP[6].x, IN[3].xxxx
>143: ADD TEMP[7].x, IMM[0].xxxx, -IN[3].yyyy
>144: MOV TEMP[6].y, TEMP[7].xxxx
>145: MUL TEMP[7], CONST[8], TEMP[0].xxxx
>146: MAD TEMP[7], CONST[9], TEMP[0].yyyy, TEMP[7]
>147: MAD TEMP[7], CONST[10], TEMP[0].zzzz, TEMP[7]
>148: ADD TEMP[7], TEMP[7], CONST[11]
>149: MOV TEMP[1].xyz, TEMP[1].xyzx
>150: MOV TEMP[1].w, TEMP[4].xxxx
>151: MOV TEMP[4].xy, TEMP[4].yzyy
>152: MOV TEMP[4].zw, TEMP[3].yyxy
>153: MOV TEMP[3].x, TEMP[3].zzzz
>154: MOV TEMP[3].yzw, TEMP[0].yxyz
>155: MUL TEMP[8], CONST[4], TEMP[0].xxxx
>156: MAD TEMP[8], CONST[5], TEMP[0].yyyy, TEMP[8]
>157: MAD TEMP[0], CONST[6], TEMP[0].zzzz, TEMP[8]
>158: ADD TEMP[0].xyz, TEMP[0], CONST[7]
>159: MOV TEMP[0].xyz, TEMP[0].xyzx
>160: MOV TEMP[0].w, TEMP[2].xxxx
>161: MOV TEMP[2].xy, TEMP[2].yzyy
>162: MOV TEMP[5].xy, TEMP[5].xyxx
>163: MOV TEMP[5].zw, TEMP[6].yyxy
>164: MOV OUT[5], TEMP[0]
>165: MOV OUT[3], TEMP[4]
>166: MOV OUT[2], TEMP[1]
>167: MOV OUT[0], TEMP[7]
>168: MOV OUT[6], TEMP[2]
>169: MOV OUT[1], TEMP[5]
>170: MOV OUT[4], TEMP[3]
>171: END
>radeonsi: Compiling shader 8
>TGSI shader LLVM IR:
>
>; ModuleID = 'tgsi'
>source_filename = "tgsi"
>target triple = "amdgcn--"
>
>define amdgpu_vs <{ float, float, float }> @main([17 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), [32 x <8 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <8 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <4 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), i32 inreg, i32 inreg, i32 inreg, i32 inreg, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32) {
>main_body:
>  %26 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 0, !amdgpu.uniform !0
>  %27 = load <16 x i8>, <16 x i8> addrspace(2)* %26, align 16, !invariant.load !0
>  %28 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %27, i32 0, i32 %14)
>  %29 = extractelement <4 x float> %28, i32 0
>  %30 = extractelement <4 x float> %28, i32 1
>  %31 = extractelement <4 x float> %28, i32 2
>  %32 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 1, !amdgpu.uniform !0
>  %33 = load <16 x i8>, <16 x i8> addrspace(2)* %32, align 16, !invariant.load !0
>  %34 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %33, i32 0, i32 %15)
>  %35 = extractelement <4 x float> %34, i32 0
>  %36 = extractelement <4 x float> %34, i32 1
>  %37 = extractelement <4 x float> %34, i32 2
>  %38 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 2, !amdgpu.uniform !0
>  %39 = load <16 x i8>, <16 x i8> addrspace(2)* %38, align 16, !invariant.load !0
>  %40 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %39, i32 0, i32 %16)
>  %41 = extractelement <4 x float> %40, i32 0
>  %42 = extractelement <4 x float> %40, i32 1
>  %43 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 3, !amdgpu.uniform !0
>  %44 = load <16 x i8>, <16 x i8> addrspace(2)* %43, align 16, !invariant.load !0
>  %45 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %44, i32 0, i32 %17)
>  %46 = extractelement <4 x float> %45, i32 0
>  %47 = extractelement <4 x float> %45, i32 1
>  %48 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 4, !amdgpu.uniform !0
>  %49 = load <16 x i8>, <16 x i8> addrspace(2)* %48, align 16, !invariant.load !0
>  %50 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %49, i32 0, i32 %18)
>  %51 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 5, !amdgpu.uniform !0
>  %52 = load <16 x i8>, <16 x i8> addrspace(2)* %51, align 16, !invariant.load !0
>  %53 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %52, i32 0, i32 %19)
>  %54 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 6, !amdgpu.uniform !0
>  %55 = load <16 x i8>, <16 x i8> addrspace(2)* %54, align 16, !invariant.load !0
>  %56 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %55, i32 0, i32 %20)
>  %57 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 7, !amdgpu.uniform !0
>  %58 = load <16 x i8>, <16 x i8> addrspace(2)* %57, align 16, !invariant.load !0
>  %59 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %58, i32 0, i32 %21)
>  %60 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 8, !amdgpu.uniform !0
>  %61 = load <16 x i8>, <16 x i8> addrspace(2)* %60, align 16, !invariant.load !0
>  %62 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %61, i32 0, i32 %22)
>  %63 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 9, !amdgpu.uniform !0
>  %64 = load <16 x i8>, <16 x i8> addrspace(2)* %63, align 16, !invariant.load !0
>  %65 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %64, i32 0, i32 %23)
>  %66 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 10, !amdgpu.uniform !0
>  %67 = load <16 x i8>, <16 x i8> addrspace(2)* %66, align 16, !invariant.load !0
>  %68 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %67, i32 0, i32 %24)
>  %69 = extractelement <4 x float> %68, i32 1
>  %70 = extractelement <4 x float> %68, i32 2
>  %71 = extractelement <4 x float> %68, i32 3
>  %72 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %5, i64 0, i64 11, !amdgpu.uniform !0
>  %73 = load <16 x i8>, <16 x i8> addrspace(2)* %72, align 16, !invariant.load !0
>  %74 = call <4 x float> @llvm.SI.vs.load.input(<16 x i8> %73, i32 0, i32 %25)
>  %75 = extractelement <4 x float> %74, i32 0
>  %76 = extractelement <4 x float> %74, i32 1
>  %77 = extractelement <4 x float> %74, i32 2
>  %78 = extractelement <4 x float> %74, i32 3
>  %79 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %80 = load <16 x i8>, <16 x i8> addrspace(2)* %79, align 16, !invariant.load !0
>  %81 = call float @llvm.SI.load.const(<16 x i8> %80, i32 336)
>  %82 = fcmp oeq float %81, 1.000000e+00
>  br i1 %82, label %IF, label %ELSE
>
>IF:                                               ; preds = %main_body
>  %83 = extractelement <4 x float> %68, i32 0
>  %84 = fptosi float %83 to i32
>  %85 = icmp sgt i32 %84, -1
>  br i1 %85, label %IF2, label %ENDIF1
>
>ELSE:                                             ; preds = %main_body
>  %86 = extractelement <4 x float> %65, i32 2
>  %87 = extractelement <4 x float> %65, i32 1
>  %88 = extractelement <4 x float> %65, i32 0
>  %89 = extractelement <4 x float> %62, i32 2
>  %90 = extractelement <4 x float> %62, i32 1
>  %91 = extractelement <4 x float> %62, i32 0
>  %92 = extractelement <4 x float> %59, i32 2
>  %93 = extractelement <4 x float> %59, i32 1
>  %94 = extractelement <4 x float> %59, i32 0
>  %95 = extractelement <4 x float> %56, i32 2
>  %96 = extractelement <4 x float> %56, i32 1
>  %97 = extractelement <4 x float> %56, i32 0
>  %98 = extractelement <4 x float> %53, i32 2
>  %99 = extractelement <4 x float> %53, i32 1
>  %100 = extractelement <4 x float> %53, i32 0
>  %101 = extractelement <4 x float> %50, i32 2
>  %102 = extractelement <4 x float> %50, i32 1
>  %103 = extractelement <4 x float> %50, i32 0
>  %104 = fsub float %103, %29
>  %105 = fsub float %102, %30
>  %106 = fsub float %101, %31
>  %107 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %108 = load <16 x i8>, <16 x i8> addrspace(2)* %107, align 16, !invariant.load !0
>  %109 = call float @llvm.SI.load.const(<16 x i8> %108, i32 320)
>  %110 = fmul float %104, %109
>  %111 = fadd float %110, %29
>  %112 = call float @llvm.SI.load.const(<16 x i8> %108, i32 320)
>  %113 = fmul float %105, %112
>  %114 = fadd float %113, %30
>  %115 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %116 = load <16 x i8>, <16 x i8> addrspace(2)* %115, align 16, !invariant.load !0
>  %117 = call float @llvm.SI.load.const(<16 x i8> %116, i32 320)
>  %118 = fmul float %106, %117
>  %119 = fadd float %118, %31
>  %120 = fsub float %94, %35
>  %121 = fsub float %93, %36
>  %122 = fsub float %92, %37
>  %123 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %124 = load <16 x i8>, <16 x i8> addrspace(2)* %123, align 16, !invariant.load !0
>  %125 = call float @llvm.SI.load.const(<16 x i8> %124, i32 320)
>  %126 = fmul float %120, %125
>  %127 = fadd float %126, %35
>  %128 = call float @llvm.SI.load.const(<16 x i8> %124, i32 320)
>  %129 = fmul float %121, %128
>  %130 = fadd float %129, %36
>  %131 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %132 = load <16 x i8>, <16 x i8> addrspace(2)* %131, align 16, !invariant.load !0
>  %133 = call float @llvm.SI.load.const(<16 x i8> %132, i32 320)
>  %134 = fmul float %122, %133
>  %135 = fadd float %134, %37
>  %136 = fsub float %100, %29
>  %137 = fsub float %99, %30
>  %138 = fsub float %98, %31
>  %139 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %140 = load <16 x i8>, <16 x i8> addrspace(2)* %139, align 16, !invariant.load !0
>  %141 = call float @llvm.SI.load.const(<16 x i8> %140, i32 324)
>  %142 = fmul float %136, %141
>  %143 = fadd float %142, %111
>  %144 = call float @llvm.SI.load.const(<16 x i8> %140, i32 324)
>  %145 = fmul float %137, %144
>  %146 = fadd float %145, %114
>  %147 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %148 = load <16 x i8>, <16 x i8> addrspace(2)* %147, align 16, !invariant.load !0
>  %149 = call float @llvm.SI.load.const(<16 x i8> %148, i32 324)
>  %150 = fmul float %138, %149
>  %151 = fadd float %150, %119
>  %152 = fsub float %91, %35
>  %153 = fsub float %90, %36
>  %154 = fsub float %89, %37
>  %155 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %156 = load <16 x i8>, <16 x i8> addrspace(2)* %155, align 16, !invariant.load !0
>  %157 = call float @llvm.SI.load.const(<16 x i8> %156, i32 324)
>  %158 = fmul float %152, %157
>  %159 = fadd float %158, %127
>  %160 = call float @llvm.SI.load.const(<16 x i8> %156, i32 324)
>  %161 = fmul float %153, %160
>  %162 = fadd float %161, %130
>  %163 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %164 = load <16 x i8>, <16 x i8> addrspace(2)* %163, align 16, !invariant.load !0
>  %165 = call float @llvm.SI.load.const(<16 x i8> %164, i32 324)
>  %166 = fmul float %154, %165
>  %167 = fadd float %166, %135
>  %168 = fsub float %97, %29
>  %169 = fsub float %96, %30
>  %170 = fsub float %95, %31
>  %171 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %172 = load <16 x i8>, <16 x i8> addrspace(2)* %171, align 16, !invariant.load !0
>  %173 = call float @llvm.SI.load.const(<16 x i8> %172, i32 328)
>  %174 = fmul float %168, %173
>  %175 = fadd float %174, %143
>  %176 = call float @llvm.SI.load.const(<16 x i8> %172, i32 328)
>  %177 = fmul float %169, %176
>  %178 = fadd float %177, %146
>  %179 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %180 = load <16 x i8>, <16 x i8> addrspace(2)* %179, align 16, !invariant.load !0
>  %181 = call float @llvm.SI.load.const(<16 x i8> %180, i32 328)
>  %182 = fmul float %170, %181
>  %183 = fadd float %182, %151
>  %184 = fsub float %88, %35
>  %185 = fsub float %87, %36
>  %186 = fsub float %86, %37
>  %187 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %188 = load <16 x i8>, <16 x i8> addrspace(2)* %187, align 16, !invariant.load !0
>  %189 = call float @llvm.SI.load.const(<16 x i8> %188, i32 328)
>  %190 = fmul float %184, %189
>  %191 = fadd float %190, %159
>  %192 = call float @llvm.SI.load.const(<16 x i8> %188, i32 328)
>  %193 = fmul float %185, %192
>  %194 = fadd float %193, %162
>  %195 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %196 = load <16 x i8>, <16 x i8> addrspace(2)* %195, align 16, !invariant.load !0
>  %197 = call float @llvm.SI.load.const(<16 x i8> %196, i32 328)
>  %198 = fmul float %186, %197
>  %199 = fadd float %198, %167
>  br label %ENDIF
>
>ENDIF:                                            ; preds = %IF88, %ENDIF58, %ELSE
>  %.0136 = phi float [ %199, %ELSE ], [ %967, %IF88 ], [ %.3139, %ENDIF58 ]
>  %.0131 = phi float [ %194, %ELSE ], [ %965, %IF88 ], [ %.3134, %ENDIF58 ]
>  %.0126 = phi float [ %191, %ELSE ], [ %963, %IF88 ], [ %.3129, %ENDIF58 ]
>  %.0121 = phi float [ %183, %ELSE ], [ %907, %IF88 ], [ %.3124, %ENDIF58 ]
>  %.0116 = phi float [ %178, %ELSE ], [ %905, %IF88 ], [ %.3119, %ENDIF58 ]
>  %.0 = phi float [ %175, %ELSE ], [ %903, %IF88 ], [ %.3, %ENDIF58 ]
>  %200 = fmul float %.0126, %.0126
>  %201 = fmul float %.0131, %.0131
>  %202 = fadd float %201, %200
>  %203 = fmul float %.0136, %.0136
>  %204 = fadd float %202, %203
>  %205 = call float @llvm.sqrt.f32(float %204)
>  %206 = fdiv float 1.000000e+00, %205, !fpmath !1
>  %207 = fmul float %.0126, %206
>  %208 = fmul float %.0131, %206
>  %209 = fmul float %.0136, %206
>  %210 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %211 = load <16 x i8>, <16 x i8> addrspace(2)* %210, align 16, !invariant.load !0
>  %212 = call float @llvm.SI.load.const(<16 x i8> %211, i32 0)
>  %213 = fmul float %212, %.0
>  %214 = call float @llvm.SI.load.const(<16 x i8> %211, i32 4)
>  %215 = fmul float %214, %.0
>  %216 = call float @llvm.SI.load.const(<16 x i8> %211, i32 8)
>  %217 = fmul float %216, %.0
>  %218 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %219 = load <16 x i8>, <16 x i8> addrspace(2)* %218, align 16, !invariant.load !0
>  %220 = call float @llvm.SI.load.const(<16 x i8> %219, i32 12)
>  %221 = fmul float %220, %.0
>  %222 = call float @llvm.SI.load.const(<16 x i8> %219, i32 16)
>  %223 = fmul float %222, %.0116
>  %224 = fadd float %223, %213
>  %225 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %226 = load <16 x i8>, <16 x i8> addrspace(2)* %225, align 16, !invariant.load !0
>  %227 = call float @llvm.SI.load.const(<16 x i8> %226, i32 20)
>  %228 = fmul float %227, %.0116
>  %229 = fadd float %228, %215
>  %230 = call float @llvm.SI.load.const(<16 x i8> %226, i32 24)
>  %231 = fmul float %230, %.0116
>  %232 = fadd float %231, %217
>  %233 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %234 = load <16 x i8>, <16 x i8> addrspace(2)* %233, align 16, !invariant.load !0
>  %235 = call float @llvm.SI.load.const(<16 x i8> %234, i32 28)
>  %236 = fmul float %235, %.0116
>  %237 = fadd float %236, %221
>  %238 = call float @llvm.SI.load.const(<16 x i8> %234, i32 32)
>  %239 = fmul float %238, %.0121
>  %240 = fadd float %239, %224
>  %241 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %242 = load <16 x i8>, <16 x i8> addrspace(2)* %241, align 16, !invariant.load !0
>  %243 = call float @llvm.SI.load.const(<16 x i8> %242, i32 36)
>  %244 = fmul float %243, %.0121
>  %245 = fadd float %244, %229
>  %246 = call float @llvm.SI.load.const(<16 x i8> %242, i32 40)
>  %247 = fmul float %246, %.0121
>  %248 = fadd float %247, %232
>  %249 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %250 = load <16 x i8>, <16 x i8> addrspace(2)* %249, align 16, !invariant.load !0
>  %251 = call float @llvm.SI.load.const(<16 x i8> %250, i32 44)
>  %252 = fmul float %251, %.0121
>  %253 = fadd float %252, %237
>  %254 = call float @llvm.SI.load.const(<16 x i8> %250, i32 48)
>  %255 = fadd float %240, %254
>  %256 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %257 = load <16 x i8>, <16 x i8> addrspace(2)* %256, align 16, !invariant.load !0
>  %258 = call float @llvm.SI.load.const(<16 x i8> %257, i32 52)
>  %259 = fadd float %245, %258
>  %260 = call float @llvm.SI.load.const(<16 x i8> %257, i32 56)
>  %261 = fadd float %248, %260
>  %262 = call float @llvm.SI.load.const(<16 x i8> %257, i32 192)
>  %263 = fmul float %262, %207
>  %264 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %265 = load <16 x i8>, <16 x i8> addrspace(2)* %264, align 16, !invariant.load !0
>  %266 = call float @llvm.SI.load.const(<16 x i8> %265, i32 196)
>  %267 = fmul float %266, %207
>  %268 = call float @llvm.SI.load.const(<16 x i8> %265, i32 200)
>  %269 = fmul float %268, %207
>  %270 = call float @llvm.SI.load.const(<16 x i8> %265, i32 208)
>  %271 = fmul float %270, %208
>  %272 = fadd float %271, %263
>  %273 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %274 = load <16 x i8>, <16 x i8> addrspace(2)* %273, align 16, !invariant.load !0
>  %275 = call float @llvm.SI.load.const(<16 x i8> %274, i32 212)
>  %276 = fmul float %275, %208
>  %277 = fadd float %276, %267
>  %278 = call float @llvm.SI.load.const(<16 x i8> %274, i32 216)
>  %279 = fmul float %278, %208
>  %280 = fadd float %279, %269
>  %281 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %282 = load <16 x i8>, <16 x i8> addrspace(2)* %281, align 16, !invariant.load !0
>  %283 = call float @llvm.SI.load.const(<16 x i8> %282, i32 224)
>  %284 = fmul float %283, %209
>  %285 = fadd float %284, %272
>  %286 = call float @llvm.SI.load.const(<16 x i8> %282, i32 228)
>  %287 = fmul float %286, %209
>  %288 = fadd float %287, %277
>  %289 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %290 = load <16 x i8>, <16 x i8> addrspace(2)* %289, align 16, !invariant.load !0
>  %291 = call float @llvm.SI.load.const(<16 x i8> %290, i32 232)
>  %292 = fmul float %291, %209
>  %293 = fadd float %292, %280
>  %294 = call float @llvm.SI.load.const(<16 x i8> %290, i32 256)
>  %295 = fmul float %294, %207
>  %296 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %297 = load <16 x i8>, <16 x i8> addrspace(2)* %296, align 16, !invariant.load !0
>  %298 = call float @llvm.SI.load.const(<16 x i8> %297, i32 260)
>  %299 = fmul float %298, %207
>  %300 = call float @llvm.SI.load.const(<16 x i8> %297, i32 264)
>  %301 = fmul float %300, %207
>  %302 = call float @llvm.SI.load.const(<16 x i8> %297, i32 272)
>  %303 = fmul float %302, %208
>  %304 = fadd float %303, %295
>  %305 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %306 = load <16 x i8>, <16 x i8> addrspace(2)* %305, align 16, !invariant.load !0
>  %307 = call float @llvm.SI.load.const(<16 x i8> %306, i32 276)
>  %308 = fmul float %307, %208
>  %309 = fadd float %308, %299
>  %310 = call float @llvm.SI.load.const(<16 x i8> %306, i32 280)
>  %311 = fmul float %310, %208
>  %312 = fadd float %311, %301
>  %313 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %314 = load <16 x i8>, <16 x i8> addrspace(2)* %313, align 16, !invariant.load !0
>  %315 = call float @llvm.SI.load.const(<16 x i8> %314, i32 288)
>  %316 = fmul float %315, %209
>  %317 = fadd float %316, %304
>  %318 = call float @llvm.SI.load.const(<16 x i8> %314, i32 292)
>  %319 = fmul float %318, %209
>  %320 = fadd float %319, %309
>  %321 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %322 = load <16 x i8>, <16 x i8> addrspace(2)* %321, align 16, !invariant.load !0
>  %323 = call float @llvm.SI.load.const(<16 x i8> %322, i32 296)
>  %324 = fmul float %323, %209
>  %325 = fadd float %324, %312
>  %326 = fsub float 1.000000e+00, %42
>  %327 = fsub float 1.000000e+00, %47
>  %328 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %329 = load <16 x i8>, <16 x i8> addrspace(2)* %328, align 16, !invariant.load !0
>  %330 = call float @llvm.SI.load.const(<16 x i8> %329, i32 128)
>  %331 = fmul float %330, %.0
>  %332 = call float @llvm.SI.load.const(<16 x i8> %329, i32 132)
>  %333 = fmul float %332, %.0
>  %334 = call float @llvm.SI.load.const(<16 x i8> %329, i32 136)
>  %335 = fmul float %334, %.0
>  %336 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %337 = load <16 x i8>, <16 x i8> addrspace(2)* %336, align 16, !invariant.load !0
>  %338 = call float @llvm.SI.load.const(<16 x i8> %337, i32 140)
>  %339 = fmul float %338, %.0
>  %340 = call float @llvm.SI.load.const(<16 x i8> %337, i32 144)
>  %341 = fmul float %340, %.0116
>  %342 = fadd float %341, %331
>  %343 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %344 = load <16 x i8>, <16 x i8> addrspace(2)* %343, align 16, !invariant.load !0
>  %345 = call float @llvm.SI.load.const(<16 x i8> %344, i32 148)
>  %346 = fmul float %345, %.0116
>  %347 = fadd float %346, %333
>  %348 = call float @llvm.SI.load.const(<16 x i8> %344, i32 152)
>  %349 = fmul float %348, %.0116
>  %350 = fadd float %349, %335
>  %351 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %352 = load <16 x i8>, <16 x i8> addrspace(2)* %351, align 16, !invariant.load !0
>  %353 = call float @llvm.SI.load.const(<16 x i8> %352, i32 156)
>  %354 = fmul float %353, %.0116
>  %355 = fadd float %354, %339
>  %356 = call float @llvm.SI.load.const(<16 x i8> %352, i32 160)
>  %357 = fmul float %356, %.0121
>  %358 = fadd float %357, %342
>  %359 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %360 = load <16 x i8>, <16 x i8> addrspace(2)* %359, align 16, !invariant.load !0
>  %361 = call float @llvm.SI.load.const(<16 x i8> %360, i32 164)
>  %362 = fmul float %361, %.0121
>  %363 = fadd float %362, %347
>  %364 = call float @llvm.SI.load.const(<16 x i8> %360, i32 168)
>  %365 = fmul float %364, %.0121
>  %366 = fadd float %365, %350
>  %367 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %368 = load <16 x i8>, <16 x i8> addrspace(2)* %367, align 16, !invariant.load !0
>  %369 = call float @llvm.SI.load.const(<16 x i8> %368, i32 172)
>  %370 = fmul float %369, %.0121
>  %371 = fadd float %370, %355
>  %372 = call float @llvm.SI.load.const(<16 x i8> %368, i32 176)
>  %373 = fadd float %358, %372
>  %374 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %375 = load <16 x i8>, <16 x i8> addrspace(2)* %374, align 16, !invariant.load !0
>  %376 = call float @llvm.SI.load.const(<16 x i8> %375, i32 180)
>  %377 = fadd float %363, %376
>  %378 = call float @llvm.SI.load.const(<16 x i8> %375, i32 184)
>  %379 = fadd float %366, %378
>  %380 = call float @llvm.SI.load.const(<16 x i8> %375, i32 188)
>  %381 = fadd float %371, %380
>  %382 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %383 = load <16 x i8>, <16 x i8> addrspace(2)* %382, align 16, !invariant.load !0
>  %384 = call float @llvm.SI.load.const(<16 x i8> %383, i32 64)
>  %385 = fmul float %384, %.0
>  %386 = call float @llvm.SI.load.const(<16 x i8> %383, i32 68)
>  %387 = fmul float %386, %.0
>  %388 = call float @llvm.SI.load.const(<16 x i8> %383, i32 72)
>  %389 = fmul float %388, %.0
>  %390 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %391 = load <16 x i8>, <16 x i8> addrspace(2)* %390, align 16, !invariant.load !0
>  %392 = call float @llvm.SI.load.const(<16 x i8> %391, i32 80)
>  %393 = fmul float %392, %.0116
>  %394 = fadd float %393, %385
>  %395 = call float @llvm.SI.load.const(<16 x i8> %391, i32 84)
>  %396 = fmul float %395, %.0116
>  %397 = fadd float %396, %387
>  %398 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %399 = load <16 x i8>, <16 x i8> addrspace(2)* %398, align 16, !invariant.load !0
>  %400 = call float @llvm.SI.load.const(<16 x i8> %399, i32 88)
>  %401 = fmul float %400, %.0116
>  %402 = fadd float %401, %389
>  %403 = call float @llvm.SI.load.const(<16 x i8> %399, i32 96)
>  %404 = fmul float %403, %.0121
>  %405 = fadd float %404, %394
>  %406 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %407 = load <16 x i8>, <16 x i8> addrspace(2)* %406, align 16, !invariant.load !0
>  %408 = call float @llvm.SI.load.const(<16 x i8> %407, i32 100)
>  %409 = fmul float %408, %.0121
>  %410 = fadd float %409, %397
>  %411 = call float @llvm.SI.load.const(<16 x i8> %407, i32 104)
>  %412 = fmul float %411, %.0121
>  %413 = fadd float %412, %402
>  %414 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %415 = load <16 x i8>, <16 x i8> addrspace(2)* %414, align 16, !invariant.load !0
>  %416 = call float @llvm.SI.load.const(<16 x i8> %415, i32 112)
>  %417 = fadd float %405, %416
>  %418 = call float @llvm.SI.load.const(<16 x i8> %415, i32 116)
>  %419 = fadd float %410, %418
>  %420 = call float @llvm.SI.load.const(<16 x i8> %415, i32 120)
>  %421 = fadd float %413, %420
>  %422 = bitcast i32 %12 to float
>  %423 = insertvalue <{ float, float, float }> undef, float %422, 2
>  call void @llvm.SI.export(i32 15, i32 0, i32 0, i32 32, i32 0, float %41, float %326, float %46, float %327)
>  call void @llvm.SI.export(i32 15, i32 0, i32 0, i32 33, i32 0, float %207, float %208, float %209, float %317)
>  call void @llvm.SI.export(i32 15, i32 0, i32 0, i32 34, i32 0, float %320, float %325, float %285, float %288)
>  call void @llvm.SI.export(i32 15, i32 0, i32 0, i32 35, i32 0, float %293, float %.0, float %.0116, float %.0121)
>  call void @llvm.SI.export(i32 15, i32 0, i32 0, i32 36, i32 0, float %417, float %419, float %421, float %255)
>  call void @llvm.SI.export(i32 15, i32 0, i32 0, i32 37, i32 0, float %259, float %261, float %261, float %253)
>  call void @llvm.SI.export(i32 15, i32 0, i32 1, i32 12, i32 0, float %373, float %377, float %379, float %381)
>  ret <{ float, float, float }> %423
>
>IF2:                                              ; preds = %IF
>  %424 = shl i32 %84, 6
>  %425 = shl i32 %84, 6
>  %426 = shl i32 %84, 6
>  %427 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %428 = load <16 x i8>, <16 x i8> addrspace(2)* %427, align 16, !invariant.load !0
>  %429 = shl i32 %84, 6
>  %430 = add i32 %429, 352
>  %431 = call float @llvm.SI.load.const(<16 x i8> %428, i32 %430)
>  %432 = fmul float %431, %29
>  %433 = shl i32 %84, 6
>  %434 = add i32 %433, 356
>  %435 = call float @llvm.SI.load.const(<16 x i8> %428, i32 %434)
>  %436 = fmul float %435, %29
>  %437 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %438 = load <16 x i8>, <16 x i8> addrspace(2)* %437, align 16, !invariant.load !0
>  %439 = add i32 %426, 360
>  %440 = call float @llvm.SI.load.const(<16 x i8> %438, i32 %439)
>  %441 = fmul float %440, %29
>  %442 = shl i32 %84, 6
>  %443 = add i32 %442, 368
>  %444 = call float @llvm.SI.load.const(<16 x i8> %438, i32 %443)
>  %445 = fmul float %444, %30
>  %446 = fadd float %445, %432
>  %447 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %448 = load <16 x i8>, <16 x i8> addrspace(2)* %447, align 16, !invariant.load !0
>  %449 = shl i32 %84, 6
>  %450 = add i32 %449, 372
>  %451 = call float @llvm.SI.load.const(<16 x i8> %448, i32 %450)
>  %452 = fmul float %451, %30
>  %453 = fadd float %452, %436
>  %454 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %455 = load <16 x i8>, <16 x i8> addrspace(2)* %454, align 16, !invariant.load !0
>  %456 = add i32 %425, 376
>  %457 = call float @llvm.SI.load.const(<16 x i8> %455, i32 %456)
>  %458 = fmul float %457, %30
>  %459 = fadd float %458, %441
>  %460 = shl i32 %84, 6
>  %461 = add i32 %460, 384
>  %462 = call float @llvm.SI.load.const(<16 x i8> %455, i32 %461)
>  %463 = fmul float %462, %31
>  %464 = fadd float %463, %446
>  %465 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %466 = load <16 x i8>, <16 x i8> addrspace(2)* %465, align 16, !invariant.load !0
>  %467 = shl i32 %84, 6
>  %468 = add i32 %467, 388
>  %469 = call float @llvm.SI.load.const(<16 x i8> %466, i32 %468)
>  %470 = fmul float %469, %31
>  %471 = fadd float %470, %453
>  %472 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %473 = load <16 x i8>, <16 x i8> addrspace(2)* %472, align 16, !invariant.load !0
>  %474 = add i32 %424, 392
>  %475 = call float @llvm.SI.load.const(<16 x i8> %473, i32 %474)
>  %476 = fmul float %475, %31
>  %477 = fadd float %476, %459
>  %478 = shl i32 %84, 6
>  %479 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %480 = load <16 x i8>, <16 x i8> addrspace(2)* %479, align 16, !invariant.load !0
>  %481 = shl i32 %84, 6
>  %482 = add i32 %481, 400
>  %483 = call float @llvm.SI.load.const(<16 x i8> %480, i32 %482)
>  %484 = fadd float %464, %483
>  %485 = shl i32 %84, 6
>  %486 = add i32 %485, 404
>  %487 = call float @llvm.SI.load.const(<16 x i8> %480, i32 %486)
>  %488 = fadd float %471, %487
>  %489 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %490 = load <16 x i8>, <16 x i8> addrspace(2)* %489, align 16, !invariant.load !0
>  %491 = add i32 %478, 408
>  %492 = call float @llvm.SI.load.const(<16 x i8> %490, i32 %491)
>  %493 = fadd float %477, %492
>  %494 = fmul float %484, %75
>  %495 = fmul float %488, %75
>  %496 = fmul float %493, %75
>  %497 = shl i32 %84, 6
>  %498 = shl i32 %84, 6
>  %499 = shl i32 %84, 6
>  %500 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %501 = load <16 x i8>, <16 x i8> addrspace(2)* %500, align 16, !invariant.load !0
>  %502 = shl i32 %84, 6
>  %503 = add i32 %502, 352
>  %504 = call float @llvm.SI.load.const(<16 x i8> %501, i32 %503)
>  %505 = fmul float %504, %35
>  %506 = shl i32 %84, 6
>  %507 = add i32 %506, 356
>  %508 = call float @llvm.SI.load.const(<16 x i8> %501, i32 %507)
>  %509 = fmul float %508, %35
>  %510 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %511 = load <16 x i8>, <16 x i8> addrspace(2)* %510, align 16, !invariant.load !0
>  %512 = add i32 %499, 360
>  %513 = call float @llvm.SI.load.const(<16 x i8> %511, i32 %512)
>  %514 = fmul float %513, %35
>  %515 = shl i32 %84, 6
>  %516 = add i32 %515, 368
>  %517 = call float @llvm.SI.load.const(<16 x i8> %511, i32 %516)
>  %518 = fmul float %517, %36
>  %519 = fadd float %518, %505
>  %520 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %521 = load <16 x i8>, <16 x i8> addrspace(2)* %520, align 16, !invariant.load !0
>  %522 = shl i32 %84, 6
>  %523 = add i32 %522, 372
>  %524 = call float @llvm.SI.load.const(<16 x i8> %521, i32 %523)
>  %525 = fmul float %524, %36
>  %526 = fadd float %525, %509
>  %527 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %528 = load <16 x i8>, <16 x i8> addrspace(2)* %527, align 16, !invariant.load !0
>  %529 = add i32 %498, 376
>  %530 = call float @llvm.SI.load.const(<16 x i8> %528, i32 %529)
>  %531 = fmul float %530, %36
>  %532 = fadd float %531, %514
>  %533 = shl i32 %84, 6
>  %534 = add i32 %533, 384
>  %535 = call float @llvm.SI.load.const(<16 x i8> %528, i32 %534)
>  %536 = fmul float %535, %37
>  %537 = fadd float %536, %519
>  %538 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %539 = load <16 x i8>, <16 x i8> addrspace(2)* %538, align 16, !invariant.load !0
>  %540 = shl i32 %84, 6
>  %541 = add i32 %540, 388
>  %542 = call float @llvm.SI.load.const(<16 x i8> %539, i32 %541)
>  %543 = fmul float %542, %37
>  %544 = fadd float %543, %526
>  %545 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %546 = load <16 x i8>, <16 x i8> addrspace(2)* %545, align 16, !invariant.load !0
>  %547 = add i32 %497, 392
>  %548 = call float @llvm.SI.load.const(<16 x i8> %546, i32 %547)
>  %549 = fmul float %548, %37
>  %550 = fadd float %549, %532
>  %551 = fmul float %537, %75
>  %552 = fmul float %544, %75
>  %553 = fmul float %550, %75
>  br label %ENDIF1
>
>ENDIF1:                                           ; preds = %IF, %IF2
>  %.1137 = phi float [ %553, %IF2 ], [ %37, %IF ]
>  %.1132 = phi float [ %552, %IF2 ], [ %36, %IF ]
>  %.1127 = phi float [ %551, %IF2 ], [ %35, %IF ]
>  %.1122 = phi float [ %496, %IF2 ], [ %31, %IF ]
>  %.1117 = phi float [ %495, %IF2 ], [ %30, %IF ]
>  %.1 = phi float [ %494, %IF2 ], [ %29, %IF ]
>  %554 = fptosi float %69 to i32
>  %555 = icmp sgt i32 %554, -1
>  br i1 %555, label %IF30, label %ENDIF29
>
>IF30:                                             ; preds = %ENDIF1
>  %556 = shl i32 %554, 6
>  %557 = shl i32 %554, 6
>  %558 = shl i32 %554, 6
>  %559 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %560 = load <16 x i8>, <16 x i8> addrspace(2)* %559, align 16, !invariant.load !0
>  %561 = shl i32 %554, 6
>  %562 = add i32 %561, 352
>  %563 = call float @llvm.SI.load.const(<16 x i8> %560, i32 %562)
>  %564 = fmul float %563, %29
>  %565 = shl i32 %554, 6
>  %566 = add i32 %565, 356
>  %567 = call float @llvm.SI.load.const(<16 x i8> %560, i32 %566)
>  %568 = fmul float %567, %29
>  %569 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %570 = load <16 x i8>, <16 x i8> addrspace(2)* %569, align 16, !invariant.load !0
>  %571 = add i32 %558, 360
>  %572 = call float @llvm.SI.load.const(<16 x i8> %570, i32 %571)
>  %573 = fmul float %572, %29
>  %574 = shl i32 %554, 6
>  %575 = add i32 %574, 368
>  %576 = call float @llvm.SI.load.const(<16 x i8> %570, i32 %575)
>  %577 = fmul float %576, %30
>  %578 = fadd float %577, %564
>  %579 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %580 = load <16 x i8>, <16 x i8> addrspace(2)* %579, align 16, !invariant.load !0
>  %581 = shl i32 %554, 6
>  %582 = add i32 %581, 372
>  %583 = call float @llvm.SI.load.const(<16 x i8> %580, i32 %582)
>  %584 = fmul float %583, %30
>  %585 = fadd float %584, %568
>  %586 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %587 = load <16 x i8>, <16 x i8> addrspace(2)* %586, align 16, !invariant.load !0
>  %588 = add i32 %557, 376
>  %589 = call float @llvm.SI.load.const(<16 x i8> %587, i32 %588)
>  %590 = fmul float %589, %30
>  %591 = fadd float %590, %573
>  %592 = shl i32 %554, 6
>  %593 = add i32 %592, 384
>  %594 = call float @llvm.SI.load.const(<16 x i8> %587, i32 %593)
>  %595 = fmul float %594, %31
>  %596 = fadd float %595, %578
>  %597 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %598 = load <16 x i8>, <16 x i8> addrspace(2)* %597, align 16, !invariant.load !0
>  %599 = shl i32 %554, 6
>  %600 = add i32 %599, 388
>  %601 = call float @llvm.SI.load.const(<16 x i8> %598, i32 %600)
>  %602 = fmul float %601, %31
>  %603 = fadd float %602, %585
>  %604 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %605 = load <16 x i8>, <16 x i8> addrspace(2)* %604, align 16, !invariant.load !0
>  %606 = add i32 %556, 392
>  %607 = call float @llvm.SI.load.const(<16 x i8> %605, i32 %606)
>  %608 = fmul float %607, %31
>  %609 = fadd float %608, %591
>  %610 = shl i32 %554, 6
>  %611 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %612 = load <16 x i8>, <16 x i8> addrspace(2)* %611, align 16, !invariant.load !0
>  %613 = shl i32 %554, 6
>  %614 = add i32 %613, 400
>  %615 = call float @llvm.SI.load.const(<16 x i8> %612, i32 %614)
>  %616 = fadd float %596, %615
>  %617 = shl i32 %554, 6
>  %618 = add i32 %617, 404
>  %619 = call float @llvm.SI.load.const(<16 x i8> %612, i32 %618)
>  %620 = fadd float %603, %619
>  %621 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %622 = load <16 x i8>, <16 x i8> addrspace(2)* %621, align 16, !invariant.load !0
>  %623 = add i32 %610, 408
>  %624 = call float @llvm.SI.load.const(<16 x i8> %622, i32 %623)
>  %625 = fadd float %609, %624
>  %626 = fmul float %616, %76
>  %627 = fadd float %626, %.1
>  %628 = fmul float %620, %76
>  %629 = fadd float %628, %.1117
>  %630 = fmul float %625, %76
>  %631 = fadd float %630, %.1122
>  %632 = shl i32 %554, 6
>  %633 = shl i32 %554, 6
>  %634 = shl i32 %554, 6
>  %635 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %636 = load <16 x i8>, <16 x i8> addrspace(2)* %635, align 16, !invariant.load !0
>  %637 = shl i32 %554, 6
>  %638 = add i32 %637, 352
>  %639 = call float @llvm.SI.load.const(<16 x i8> %636, i32 %638)
>  %640 = fmul float %639, %35
>  %641 = shl i32 %554, 6
>  %642 = add i32 %641, 356
>  %643 = call float @llvm.SI.load.const(<16 x i8> %636, i32 %642)
>  %644 = fmul float %643, %35
>  %645 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %646 = load <16 x i8>, <16 x i8> addrspace(2)* %645, align 16, !invariant.load !0
>  %647 = add i32 %634, 360
>  %648 = call float @llvm.SI.load.const(<16 x i8> %646, i32 %647)
>  %649 = fmul float %648, %35
>  %650 = shl i32 %554, 6
>  %651 = add i32 %650, 368
>  %652 = call float @llvm.SI.load.const(<16 x i8> %646, i32 %651)
>  %653 = fmul float %652, %36
>  %654 = fadd float %653, %640
>  %655 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %656 = load <16 x i8>, <16 x i8> addrspace(2)* %655, align 16, !invariant.load !0
>  %657 = shl i32 %554, 6
>  %658 = add i32 %657, 372
>  %659 = call float @llvm.SI.load.const(<16 x i8> %656, i32 %658)
>  %660 = fmul float %659, %36
>  %661 = fadd float %660, %644
>  %662 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %663 = load <16 x i8>, <16 x i8> addrspace(2)* %662, align 16, !invariant.load !0
>  %664 = add i32 %633, 376
>  %665 = call float @llvm.SI.load.const(<16 x i8> %663, i32 %664)
>  %666 = fmul float %665, %36
>  %667 = fadd float %666, %649
>  %668 = shl i32 %554, 6
>  %669 = add i32 %668, 384
>  %670 = call float @llvm.SI.load.const(<16 x i8> %663, i32 %669)
>  %671 = fmul float %670, %37
>  %672 = fadd float %671, %654
>  %673 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %674 = load <16 x i8>, <16 x i8> addrspace(2)* %673, align 16, !invariant.load !0
>  %675 = shl i32 %554, 6
>  %676 = add i32 %675, 388
>  %677 = call float @llvm.SI.load.const(<16 x i8> %674, i32 %676)
>  %678 = fmul float %677, %37
>  %679 = fadd float %678, %661
>  %680 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %681 = load <16 x i8>, <16 x i8> addrspace(2)* %680, align 16, !invariant.load !0
>  %682 = add i32 %632, 392
>  %683 = call float @llvm.SI.load.const(<16 x i8> %681, i32 %682)
>  %684 = fmul float %683, %37
>  %685 = fadd float %684, %667
>  %686 = fmul float %672, %76
>  %687 = fadd float %686, %.1127
>  %688 = fmul float %679, %76
>  %689 = fadd float %688, %.1132
>  %690 = fmul float %685, %76
>  %691 = fadd float %690, %.1137
>  br label %ENDIF29
>
>ENDIF29:                                          ; preds = %ENDIF1, %IF30
>  %.2138 = phi float [ %691, %IF30 ], [ %.1137, %ENDIF1 ]
>  %.2133 = phi float [ %689, %IF30 ], [ %.1132, %ENDIF1 ]
>  %.2128 = phi float [ %687, %IF30 ], [ %.1127, %ENDIF1 ]
>  %.2123 = phi float [ %631, %IF30 ], [ %.1122, %ENDIF1 ]
>  %.2118 = phi float [ %629, %IF30 ], [ %.1117, %ENDIF1 ]
>  %.2 = phi float [ %627, %IF30 ], [ %.1, %ENDIF1 ]
>  %692 = fptosi float %70 to i32
>  %693 = icmp sgt i32 %692, -1
>  br i1 %693, label %IF59, label %ENDIF58
>
>IF59:                                             ; preds = %ENDIF29
>  %694 = shl i32 %692, 6
>  %695 = shl i32 %692, 6
>  %696 = shl i32 %692, 6
>  %697 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %698 = load <16 x i8>, <16 x i8> addrspace(2)* %697, align 16, !invariant.load !0
>  %699 = shl i32 %692, 6
>  %700 = add i32 %699, 352
>  %701 = call float @llvm.SI.load.const(<16 x i8> %698, i32 %700)
>  %702 = fmul float %701, %29
>  %703 = shl i32 %692, 6
>  %704 = add i32 %703, 356
>  %705 = call float @llvm.SI.load.const(<16 x i8> %698, i32 %704)
>  %706 = fmul float %705, %29
>  %707 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %708 = load <16 x i8>, <16 x i8> addrspace(2)* %707, align 16, !invariant.load !0
>  %709 = add i32 %696, 360
>  %710 = call float @llvm.SI.load.const(<16 x i8> %708, i32 %709)
>  %711 = fmul float %710, %29
>  %712 = shl i32 %692, 6
>  %713 = add i32 %712, 368
>  %714 = call float @llvm.SI.load.const(<16 x i8> %708, i32 %713)
>  %715 = fmul float %714, %30
>  %716 = fadd float %715, %702
>  %717 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %718 = load <16 x i8>, <16 x i8> addrspace(2)* %717, align 16, !invariant.load !0
>  %719 = shl i32 %692, 6
>  %720 = add i32 %719, 372
>  %721 = call float @llvm.SI.load.const(<16 x i8> %718, i32 %720)
>  %722 = fmul float %721, %30
>  %723 = fadd float %722, %706
>  %724 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %725 = load <16 x i8>, <16 x i8> addrspace(2)* %724, align 16, !invariant.load !0
>  %726 = add i32 %695, 376
>  %727 = call float @llvm.SI.load.const(<16 x i8> %725, i32 %726)
>  %728 = fmul float %727, %30
>  %729 = fadd float %728, %711
>  %730 = shl i32 %692, 6
>  %731 = add i32 %730, 384
>  %732 = call float @llvm.SI.load.const(<16 x i8> %725, i32 %731)
>  %733 = fmul float %732, %31
>  %734 = fadd float %733, %716
>  %735 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %736 = load <16 x i8>, <16 x i8> addrspace(2)* %735, align 16, !invariant.load !0
>  %737 = shl i32 %692, 6
>  %738 = add i32 %737, 388
>  %739 = call float @llvm.SI.load.const(<16 x i8> %736, i32 %738)
>  %740 = fmul float %739, %31
>  %741 = fadd float %740, %723
>  %742 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %743 = load <16 x i8>, <16 x i8> addrspace(2)* %742, align 16, !invariant.load !0
>  %744 = add i32 %694, 392
>  %745 = call float @llvm.SI.load.const(<16 x i8> %743, i32 %744)
>  %746 = fmul float %745, %31
>  %747 = fadd float %746, %729
>  %748 = shl i32 %692, 6
>  %749 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %750 = load <16 x i8>, <16 x i8> addrspace(2)* %749, align 16, !invariant.load !0
>  %751 = shl i32 %692, 6
>  %752 = add i32 %751, 400
>  %753 = call float @llvm.SI.load.const(<16 x i8> %750, i32 %752)
>  %754 = fadd float %734, %753
>  %755 = shl i32 %692, 6
>  %756 = add i32 %755, 404
>  %757 = call float @llvm.SI.load.const(<16 x i8> %750, i32 %756)
>  %758 = fadd float %741, %757
>  %759 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %760 = load <16 x i8>, <16 x i8> addrspace(2)* %759, align 16, !invariant.load !0
>  %761 = add i32 %748, 408
>  %762 = call float @llvm.SI.load.const(<16 x i8> %760, i32 %761)
>  %763 = fadd float %747, %762
>  %764 = fmul float %754, %77
>  %765 = fadd float %764, %.2
>  %766 = fmul float %758, %77
>  %767 = fadd float %766, %.2118
>  %768 = fmul float %763, %77
>  %769 = fadd float %768, %.2123
>  %770 = shl i32 %692, 6
>  %771 = shl i32 %692, 6
>  %772 = shl i32 %692, 6
>  %773 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %774 = load <16 x i8>, <16 x i8> addrspace(2)* %773, align 16, !invariant.load !0
>  %775 = shl i32 %692, 6
>  %776 = add i32 %775, 352
>  %777 = call float @llvm.SI.load.const(<16 x i8> %774, i32 %776)
>  %778 = fmul float %777, %35
>  %779 = shl i32 %692, 6
>  %780 = add i32 %779, 356
>  %781 = call float @llvm.SI.load.const(<16 x i8> %774, i32 %780)
>  %782 = fmul float %781, %35
>  %783 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %784 = load <16 x i8>, <16 x i8> addrspace(2)* %783, align 16, !invariant.load !0
>  %785 = add i32 %772, 360
>  %786 = call float @llvm.SI.load.const(<16 x i8> %784, i32 %785)
>  %787 = fmul float %786, %35
>  %788 = shl i32 %692, 6
>  %789 = add i32 %788, 368
>  %790 = call float @llvm.SI.load.const(<16 x i8> %784, i32 %789)
>  %791 = fmul float %790, %36
>  %792 = fadd float %791, %778
>  %793 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %794 = load <16 x i8>, <16 x i8> addrspace(2)* %793, align 16, !invariant.load !0
>  %795 = shl i32 %692, 6
>  %796 = add i32 %795, 372
>  %797 = call float @llvm.SI.load.const(<16 x i8> %794, i32 %796)
>  %798 = fmul float %797, %36
>  %799 = fadd float %798, %782
>  %800 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %801 = load <16 x i8>, <16 x i8> addrspace(2)* %800, align 16, !invariant.load !0
>  %802 = add i32 %771, 376
>  %803 = call float @llvm.SI.load.const(<16 x i8> %801, i32 %802)
>  %804 = fmul float %803, %36
>  %805 = fadd float %804, %787
>  %806 = shl i32 %692, 6
>  %807 = add i32 %806, 384
>  %808 = call float @llvm.SI.load.const(<16 x i8> %801, i32 %807)
>  %809 = fmul float %808, %37
>  %810 = fadd float %809, %792
>  %811 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %812 = load <16 x i8>, <16 x i8> addrspace(2)* %811, align 16, !invariant.load !0
>  %813 = shl i32 %692, 6
>  %814 = add i32 %813, 388
>  %815 = call float @llvm.SI.load.const(<16 x i8> %812, i32 %814)
>  %816 = fmul float %815, %37
>  %817 = fadd float %816, %799
>  %818 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %819 = load <16 x i8>, <16 x i8> addrspace(2)* %818, align 16, !invariant.load !0
>  %820 = add i32 %770, 392
>  %821 = call float @llvm.SI.load.const(<16 x i8> %819, i32 %820)
>  %822 = fmul float %821, %37
>  %823 = fadd float %822, %805
>  %824 = fmul float %810, %77
>  %825 = fadd float %824, %.2128
>  %826 = fmul float %817, %77
>  %827 = fadd float %826, %.2133
>  %828 = fmul float %823, %77
>  %829 = fadd float %828, %.2138
>  br label %ENDIF58
>
>ENDIF58:                                          ; preds = %ENDIF29, %IF59
>  %.3139 = phi float [ %829, %IF59 ], [ %.2138, %ENDIF29 ]
>  %.3134 = phi float [ %827, %IF59 ], [ %.2133, %ENDIF29 ]
>  %.3129 = phi float [ %825, %IF59 ], [ %.2128, %ENDIF29 ]
>  %.3124 = phi float [ %769, %IF59 ], [ %.2123, %ENDIF29 ]
>  %.3119 = phi float [ %767, %IF59 ], [ %.2118, %ENDIF29 ]
>  %.3 = phi float [ %765, %IF59 ], [ %.2, %ENDIF29 ]
>  %830 = fptosi float %71 to i32
>  %831 = icmp sgt i32 %830, -1
>  br i1 %831, label %IF88, label %ENDIF
>
>IF88:                                             ; preds = %ENDIF58
>  %832 = shl i32 %830, 6
>  %833 = shl i32 %830, 6
>  %834 = shl i32 %830, 6
>  %835 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %836 = load <16 x i8>, <16 x i8> addrspace(2)* %835, align 16, !invariant.load !0
>  %837 = shl i32 %830, 6
>  %838 = add i32 %837, 352
>  %839 = call float @llvm.SI.load.const(<16 x i8> %836, i32 %838)
>  %840 = fmul float %839, %29
>  %841 = shl i32 %830, 6
>  %842 = add i32 %841, 356
>  %843 = call float @llvm.SI.load.const(<16 x i8> %836, i32 %842)
>  %844 = fmul float %843, %29
>  %845 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %846 = load <16 x i8>, <16 x i8> addrspace(2)* %845, align 16, !invariant.load !0
>  %847 = add i32 %834, 360
>  %848 = call float @llvm.SI.load.const(<16 x i8> %846, i32 %847)
>  %849 = fmul float %848, %29
>  %850 = shl i32 %830, 6
>  %851 = add i32 %850, 368
>  %852 = call float @llvm.SI.load.const(<16 x i8> %846, i32 %851)
>  %853 = fmul float %852, %30
>  %854 = fadd float %853, %840
>  %855 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %856 = load <16 x i8>, <16 x i8> addrspace(2)* %855, align 16, !invariant.load !0
>  %857 = shl i32 %830, 6
>  %858 = add i32 %857, 372
>  %859 = call float @llvm.SI.load.const(<16 x i8> %856, i32 %858)
>  %860 = fmul float %859, %30
>  %861 = fadd float %860, %844
>  %862 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %863 = load <16 x i8>, <16 x i8> addrspace(2)* %862, align 16, !invariant.load !0
>  %864 = add i32 %833, 376
>  %865 = call float @llvm.SI.load.const(<16 x i8> %863, i32 %864)
>  %866 = fmul float %865, %30
>  %867 = fadd float %866, %849
>  %868 = shl i32 %830, 6
>  %869 = add i32 %868, 384
>  %870 = call float @llvm.SI.load.const(<16 x i8> %863, i32 %869)
>  %871 = fmul float %870, %31
>  %872 = fadd float %871, %854
>  %873 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %874 = load <16 x i8>, <16 x i8> addrspace(2)* %873, align 16, !invariant.load !0
>  %875 = shl i32 %830, 6
>  %876 = add i32 %875, 388
>  %877 = call float @llvm.SI.load.const(<16 x i8> %874, i32 %876)
>  %878 = fmul float %877, %31
>  %879 = fadd float %878, %861
>  %880 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %881 = load <16 x i8>, <16 x i8> addrspace(2)* %880, align 16, !invariant.load !0
>  %882 = add i32 %832, 392
>  %883 = call float @llvm.SI.load.const(<16 x i8> %881, i32 %882)
>  %884 = fmul float %883, %31
>  %885 = fadd float %884, %867
>  %886 = shl i32 %830, 6
>  %887 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %888 = load <16 x i8>, <16 x i8> addrspace(2)* %887, align 16, !invariant.load !0
>  %889 = shl i32 %830, 6
>  %890 = add i32 %889, 400
>  %891 = call float @llvm.SI.load.const(<16 x i8> %888, i32 %890)
>  %892 = fadd float %872, %891
>  %893 = shl i32 %830, 6
>  %894 = add i32 %893, 404
>  %895 = call float @llvm.SI.load.const(<16 x i8> %888, i32 %894)
>  %896 = fadd float %879, %895
>  %897 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %898 = load <16 x i8>, <16 x i8> addrspace(2)* %897, align 16, !invariant.load !0
>  %899 = add i32 %886, 408
>  %900 = call float @llvm.SI.load.const(<16 x i8> %898, i32 %899)
>  %901 = fadd float %885, %900
>  %902 = fmul float %892, %78
>  %903 = fadd float %902, %.3
>  %904 = fmul float %896, %78
>  %905 = fadd float %904, %.3119
>  %906 = fmul float %901, %78
>  %907 = fadd float %906, %.3124
>  %908 = shl i32 %830, 6
>  %909 = shl i32 %830, 6
>  %910 = shl i32 %830, 6
>  %911 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %912 = load <16 x i8>, <16 x i8> addrspace(2)* %911, align 16, !invariant.load !0
>  %913 = shl i32 %830, 6
>  %914 = add i32 %913, 352
>  %915 = call float @llvm.SI.load.const(<16 x i8> %912, i32 %914)
>  %916 = fmul float %915, %35
>  %917 = shl i32 %830, 6
>  %918 = add i32 %917, 356
>  %919 = call float @llvm.SI.load.const(<16 x i8> %912, i32 %918)
>  %920 = fmul float %919, %35
>  %921 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %922 = load <16 x i8>, <16 x i8> addrspace(2)* %921, align 16, !invariant.load !0
>  %923 = add i32 %910, 360
>  %924 = call float @llvm.SI.load.const(<16 x i8> %922, i32 %923)
>  %925 = fmul float %924, %35
>  %926 = shl i32 %830, 6
>  %927 = add i32 %926, 368
>  %928 = call float @llvm.SI.load.const(<16 x i8> %922, i32 %927)
>  %929 = fmul float %928, %36
>  %930 = fadd float %929, %916
>  %931 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %932 = load <16 x i8>, <16 x i8> addrspace(2)* %931, align 16, !invariant.load !0
>  %933 = shl i32 %830, 6
>  %934 = add i32 %933, 372
>  %935 = call float @llvm.SI.load.const(<16 x i8> %932, i32 %934)
>  %936 = fmul float %935, %36
>  %937 = fadd float %936, %920
>  %938 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %939 = load <16 x i8>, <16 x i8> addrspace(2)* %938, align 16, !invariant.load !0
>  %940 = add i32 %909, 376
>  %941 = call float @llvm.SI.load.const(<16 x i8> %939, i32 %940)
>  %942 = fmul float %941, %36
>  %943 = fadd float %942, %925
>  %944 = shl i32 %830, 6
>  %945 = add i32 %944, 384
>  %946 = call float @llvm.SI.load.const(<16 x i8> %939, i32 %945)
>  %947 = fmul float %946, %37
>  %948 = fadd float %947, %930
>  %949 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %950 = load <16 x i8>, <16 x i8> addrspace(2)* %949, align 16, !invariant.load !0
>  %951 = shl i32 %830, 6
>  %952 = add i32 %951, 388
>  %953 = call float @llvm.SI.load.const(<16 x i8> %950, i32 %952)
>  %954 = fmul float %953, %37
>  %955 = fadd float %954, %937
>  %956 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %957 = load <16 x i8>, <16 x i8> addrspace(2)* %956, align 16, !invariant.load !0
>  %958 = add i32 %908, 392
>  %959 = call float @llvm.SI.load.const(<16 x i8> %957, i32 %958)
>  %960 = fmul float %959, %37
>  %961 = fadd float %960, %943
>  %962 = fmul float %948, %78
>  %963 = fadd float %962, %.3129
>  %964 = fmul float %955, %78
>  %965 = fadd float %964, %.3134
>  %966 = fmul float %961, %78
>  %967 = fadd float %966, %.3139
>  br label %ENDIF
>}
>
>; Function Attrs: nounwind readnone
>declare <4 x float> @llvm.SI.vs.load.input(<16 x i8>, i32, i32) #0
>
>; Function Attrs: nounwind readnone
>declare float @llvm.SI.load.const(<16 x i8>, i32) #0
>
>; Function Attrs: nounwind readnone
>declare float @llvm.sqrt.f32(float) #0
>
>; Function Attrs: nounwind
>declare void @llvm.SI.export(i32, i32, i32, i32, i32, float, float, float, float) #1
>
>attributes #0 = { nounwind readnone }
>attributes #1 = { nounwind }
>
>!0 = !{}
>!1 = !{float 2.500000e+00}
>
>FRAG
>DCL IN[0], GENERIC[0], PERSPECTIVE
>DCL IN[1], GENERIC[1], PERSPECTIVE
>DCL IN[2], GENERIC[2], PERSPECTIVE
>DCL IN[3], GENERIC[3], PERSPECTIVE
>DCL IN[4], GENERIC[4], PERSPECTIVE
>DCL IN[5], GENERIC[5], PERSPECTIVE
>DCL OUT[0], COLOR
>DCL SAMP[0]
>DCL SAMP[1]
>DCL SAMP[2]
>DCL SAMP[3]
>DCL SAMP[4]
>DCL SAMP[5]
>DCL SAMP[6]
>DCL SAMP[7]
>DCL SAMP[8]
>DCL SVIEW[0], 2D, FLOAT
>DCL SVIEW[1], 2D, FLOAT
>DCL SVIEW[2], 2D, FLOAT
>DCL SVIEW[3], 2D, FLOAT
>DCL SVIEW[4], 2D, FLOAT
>DCL SVIEW[5], 2D, FLOAT
>DCL SVIEW[6], 2D, FLOAT
>DCL SVIEW[7], CUBE, FLOAT
>DCL SVIEW[8], CUBE, FLOAT
>DCL CONST[9..42]
>DCL CONST[1][0..47]
>DCL TEMP[0..106], LOCAL
>DCL ADDR[0]
>IMM[0] UINT32 {0, 48, 16, 32}
>IMM[1] FLT32 {    1.0000,     0.0000,     2.2000,     0.9000}
>IMM[2] FLT32 {    2.0079,    -1.0079,     0.0300,   511.0000}
>IMM[3] FLT32 {    4.0000,    -2.0000,     2.0000,  2048.0000}
>IMM[4] FLT32 {   -1.0000,     0.1000,     0.0010,     0.5000}
>IMM[5] INT32 {0, 16, 4, 1}
>IMM[6] FLT32 {    5.0000,     3.1416,     0.2500,    50.0000}
>IMM[7] FLT32 {    0.3183,     0.3786,     0.4400,    -0.0102}
>IMM[8] FLT32 {   -0.0172,    -0.0257,    -0.0858,    -0.0086}
>IMM[9] FLT32 {    0.3530,     0.3441,     0.3894,     8.0000}
>IMM[10] FLT32 {   -0.2081,    -0.2378,    -0.1030,    -0.1201}
>IMM[11] FLT32 {    0.0500,    -1.0400,     1.0400,    -9.2800}
>IMM[12] FLT32 {   -1.0000,    -0.0275,    -0.5720,     0.0220}
>IMM[13] FLT32 {    1.0000,     0.0425,     1.0400,    -0.0400}
>IMM[14] FLT32 {    1.4427,     0.0000,     0.0000,     0.0000}
>  0: MOV TEMP[0].x, IN[1].wwww
>  1: MOV TEMP[0].yz, IN[2].yxyy
>  2: MOV TEMP[1].xy, IN[2].zwzz
>  3: MOV TEMP[1].z, IN[3].xxxx
>  4: MOV TEMP[2].x, IN[4].wwww
>  5: MOV TEMP[2].yz, IN[5].yxyy
>  6: MOV TEMP[3].xy, IN[0].zwzz
>  7: FSEQ TEMP[4].x, CONST[9].xxxx, IMM[1].xxxx
>  8: UIF TEMP[4].xxxx :0
>  9:   DP3 TEMP[4].x, TEMP[2].xyzz, CONST[10].xyzz
> 10:   FSLT TEMP[4].x, TEMP[4].xxxx, CONST[10].wwww
> 11: ELSE :0
> 12:   MOV TEMP[4].x, IMM[0].xxxx
> 13: ENDIF
> 14: MOV TEMP[3].x, TEMP[4].xxxx
> 15: AND TEMP[4], TEMP[4].xxxx, IMM[1].xxxx
> 16: KILL_IF -TEMP[4].xxxx
> 17: MOV TEMP[4], IMM[1].yyyy
> 18: FSEQ TEMP[5].x, CONST[38].xxxx, IMM[1].xxxx
> 19: UIF TEMP[5].xxxx :0
> 20:   MOV TEMP[5].xy, IN[0].xyyy
> 21:   TEX TEMP[5], TEMP[5], SAMP[0], 2D
> 22:   POW TEMP[6].x, TEMP[5].xxxx, IMM[1].zzzz
> 23:   POW TEMP[6].y, TEMP[5].yyyy, IMM[1].zzzz
> 24:   POW TEMP[6].z, TEMP[5].zzzz, IMM[1].zzzz
> 25:   POW TEMP[6].w, TEMP[5].wwww, IMM[1].xxxx
> 26:   MOV TEMP[5], TEMP[6]
> 27:   MOV TEMP[4], TEMP[6]
> 28:   FSLT TEMP[5].x, IMM[1].wwww, CONST[23].wwww
> 29:   FSEQ TEMP[7], TEMP[6].xyzz, CONST[23].xyzz
> 30:   AND TEMP[7].y, TEMP[7].yyyy, TEMP[7].zzzz
> 31:   AND TEMP[7].x, TEMP[7].xxxx, TEMP[7].yyyy
> 32:   AND TEMP[3].x, TEMP[5].xxxx, TEMP[7].xxxx
> 33:   AND TEMP[5], TEMP[3].xxxx, IMM[1].xxxx
> 34:   KILL_IF -TEMP[5].xxxx
> 35:   FSEQ TEMP[3].x, TEMP[6].wwww, IMM[1].yyyy
> 36:   AND TEMP[5], TEMP[3].xxxx, IMM[1].xxxx
> 37:   KILL_IF -TEMP[5].xxxx
> 38: ENDIF
> 39: MOV TEMP[5], CONST[37]
> 40: FSEQ TEMP[6].x, CONST[39].zzzz, IMM[1].xxxx
> 41: UIF TEMP[6].xxxx :0
> 42:   MOV TEMP[6].w, IMM[1].yyyy
> 43:   MOV TEMP[7].xy, IN[0].xyyy
> 44:   TEX TEMP[7], TEMP[7], SAMP[5], 2D
> 45:   POW TEMP[8].x, TEMP[7].xxxx, IMM[1].zzzz
> 46:   POW TEMP[8].y, TEMP[7].yyyy, IMM[1].zzzz
> 47:   POW TEMP[8].z, TEMP[7].zzzz, IMM[1].zzzz
> 48:   MOV TEMP[6].xyz, TEMP[8].xyzx
> 49:   MOV TEMP[5], TEMP[6]
> 50: ENDIF
> 51: MOV TEMP[6], CONST[33]
> 52: FSEQ TEMP[7].x, CONST[39].yyyy, IMM[1].xxxx
> 53: UIF TEMP[7].xxxx :0
> 54:   MOV TEMP[7].w, IMM[1].xxxx
> 55:   MOV TEMP[8].xy, IN[0].zwww
> 56:   TEX TEMP[8], TEMP[8], SAMP[4], 2D
> 57:   POW TEMP[9].x, TEMP[8].xxxx, IMM[1].zzzz
> 58:   POW TEMP[9].y, TEMP[8].yyyy, IMM[1].zzzz
> 59:   POW TEMP[9].z, TEMP[8].zzzz, IMM[1].zzzz
> 60:   MOV TEMP[7].xyz, TEMP[9].xyzx
> 61:   MOV TEMP[6], TEMP[7]
> 62: ENDIF
> 63: MOV TEMP[7].x, IMM[1].yyyy
> 64: MOV TEMP[8].x, IMM[1].yyyy
> 65: MOV TEMP[9].xyz, IMM[1].yyyy
> 66: MOV TEMP[10].xyz, IMM[1].yyyy
> 67: MOV TEMP[11].xyz, IMM[1].yyyy
> 68: MOV TEMP[12].xyz, IMM[1].yyyy
> 69: MOV TEMP[13].xyz, IMM[1].yyyy
> 70: MOV TEMP[14].xyz, IMM[1].yyyy
> 71: MOV TEMP[15].xyz, IMM[1].yyyy
> 72: MOV TEMP[16].x, IMM[1].yyyy
> 73: MOV TEMP[17].x, IMM[1].yyyy
> 74: MOV TEMP[18].xyz, IMM[1].yyyy
> 75: MOV TEMP[19].xyz, IMM[1].yyyy
> 76: MOV TEMP[20].xyz, IMM[1].yyyy
> 77: MOV TEMP[21].xyz, IMM[1].yyyy
> 78: FSEQ TEMP[22].x, CONST[38].wwww, IMM[1].xxxx
> 79: UIF TEMP[22].xxxx :0
> 80:   MOV TEMP[22].xy, IN[0].xyyy
> 81:   TEX TEMP[22], TEMP[22], SAMP[3], 2D
> 82:   MAD TEMP[21].xyz, IMM[2].xxxx, TEMP[22].xyzz, IMM[2].yyyy
> 83:   DDX TEMP[22].xyz, IN[3].yzww
> 84:   MUL TEMP[23], CONST[42].xxxx, IN[3].yzww
> 85:   DDY TEMP[23].xyz, TEMP[23]
> 86:   DDX TEMP[24].xy, IN[0].xyyy
> 87:   MUL TEMP[25], CONST[42].xxxx, IN[0].xyyy
> 88:   DDY TEMP[25].xy, TEMP[25]
> 89:   MUL TEMP[26].xyz, TEMP[23].zxyy, IN[1].yzxx
> 90:   MAD TEMP[23].xyz, TEMP[23].yzxx, IN[1].zxyy, -TEMP[26].xyzz
> 91:   MUL TEMP[26].xyz, IN[1].zxyy, TEMP[22].yzxx
> 92:   MAD TEMP[22].xyz, IN[1].yzxx, TEMP[22].zxyy, -TEMP[26].xyzz
> 93:   MUL TEMP[26].xyz, TEMP[23].xyzz, TEMP[24].xxxx
> 94:   MAD TEMP[26].xyz, TEMP[22].xyzz, TEMP[25].xxxx, TEMP[26].xyzz
> 95:   MUL TEMP[23].xyz, TEMP[23].xyzz, TEMP[24].yyyy
> 96:   MAD TEMP[22].xyz, TEMP[22].xyzz, TEMP[25].yyyy, TEMP[23].xyzz
> 97:   DP3 TEMP[23].x, TEMP[26].xyzz, TEMP[26].xyzz
> 98:   DP3 TEMP[24].x, TEMP[22].xyzz, TEMP[22].xyzz
> 99:   MAX TEMP[23].x, TEMP[23].xxxx, TEMP[24].xxxx
>100:   RSQ TEMP[23].x, TEMP[23].xxxx
>101:   MUL TEMP[22].xyz, TEMP[22].xyzz, TEMP[23].xxxx
>102:   MUL TEMP[23].xyz, TEMP[26].xyzz, TEMP[23].xxxx
>103:   MUL TEMP[23].xyz, TEMP[23].xyzz, TEMP[21].xxxx
>104:   MAD TEMP[22].xyz, TEMP[22].xyzz, TEMP[21].yyyy, TEMP[23].xyzz
>105:   MAD TEMP[21].xyz, IN[1].xyzz, TEMP[21].zzzz, TEMP[22].xyzz
>106:   DP3 TEMP[22].x, TEMP[21].xyzz, TEMP[21].xyzz
>107:   RSQ TEMP[22].x, TEMP[22].xxxx
>108:   MUL TEMP[21].xyz, TEMP[21].xyzz, TEMP[22].xxxx
>109:   MUL TEMP[22].xyz, CONST[29].xyzz, TEMP[21].xxxx
>110:   MAD TEMP[22].xyz, CONST[30].xyzz, TEMP[21].yyyy, TEMP[22].xyzz
>111:   MAD TEMP[21].xyz, CONST[31].xyzz, TEMP[21].zzzz, TEMP[22].xyzz
>112:   DP3 TEMP[22].x, TEMP[21].xyzz, TEMP[21].xyzz
>113:   RSQ TEMP[22].x, TEMP[22].xxxx
>114:   MUL TEMP[21].xyz, TEMP[21].xyzz, TEMP[22].xxxx
>115:   MOV TEMP[18].xyz, TEMP[21].xyzx
>116:   MUL TEMP[22].xyz, CONST[25].xyzz, TEMP[21].xxxx
>117:   MAD TEMP[22].xyz, CONST[26].xyzz, TEMP[21].yyyy, TEMP[22].xyzz
>118:   MAD TEMP[21].xyz, CONST[27].xyzz, TEMP[21].zzzz, TEMP[22].xyzz
>119:   DP3 TEMP[22].x, TEMP[21].xyzz, TEMP[21].xyzz
>120:   RSQ TEMP[22].x, TEMP[22].xxxx
>121:   MUL TEMP[19].xyz, TEMP[21].xyzz, TEMP[22].xxxx
>122: ELSE :0
>123:   DP3 TEMP[21].x, TEMP[0].xyzz, TEMP[0].xyzz
>124:   RSQ TEMP[21].x, TEMP[21].xxxx
>125:   MUL TEMP[18].xyz, TEMP[0].xyzz, TEMP[21].xxxx
>126:   DP3 TEMP[21].x, TEMP[1].xyzz, TEMP[1].xyzz
>127:   RSQ TEMP[21].x, TEMP[21].xxxx
>128:   MUL TEMP[19].xyz, TEMP[1].xyzz, TEMP[21].xxxx
>129: ENDIF
>130: DDX TEMP[1].xyz, TEMP[18].xyzz
>131: ABS TEMP[1].xyz, TEMP[1].xyzz
>132: MUL TEMP[21], CONST[42].xxxx, TEMP[18].xyzz
>133: DDY TEMP[18].xyz, TEMP[21]
>134: ABS TEMP[18].xyz, TEMP[18].xyzz
>135: ADD TEMP[1].xyz, TEMP[1].xyzz, TEMP[18].xyzz
>136: DP3 TEMP[1].x, TEMP[1].xyzz, TEMP[1].xyzz
>137: SQRT TEMP[1].x, TEMP[1].xxxx
>138: MOV_SAT TEMP[1].x, TEMP[1].xxxx
>139: MUL TEMP[1].x, TEMP[1].xxxx, TEMP[1].xxxx
>140: MUL TEMP[0].x, TEMP[1].xxxx, IMM[2].zzzz
>141: MOV TEMP[1], IMM[1].yyyy
>142: MOV TEMP[18], IMM[1].yyyy
>143: FSEQ TEMP[21].x, CONST[38].xxxx, IMM[1].xxxx
>144: UIF TEMP[21].xxxx :0
>145:   MOV TEMP[18], TEMP[4]
>146: ELSE :0
>147:   MOV TEMP[18], CONST[34]
>148: ENDIF
>149: FSEQ TEMP[4].x, CONST[40].xxxx, IMM[1].xxxx
>150: UIF TEMP[4].xxxx :0
>151:   MOV TEMP[4].x, IN[0].zzzz
>152:   ADD TEMP[21].x, IMM[1].xxxx, -IN[0].wwww
>153:   MOV TEMP[4].y, TEMP[21].xxxx
>154:   MUL TEMP[4].xy, TEMP[4].xyyy, CONST[21].xyyy
>155:   ADD TEMP[4].xy, TEMP[4].xyyy, CONST[21].zwww
>156:   ADD TEMP[21].x, IMM[1].xxxx, -TEMP[4].yyyy
>157:   MOV TEMP[4].y, TEMP[21].xxxx
>158:   MOV TEMP[4].xy, TEMP[4].xyyy
>159:   TEX TEMP[4], TEMP[4], SAMP[6], 2D
>160:   POW TEMP[21].x, TEMP[4].xxxx, IMM[1].zzzz
>161:   POW TEMP[21].y, TEMP[4].yyyy, IMM[1].zzzz
>162:   POW TEMP[21].z, TEMP[4].zzzz, IMM[1].zzzz
>163:   POW TEMP[21].w, TEMP[4].wwww, IMM[1].xxxx
>164:   MUL TEMP[18].xyz, TEMP[18].xyzz, TEMP[21].xyzz
>165: ENDIF
>166: FSEQ TEMP[4].x, CONST[24].xxxx, IMM[1].xxxx
>167: UIF TEMP[4].xxxx :0
>168:   FSEQ TEMP[4].x, CONST[38].zzzz, IMM[1].xxxx
>169:   UIF TEMP[4].xxxx :0
>170:     MOV TEMP[4].xy, IN[0].xyyy
>171:     TEX TEMP[4], TEMP[4], SAMP[2], 2D
>172:     ADD TEMP[7].x, IMM[1].xxxx, -TEMP[4].xxxx
>173:   ELSE :0
>174:     FSLT TEMP[4].x, CONST[36].xxxx, IMM[2].wwww
>175:     UIF TEMP[4].xxxx :0
>176:       MAD TEMP[4].x, IMM[3].xxxx, CONST[36].xxxx, IMM[3].yyyy
>177:       MAX TEMP[4].x, TEMP[4].xxxx, IMM[3].zzzz
>178:       MIN TEMP[4].x, TEMP[4].xxxx, IMM[3].wwww
>179:       LG2 TEMP[4].x, TEMP[4].xxxx
>180:       ADD TEMP[4].x, TEMP[4].xxxx, IMM[4].xxxx
>181:       MUL TEMP[7].x, TEMP[4].xxxx, IMM[4].yyyy
>182:       ADD TEMP[7].x, IMM[1].xxxx, -TEMP[7].xxxx
>183:     ELSE :0
>184:       MOV TEMP[7].x, IMM[1].yyyy
>185:     ENDIF
>186:   ENDIF
>187:   ADD TEMP[7].x, TEMP[7].xxxx, TEMP[0].xxxx
>188:   MAD TEMP[8].x, TEMP[7].xxxx, TEMP[7].xxxx, TEMP[0].xxxx
>189:   MAX TEMP[0].x, TEMP[7].xxxx, IMM[4].zzzz
>190:   MOV_SAT TEMP[0].x, TEMP[0].xxxx
>191:   MOV TEMP[7].x, TEMP[0].xxxx
>192:   MAX TEMP[4].x, TEMP[8].xxxx, IMM[4].zzzz
>193:   MOV_SAT TEMP[4].x, TEMP[4].xxxx
>194:   MOV TEMP[8].x, TEMP[4].xxxx
>195:   FSEQ TEMP[7].x, CONST[38].yyyy, IMM[1].xxxx
>196:   UIF TEMP[7].xxxx :0
>197:     MOV TEMP[7].xy, IN[0].xyyy
>198:     TEX TEMP[7], TEMP[7], SAMP[1], 2D
>199:     POW TEMP[8].x, TEMP[7].xxxx, IMM[1].zzzz
>200:     POW TEMP[8].y, TEMP[7].yyyy, IMM[1].zzzz
>201:     POW TEMP[8].z, TEMP[7].zzzz, IMM[1].zzzz
>202:     MOV TEMP[11].xyz, TEMP[8].xyzx
>203:   ELSE :0
>204:     MOV TEMP[11].xyz, CONST[35].xyzx
>205:   ENDIF
>206:   MOV TEMP[7].xyz, IMM[1].yyyy
>207:   MOV TEMP[7].w, TEMP[18].wwww
>208:   MOV TEMP[1], TEMP[7]
>209:   MOV TEMP[7].xyz, -IN[4].xyzx
>210:   DP3 TEMP[8].x, TEMP[7].xyzz, TEMP[7].xyzz
>211:   RSQ TEMP[8].x, TEMP[8].xxxx
>212:   MUL TEMP[7].xyz, TEMP[7].xyzz, TEMP[8].xxxx
>213:   MUL TEMP[8].xyz, CONST[25].xyzz, TEMP[7].xxxx
>214:   MAD TEMP[8].xyz, CONST[26].xyzz, TEMP[7].yyyy, TEMP[8].xyzz
>215:   MAD TEMP[7].xyz, CONST[27].xyzz, TEMP[7].zzzz, TEMP[8].xyzz
>216:   DP3 TEMP[8].x, TEMP[19].xyzz, TEMP[7].xyzz
>217:   MOV_SAT TEMP[8].x, TEMP[8].xxxx
>218:   MOV TEMP[21].x, IMM[5].xxxx
>219:   BGNLOOP :0
>220:     ISGE TEMP[22].x, TEMP[21].xxxx, IMM[5].yyyy
>221:     UIF TEMP[22].xxxx :0
>222:       BRK
>223:     ENDIF
>224:     UMUL TEMP[23].x, TEMP[21].xxxx, IMM[0].yyyy
>225:     USHR TEMP[24], TEMP[23].xxxx, IMM[5].zzzz
>226:     UARL ADDR[0].x, TEMP[24].xxxx
>227:     UARL ADDR[0].x, TEMP[24].xxxx
>228:     MOV TEMP[25], CONST[1][ADDR[0].x]
>229:     FSEQ TEMP[26].x, TEMP[25].wwww, IMM[4].xxxx
>230:     UIF TEMP[26].xxxx :0
>231:       BRK
>232:     ENDIF
>233:     UMUL TEMP[27].x, TEMP[21].xxxx, IMM[0].yyyy
>234:     USHR TEMP[28], TEMP[27].xxxx, IMM[5].zzzz
>235:     UARL ADDR[0].x, TEMP[28].xxxx
>236:     UARL ADDR[0].x, TEMP[28].xxxx
>237:     MOV TEMP[29], CONST[1][ADDR[0].x]
>238:     MOV TEMP[30].xyz, TEMP[29].xyzx
>239:     UMUL TEMP[31].x, TEMP[21].xxxx, IMM[0].yyyy
>240:     USHR TEMP[32], TEMP[31].xxxx, IMM[5].zzzz
>241:     UARL ADDR[0].x, TEMP[32].xxxx
>242:     UARL ADDR[0].x, TEMP[32].xxxx
>243:     MOV TEMP[33], CONST[1][ADDR[0].x]
>244:     FSNE TEMP[34].x, TEMP[33].wwww, IMM[1].xxxx
>245:     UIF TEMP[34].xxxx :0
>246:       UMAD TEMP[35].x, TEMP[21].xxxx, IMM[0].yyyy, IMM[0].zzzz
>247:       USHR TEMP[36], TEMP[35].xxxx, IMM[5].zzzz
>248:       UARL ADDR[0].x, TEMP[36].xxxx
>249:       MOV TEMP[37], CONST[1][ADDR[0].x]
>250:       ADD TEMP[38].xyz, TEMP[37].xyzz, -TEMP[2].xyzz
>251:       DP3 TEMP[39].x, TEMP[38].xyzz, TEMP[38].xyzz
>252:       SQRT TEMP[40].x, TEMP[39].xxxx
>253:       MUL TEMP[16].x, TEMP[40].xxxx, TEMP[40].xxxx
>254:       UMAD TEMP[41].x, TEMP[21].xxxx, IMM[0].yyyy, IMM[0].zzzz
>255:       USHR TEMP[42], TEMP[41].xxxx, IMM[5].zzzz
>256:       UARL ADDR[0].x, TEMP[42].xxxx
>257:       UARL ADDR[0].x, TEMP[42].xxxx
>258:       MOV TEMP[43], CONST[1][ADDR[0].x]
>259:       FSLT TEMP[44].x, TEMP[43].wwww, TEMP[16].xxxx
>260:       UIF TEMP[44].xxxx :0
>261:         UADD TEMP[21].x, TEMP[21].xxxx, IMM[5].wwww
>262:         UIF TEMP[3].xxxx :0
>263:           BRK
>264:         ENDIF
>265:         CONT
>266:       ENDIF
>267:       MUL TEMP[16].x, TEMP[40].xxxx, TEMP[40].xxxx
>268:       RCP TEMP[45].x, TEMP[40].xxxx
>269:       MUL TEMP[20].xyz, TEMP[38].xyzz, TEMP[45].xxxx
>270:       ADD TEMP[46].x, TEMP[16].xxxx, IMM[1].xxxx
>271:       RCP TEMP[17].x, TEMP[46].xxxx
>272:       MUL TEMP[30].xyz, TEMP[29].xyzz, TEMP[17].xxxx
>273:     ENDIF
>274:     UMUL TEMP[47].x, TEMP[21].xxxx, IMM[0].yyyy
>275:     USHR TEMP[48], TEMP[47].xxxx, IMM[5].zzzz
>276:     UARL ADDR[0].x, TEMP[48].xxxx
>277:     UARL ADDR[0].x, TEMP[48].xxxx
>278:     MOV TEMP[49], CONST[1][ADDR[0].x]
>279:     FSEQ TEMP[50].x, TEMP[49].wwww, IMM[1].xxxx
>280:     UIF TEMP[50].xxxx :0
>281:       UMAD TEMP[51].x, TEMP[21].xxxx, IMM[0].yyyy, IMM[0].wwww
>282:       USHR TEMP[52], TEMP[51].xxxx, IMM[5].zzzz
>283:       UARL ADDR[0].x, TEMP[52].xxxx
>284:       MOV TEMP[53], CONST[1][ADDR[0].x]
>285:       MOV TEMP[20].xyz, -TEMP[53].xyzx
>286:     ENDIF
>287:     DP3 TEMP[54].x, TEMP[19].xyzz, TEMP[20].xyzz
>288:     MOV_SAT TEMP[55].x, TEMP[54].xxxx
>289:     UMUL TEMP[56].x, TEMP[21].xxxx, IMM[0].yyyy
>290:     USHR TEMP[57], TEMP[56].xxxx, IMM[5].zzzz
>291:     UARL ADDR[0].x, TEMP[57].xxxx
>292:     UARL ADDR[0].x, TEMP[57].xxxx
>293:     MOV TEMP[58], CONST[1][ADDR[0].x]
>294:     UMUL TEMP[59].x, TEMP[21].xxxx, IMM[0].yyyy
>295:     USHR TEMP[60], TEMP[59].xxxx, IMM[5].zzzz
>296:     UARL ADDR[0].x, TEMP[60].xxxx
>297:     UARL ADDR[0].x, TEMP[60].xxxx
>298:     MOV TEMP[61], CONST[1][ADDR[0].x]
>299:     FSLT TEMP[62].x, IMM[1].yyyy, TEMP[58].wwww
>300:     FSLT TEMP[63].x, TEMP[61].wwww, IMM[1].xxxx
>301:     AND TEMP[64].x, TEMP[62].xxxx, TEMP[63].xxxx
>302:     UIF TEMP[64].xxxx :0
>303:       UMAD TEMP[65].x, TEMP[21].xxxx, IMM[0].yyyy, IMM[0].wwww
>304:       USHR TEMP[66], TEMP[65].xxxx, IMM[5].zzzz
>305:       UARL ADDR[0].x, TEMP[66].xxxx
>306:       MOV TEMP[67], CONST[1][ADDR[0].x]
>307:       DP3 TEMP[68].x, -TEMP[20].xyzz, TEMP[67].xyzz
>308:       UMUL TEMP[69].x, TEMP[21].xxxx, IMM[0].yyyy
>309:       USHR TEMP[70], TEMP[69].xxxx, IMM[5].zzzz
>310:       UARL ADDR[0].x, TEMP[70].xxxx
>311:       UARL ADDR[0].x, TEMP[70].xxxx
>312:       MOV TEMP[71], CONST[1][ADDR[0].x]
>313:       FSLT TEMP[72].x, TEMP[68].xxxx, TEMP[71].wwww
>314:       UIF TEMP[72].xxxx :0
>315:         UADD TEMP[21].x, TEMP[21].xxxx, IMM[5].wwww
>316:         UIF TEMP[3].xxxx :0
>317:           BRK
>318:         ENDIF
>319:         CONT
>320:       ELSE :0
>321:         UMAD TEMP[73].x, TEMP[21].xxxx, IMM[0].yyyy, IMM[0].wwww
>322:         USHR TEMP[74], TEMP[73].xxxx, IMM[5].zzzz
>323:         UARL ADDR[0].x, TEMP[74].xxxx
>324:         MOV TEMP[75], CONST[1][ADDR[0].x]
>325:         POW TEMP[76].x, TEMP[68].xxxx, TEMP[75].wwww
>326:         MUL TEMP[30].xyz, TEMP[30].xyzz, TEMP[76].xxxx
>327:       ENDIF
>328:     ENDIF
>329:     ADD TEMP[77].xyz, TEMP[7].xyzz, TEMP[20].xyzz
>330:     DP3 TEMP[78].x, TEMP[77].xyzz, TEMP[77].xyzz
>331:     RSQ TEMP[79].x, TEMP[78].xxxx
>332:     MUL TEMP[80].xyz, TEMP[77].xyzz, TEMP[79].xxxx
>333:     MUL TEMP[30].xyz, TEMP[30].xyzz, TEMP[55].xxxx
>334:     ADD TEMP[12].xyz, TEMP[12].xyzz, TEMP[30].xyzz
>335:     DP3 TEMP[81].x, TEMP[19].xyzz, TEMP[80].xyzz
>336:     MOV_SAT TEMP[82].x, TEMP[81].xxxx
>337:     MUL TEMP[83].x, TEMP[4].xxxx, TEMP[4].xxxx
>338:     MAD TEMP[84].x, TEMP[82].xxxx, TEMP[83].xxxx, -TEMP[82].xxxx
>339:     MAD TEMP[85].x, TEMP[84].xxxx, TEMP[82].xxxx, IMM[1].xxxx
>340:     MUL TEMP[86].x, TEMP[4].xxxx, IMM[4].wwww
>341:     DP3 TEMP[87].x, TEMP[7].xyzz, TEMP[80].xyzz
>342:     MOV_SAT TEMP[88].x, TEMP[87].xxxx
>343:     ADD TEMP[89].x, IMM[1].xxxx, -TEMP[88].xxxx
>344:     POW TEMP[90].x, TEMP[89].xxxx, IMM[6].xxxx
>345:     MUL TEMP[91].x, IMM[6].yyyy, TEMP[85].xxxx
>346:     MUL TEMP[92].x, TEMP[91].xxxx, TEMP[85].xxxx
>347:     RCP TEMP[93].x, TEMP[92].xxxx
>348:     MUL TEMP[94].x, TEMP[83].xxxx, TEMP[93].xxxx
>349:     LRP TEMP[95].x, TEMP[8].xxxx, IMM[1].xxxx, TEMP[86].xxxx
>350:     LRP TEMP[96].x, TEMP[55].xxxx, IMM[1].xxxx, TEMP[86].xxxx
>351:     ADD TEMP[97].x, TEMP[95].xxxx, TEMP[96].xxxx
>352:     RCP TEMP[98].x, TEMP[97].xxxx
>353:     MUL TEMP[99].x, IMM[6].zzzz, TEMP[98].xxxx
>354:     MUL TEMP[100].x, TEMP[94].xxxx, TEMP[99].xxxx
>355:     ADD TEMP[101].x, IMM[1].xxxx, -TEMP[90].xxxx
>356:     MUL TEMP[102].x, IMM[6].wwww, TEMP[11].yyyy
>357:     MOV_SAT TEMP[103].x, TEMP[102].xxxx
>358:     MUL TEMP[104].x, TEMP[103].xxxx, TEMP[90].xxxx
>359:     MAD TEMP[105].xyz, TEMP[101].xxxx, TEMP[11].xyzz, TEMP[104].xxxx
>360:     MUL TEMP[106].xyz, TEMP[100].xxxx, TEMP[105].xyzz
>361:     MAD TEMP[13].xyz, TEMP[106].xyzz, TEMP[30].xyzz, TEMP[13].xyzz
>362:     UADD TEMP[21].x, TEMP[21].xxxx, IMM[5].wwww
>363:     UIF TEMP[3].xxxx :0
>364:       BRK
>365:     ENDIF
>366:   ENDLOOP :0
>367:   MUL TEMP[2].xyz, TEMP[18].xyzz, IMM[7].xxxx
>368:   MUL TEMP[12].xyz, TEMP[12].xyzz, TEMP[2].xyzz
>369:   ADD TEMP[1].xyz, TEMP[12].xyzz, TEMP[13].xyzz
>370:   MUL TEMP[2].x, CONST[19].yyyy, CONST[18].zzzz
>371:   MAD TEMP[2].x, CONST[18].yyyy, CONST[19].zzzz, -TEMP[2].xxxx
>372:   MUL TEMP[3].x, CONST[19].xxxx, CONST[18].zzzz
>373:   MAD TEMP[3].x, CONST[18].xxxx, CONST[19].zzzz, -TEMP[3].xxxx
>374:   MUL TEMP[12].x, CONST[19].xxxx, CONST[18].yyyy
>375:   MAD TEMP[12].x, CONST[18].xxxx, CONST[19].yyyy, -TEMP[12].xxxx
>376:   MOV TEMP[13].x, TEMP[2].xxxx
>377:   MOV TEMP[16].x, -TEMP[3].xxxx
>378:   MOV TEMP[17].x, TEMP[12].xxxx
>379:   MUL TEMP[20].x, CONST[19].yyyy, CONST[17].zzzz
>380:   MAD TEMP[20].x, CONST[17].yyyy, CONST[19].zzzz, -TEMP[20].xxxx
>381:   MOV TEMP[13].y, -TEMP[20].xxxx
>382:   MUL TEMP[20].x, CONST[19].xxxx, CONST[17].zzzz
>383:   MAD TEMP[20].x, CONST[17].xxxx, CONST[19].zzzz, -TEMP[20].xxxx
>384:   MOV TEMP[16].y, TEMP[20].xxxx
>385:   MUL TEMP[20].x, CONST[19].xxxx, CONST[17].yyyy
>386:   MAD TEMP[20].x, CONST[17].xxxx, CONST[19].yyyy, -TEMP[20].xxxx
>387:   MOV TEMP[17].y, -TEMP[20].xxxx
>388:   MUL TEMP[20].x, CONST[18].yyyy, CONST[17].zzzz
>389:   MAD TEMP[20].x, CONST[17].yyyy, CONST[18].zzzz, -TEMP[20].xxxx
>390:   MOV TEMP[13].z, TEMP[20].xxxx
>391:   MUL TEMP[20].x, CONST[18].xxxx, CONST[17].zzzz
>392:   MAD TEMP[20].x, CONST[17].xxxx, CONST[18].zzzz, -TEMP[20].xxxx
>393:   MOV TEMP[16].z, -TEMP[20].xxxx
>394:   MUL TEMP[20].x, CONST[18].xxxx, CONST[17].yyyy
>395:   MAD TEMP[20].x, CONST[17].xxxx, CONST[18].yyyy, -TEMP[20].xxxx
>396:   MOV TEMP[17].z, TEMP[20].xxxx
>397:   MUL TEMP[3].x, CONST[17].yyyy, TEMP[3].xxxx
>398:   MAD TEMP[2].x, CONST[17].xxxx, TEMP[2].xxxx, -TEMP[3].xxxx
>399:   MAD TEMP[2].x, CONST[17].zzzz, TEMP[12].xxxx, TEMP[2].xxxx
>400:   RCP TEMP[3].x, TEMP[2].xxxx
>401:   MUL TEMP[3].xyz, TEMP[17].xyzz, TEMP[3].xxxx
>402:   RCP TEMP[12].x, TEMP[2].xxxx
>403:   MUL TEMP[12].xyz, TEMP[16].xyzz, TEMP[12].xxxx
>404:   RCP TEMP[2].x, TEMP[2].xxxx
>405:   MUL TEMP[2].xyz, TEMP[13].xyzz, TEMP[2].xxxx
>406:   MUL TEMP[2].xyz, TEMP[2].xyzz, TEMP[19].xxxx
>407:   MAD TEMP[2].xyz, TEMP[12].xyzz, TEMP[19].yyyy, TEMP[2].xyzz
>408:   MAD TEMP[2].xyz, TEMP[3].xyzz, TEMP[19].zzzz, TEMP[2].xyzz
>409:   FSEQ TEMP[3].x, CONST[41].xxxx, IMM[1].yyyy
>410:   UIF TEMP[3].xxxx :0
>411:     DP3 TEMP[3].x, TEMP[2].xyzz, TEMP[2].xyzz
>412:     RSQ TEMP[3].x, TEMP[3].xxxx
>413:     MUL TEMP[3].xyz, TEMP[2].xyzz, TEMP[3].xxxx
>414:     MUL TEMP[12].xyz, IMM[8].xxyy, TEMP[3].yyyy
>415:     MUL TEMP[13].xyz, IMM[8].zwww, TEMP[3].xxxx
>416:     MUL TEMP[16].xyz, IMM[10].xxyy, TEMP[3].zzzz
>417:     MUL TEMP[17].x, TEMP[3].yyyy, TEMP[3].yyyy
>418:     MAD TEMP[17].x, TEMP[3].xxxx, TEMP[3].xxxx, -TEMP[17].xxxx
>419:     MUL TEMP[17].xyz, IMM[10].zzww, TEMP[17].xxxx
>420:     MAD TEMP[16].xyz, TEMP[16].xyzz, TEMP[3].zzzz, TEMP[17].xyzz
>421:     ADD TEMP[16].xyz, IMM[9].xyzz, TEMP[16].xyzz
>422:     MAD TEMP[13].xyz, TEMP[13].xyzz, TEMP[3].yyyy, TEMP[16].xyzz
>423:     MAD TEMP[12].xyz, TEMP[12].xyzz, TEMP[3].zzzz, TEMP[13].xyzz
>424:     MAD TEMP[12].xyz, IMM[7].wwww, TEMP[3].xxxx, TEMP[12].xyzz
>425:     MAD TEMP[3].y, IMM[7].yyzz, TEMP[3].yyyy, TEMP[12].xyzz
>426:     MAX TEMP[9].xyz, TEMP[3].yyyy, IMM[4].yyyy
>427:   ELSE :0
>428:     MOV TEMP[3].xy, TEMP[2].xyxx
>429:     MOV TEMP[3].z, -TEMP[2].zzzz
>430:     MOV TEMP[2].xyz, TEMP[3].xyzz
>431:     MOV TEMP[2].w, IMM[1].yyyy
>432:     TXL TEMP[2].xyz, TEMP[2], SAMP[8], CUBE
>433:     POW TEMP[12].x, TEMP[2].xxxx, IMM[1].zzzz
>434:     POW TEMP[12].y, TEMP[2].yyyy, IMM[1].zzzz
>435:     POW TEMP[12].z, TEMP[2].zzzz, IMM[1].zzzz
>436:     MOV TEMP[9].xyz, TEMP[12].xyzx
>437:   ENDIF
>438:   MUL TEMP[14].xyz, TEMP[18].xyzz, TEMP[9].xyzz
>439:   MUL TEMP[0].x, TEMP[0].xxxx, IMM[9].wwww
>440:   MAX TEMP[0].x, TEMP[0].xxxx, IMM[1].xxxx
>441:   MIN TEMP[0].x, TEMP[0].xxxx, IMM[9].wwww
>442:   MOV TEMP[2].xyz, -TEMP[7].xyzx
>443:   MUL TEMP[7].x, CONST[19].yyyy, CONST[18].zzzz
>444:   MAD TEMP[7].x, CONST[18].yyyy, CONST[19].zzzz, -TEMP[7].xxxx
>445:   MUL TEMP[9].x, CONST[19].xxxx, CONST[18].zzzz
>446:   MAD TEMP[9].x, CONST[18].xxxx, CONST[19].zzzz, -TEMP[9].xxxx
>447:   MUL TEMP[12].x, CONST[19].xxxx, CONST[18].yyyy
>448:   MAD TEMP[12].x, CONST[18].xxxx, CONST[19].yyyy, -TEMP[12].xxxx
>449:   MOV TEMP[13].x, TEMP[7].xxxx
>450:   MOV TEMP[16].x, -TEMP[9].xxxx
>451:   MOV TEMP[17].x, TEMP[12].xxxx
>452:   MUL TEMP[20].x, CONST[19].yyyy, CONST[17].zzzz
>453:   MAD TEMP[20].x, CONST[17].yyyy, CONST[19].zzzz, -TEMP[20].xxxx
>454:   MOV TEMP[13].y, -TEMP[20].xxxx
>455:   MUL TEMP[20].x, CONST[19].xxxx, CONST[17].zzzz
>456:   MAD TEMP[20].x, CONST[17].xxxx, CONST[19].zzzz, -TEMP[20].xxxx
>457:   MOV TEMP[16].y, TEMP[20].xxxx
>458:   MUL TEMP[20].x, CONST[19].xxxx, CONST[17].yyyy
>459:   MAD TEMP[20].x, CONST[17].xxxx, CONST[19].yyyy, -TEMP[20].xxxx
>460:   MOV TEMP[17].y, -TEMP[20].xxxx
>461:   MUL TEMP[20].x, CONST[18].yyyy, CONST[17].zzzz
>462:   MAD TEMP[20].x, CONST[17].yyyy, CONST[18].zzzz, -TEMP[20].xxxx
>463:   MOV TEMP[13].z, TEMP[20].xxxx
>464:   MUL TEMP[20].x, CONST[18].xxxx, CONST[17].zzzz
>465:   MAD TEMP[20].x, CONST[17].xxxx, CONST[18].zzzz, -TEMP[20].xxxx
>466:   MOV TEMP[16].z, -TEMP[20].xxxx
>467:   MUL TEMP[20].x, CONST[18].xxxx, CONST[17].yyyy
>468:   MAD TEMP[20].x, CONST[17].xxxx, CONST[18].yyyy, -TEMP[20].xxxx
>469:   MOV TEMP[17].z, TEMP[20].xxxx
>470:   MUL TEMP[9].x, CONST[17].yyyy, TEMP[9].xxxx
>471:   MAD TEMP[7].x, CONST[17].xxxx, TEMP[7].xxxx, -TEMP[9].xxxx
>472:   MAD TEMP[7].x, CONST[17].zzzz, TEMP[12].xxxx, TEMP[7].xxxx
>473:   DP3 TEMP[9].x, TEMP[19].xyzz, TEMP[2].xyzz
>474:   MUL TEMP[9].xyz, TEMP[9].xxxx, TEMP[19].xyzz
>475:   MUL TEMP[9].xyz, IMM[3].zzzz, TEMP[9].xyzz
>476:   ADD TEMP[2].xyz, TEMP[2].xyzz, -TEMP[9].xyzz
>477:   RCP TEMP[9].x, TEMP[7].xxxx
>478:   MUL TEMP[9].xyz, TEMP[17].xyzz, TEMP[9].xxxx
>479:   RCP TEMP[12].x, TEMP[7].xxxx
>480:   MUL TEMP[12].xyz, TEMP[16].xyzz, TEMP[12].xxxx
>481:   RCP TEMP[7].x, TEMP[7].xxxx
>482:   MUL TEMP[7].xyz, TEMP[13].xyzz, TEMP[7].xxxx
>483:   MUL TEMP[7].xyz, TEMP[7].xyzz, TEMP[2].xxxx
>484:   MAD TEMP[7].xyz, TEMP[12].xyzz, TEMP[2].yyyy, TEMP[7].xyzz
>485:   MAD TEMP[2].xyz, TEMP[9].xyzz, TEMP[2].zzzz, TEMP[7].xyzz
>486:   MOV TEMP[3].xy, TEMP[2].xyxx
>487:   MOV TEMP[3].z, -TEMP[2].zzzz
>488:   FSEQ TEMP[7].x, CONST[40].wwww, IMM[1].yyyy
>489:   UIF TEMP[7].xxxx :0
>490:     MUL TEMP[7].xyz, IMM[8].xxyy, TEMP[2].yyyy
>491:     MUL TEMP[9].xyz, IMM[8].zwww, TEMP[2].xxxx
>492:     MUL TEMP[12].xyz, IMM[10].xxyy, TEMP[2].zzzz
>493:     MUL TEMP[13].x, TEMP[2].yyyy, TEMP[2].yyyy
>494:     MAD TEMP[13].x, TEMP[2].xxxx, TEMP[2].xxxx, -TEMP[13].xxxx
>495:     MUL TEMP[13].xyz, IMM[10].zzww, TEMP[13].xxxx
>496:     MAD TEMP[12].xyz, TEMP[12].xyzz, TEMP[2].zzzz, TEMP[13].xyzz
>497:     ADD TEMP[12].xyz, IMM[9].xyzz, TEMP[12].xyzz
>498:     MAD TEMP[9].xyz, TEMP[9].xyzz, TEMP[2].yyyy, TEMP[12].xyzz
>499:     MAD TEMP[7].xyz, TEMP[7].xyzz, TEMP[2].zzzz, TEMP[9].xyzz
>500:     MAD TEMP[7].xyz, IMM[7].wwww, TEMP[2].xxxx, TEMP[7].xyzz
>501:     MAD TEMP[2].y, IMM[7].yyzz, TEMP[2].yyyy, TEMP[7].xyzz
>502:     MAX TEMP[10].xyz, TEMP[2].yyyy, IMM[11].xxxx
>503:   ELSE :0
>504:     FSEQ TEMP[2].x, TEMP[4].xxxx, IMM[4].zzzz
>505:     UIF TEMP[2].xxxx :0
>506:       MOV TEMP[2].xyz, TEMP[3].xyzz
>507:       MOV TEMP[2].w, IMM[1].yyyy
>508:       TXL TEMP[2].xyz, TEMP[2], SAMP[7], CUBE
>509:       POW TEMP[7].x, TEMP[2].xxxx, IMM[1].zzzz
>510:       POW TEMP[7].y, TEMP[2].yyyy, IMM[1].zzzz
>511:       POW TEMP[7].z, TEMP[2].zzzz, IMM[1].zzzz
>512:       MOV TEMP[10].xyz, TEMP[7].xyzx
>513:     ELSE :0
>514:       MOV TEMP[2].xyz, TEMP[3].xyzz
>515:       MOV TEMP[2].w, TEMP[0].xxxx
>516:       TXL TEMP[0].xyz, TEMP[2], SAMP[7], CUBE
>517:       POW TEMP[2].x, TEMP[0].xxxx, IMM[1].zzzz
>518:       POW TEMP[2].y, TEMP[0].yyyy, IMM[1].zzzz
>519:       POW TEMP[2].z, TEMP[0].zzzz, IMM[1].zzzz
>520:       MOV TEMP[10].xyz, TEMP[2].xyzx
>521:     ENDIF
>522:   ENDIF
>523:   MAD TEMP[0], TEMP[4].xxxx, IMM[12], IMM[13]
>524:   MUL TEMP[2].x, TEMP[0].xxxx, TEMP[0].xxxx
>525:   MUL TEMP[3].x, IMM[11].wwww, TEMP[8].xxxx
>526:   EX2 TEMP[3].x, TEMP[3].xxxx
>527:   MIN TEMP[2].x, TEMP[2].xxxx, TEMP[3].xxxx
>528:   MAD TEMP[2].x, TEMP[2].xxxx, TEMP[0].xxxx, TEMP[0].yyyy
>529:   MAD TEMP[0].xy, IMM[11].yzzz, TEMP[2].xxxx, TEMP[0].zwww
>530:   MUL TEMP[2].x, IMM[6].wwww, TEMP[11].yyyy
>531:   MOV_SAT TEMP[2].x, TEMP[2].xxxx
>532:   MUL TEMP[2].x, TEMP[0].yyyy, TEMP[2].xxxx
>533:   MAD TEMP[0].xyz, TEMP[11].xyzz, TEMP[0].xxxx, TEMP[2].xxxx
>534:   MUL TEMP[15].xyz, TEMP[0].xyzz, TEMP[10].xyzz
>535:   ADD TEMP[0].xyz, TEMP[14].xyzz, TEMP[15].xyzz
>536:   MAD TEMP[1].xyz, TEMP[0].xyzz, TEMP[6].xyzz, TEMP[1].xyzz
>537: ENDIF
>538: MOV TEMP[0], CONST[22]
>539: FSEQ TEMP[2].x, CONST[24].xxxx, IMM[1].xxxx
>540: UIF TEMP[2].xxxx :0
>541:   ADD TEMP[1], TEMP[1], TEMP[5]
>542:   MUL TEMP[0], CONST[22], TEMP[1]
>543: ELSE :0
>544:   MAD TEMP[1], TEMP[18], TEMP[6], TEMP[5]
>545:   MUL TEMP[0], TEMP[0], TEMP[1]
>546: ENDIF
>547: FSEQ TEMP[1].x, CONST[11].xxxx, IMM[1].xxxx
>548: UIF TEMP[1].xxxx :0
>549:   DP3 TEMP[1].x, IN[4].xyzz, IN[4].xyzz
>550:   SQRT TEMP[1].x, TEMP[1].xxxx
>551:   FSEQ TEMP[2].x, CONST[12].xxxx, IMM[1].yyyy
>552:   UIF TEMP[2].xxxx :0
>553:     ADD TEMP[2].x, CONST[15].xxxx, -TEMP[1].xxxx
>554:     ADD TEMP[3].x, CONST[15].xxxx, -CONST[14].xxxx
>555:     RCP TEMP[3].x, TEMP[3].xxxx
>556:     MUL TEMP[2].x, TEMP[2].xxxx, TEMP[3].xxxx
>557:   ELSE :0
>558:     FSEQ TEMP[3].x, CONST[12].xxxx, IMM[1].xxxx
>559:     UIF TEMP[3].xxxx :0
>560:       MUL TEMP[3].x, -CONST[13].xxxx, TEMP[1].xxxx
>561:       MUL TEMP[3].x, TEMP[3].xxxx, IMM[14].xxxx
>562:       EX2 TEMP[2].x, TEMP[3].xxxx
>563:     ELSE :0
>564:       MUL TEMP[3].x, CONST[13].xxxx, TEMP[1].xxxx
>565:       MUL TEMP[1].x, CONST[13].xxxx, TEMP[1].xxxx
>566:       MUL TEMP[1].x, -TEMP[3].xxxx, TEMP[1].xxxx
>567:       MUL TEMP[1].x, TEMP[1].xxxx, IMM[14].xxxx
>568:       EX2 TEMP[2].x, TEMP[1].xxxx
>569:     ENDIF
>570:   ENDIF
>571:   MOV_SAT TEMP[1].x, TEMP[2].xxxx
>572:   LRP TEMP[0], TEMP[1].xxxx, TEMP[0], CONST[16]
>573: ENDIF
>574: MOV TEMP[1].w, TEMP[0].wwww
>575: MUL TEMP[1].xyz, TEMP[0].xyzz, TEMP[0].wwww
>576: MOV OUT[0], TEMP[1]
>577: END
>radeonsi: Compiling shader 9
>TGSI shader LLVM IR:
>
>; ModuleID = 'tgsi'
>source_filename = "tgsi"
>target triple = "amdgcn--"
>
>@ddxy_lds = external addrspace(3) global [64 x i32]
>
>define amdgpu_ps <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float }> @main([17 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <16 x i8>] addrspace(2)* byval dereferenceable(18446744073709551615), [32 x <8 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <8 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), [16 x <4 x i32>] addrspace(2)* byval dereferenceable(18446744073709551615), 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:
>  %23 = call float @llvm.SI.fs.interp(i32 3, i32 1, i32 %6, <2 x i32> %8)
>  %24 = call float @llvm.SI.fs.interp(i32 0, i32 2, i32 %6, <2 x i32> %8)
>  %25 = call float @llvm.SI.fs.interp(i32 1, i32 2, i32 %6, <2 x i32> %8)
>  %26 = call float @llvm.SI.fs.interp(i32 2, i32 2, i32 %6, <2 x i32> %8)
>  %27 = call float @llvm.SI.fs.interp(i32 3, i32 2, i32 %6, <2 x i32> %8)
>  %28 = call float @llvm.SI.fs.interp(i32 0, i32 3, i32 %6, <2 x i32> %8)
>  %29 = call float @llvm.SI.fs.interp(i32 3, i32 4, i32 %6, <2 x i32> %8)
>  %30 = call float @llvm.SI.fs.interp(i32 0, i32 5, i32 %6, <2 x i32> %8)
>  %31 = call float @llvm.SI.fs.interp(i32 1, i32 5, i32 %6, <2 x i32> %8)
>  %32 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %33 = load <16 x i8>, <16 x i8> addrspace(2)* %32, align 16, !invariant.load !0
>  %34 = call float @llvm.SI.load.const(<16 x i8> %33, i32 144)
>  %35 = fcmp oeq float %34, 1.000000e+00
>  br i1 %35, label %IF, label %ENDIF
>
>IF:                                               ; preds = %main_body
>  %36 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %37 = load <16 x i8>, <16 x i8> addrspace(2)* %36, align 16, !invariant.load !0
>  %38 = call float @llvm.SI.load.const(<16 x i8> %37, i32 160)
>  %39 = call float @llvm.SI.load.const(<16 x i8> %37, i32 164)
>  %40 = call float @llvm.SI.load.const(<16 x i8> %37, i32 168)
>  %41 = fmul float %29, %38
>  %42 = fmul float %30, %39
>  %43 = fadd float %42, %41
>  %44 = fmul float %31, %40
>  %45 = fadd float %43, %44
>  %46 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %47 = load <16 x i8>, <16 x i8> addrspace(2)* %46, align 16, !invariant.load !0
>  %48 = call float @llvm.SI.load.const(<16 x i8> %47, i32 172)
>  %49 = fcmp olt float %45, %48
>  %50 = sext i1 %49 to i32
>  %51 = bitcast i32 %50 to float
>  br label %ENDIF
>
>ENDIF:                                            ; preds = %main_body, %IF
>  %.0142 = phi float [ %51, %IF ], [ 0.000000e+00, %main_body ]
>  %52 = bitcast float %.0142 to i32
>  %53 = and i32 %52, 1065353216
>  %54 = bitcast i32 %53 to float
>  %55 = fcmp ogt float %54, -0.000000e+00
>  %56 = select i1 %55, float -1.000000e+00, float 0.000000e+00
>  call void @llvm.AMDGPU.kill(float %56)
>  %57 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %58 = load <16 x i8>, <16 x i8> addrspace(2)* %57, align 16, !invariant.load !0
>  %59 = call float @llvm.SI.load.const(<16 x i8> %58, i32 608)
>  %60 = fcmp oeq float %59, 1.000000e+00
>  br i1 %60, label %IF2, label %ENDIF1
>
>IF2:                                              ; preds = %ENDIF
>  %61 = call float @llvm.SI.fs.interp(i32 0, i32 0, i32 %6, <2 x i32> %8)
>  %62 = call float @llvm.SI.fs.interp(i32 1, i32 0, i32 %6, <2 x i32> %8)
>  %63 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 0, !amdgpu.uniform !0
>  %64 = load <8 x i32>, <8 x i32> addrspace(2)* %63, align 32, !invariant.load !0
>  %65 = bitcast [32 x <8 x i32>] addrspace(2)* %2 to [0 x <4 x i32>] addrspace(2)*
>  %66 = getelementptr [0 x <4 x i32>], [0 x <4 x i32>] addrspace(2)* %65, i64 0, i64 3, !amdgpu.uniform !0
>  %67 = load <4 x i32>, <4 x i32> addrspace(2)* %66, align 16, !invariant.load !0
>  %68 = bitcast float %61 to i32
>  %69 = bitcast float %62 to i32
>  %70 = insertelement <2 x i32> undef, i32 %68, i32 0
>  %71 = insertelement <2 x i32> %70, i32 %69, i32 1
>  %72 = call <4 x float> @llvm.SI.image.sample.v2i32(<2 x i32> %71, <8 x i32> %64, <4 x i32> %67, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %73 = extractelement <4 x float> %72, i32 0
>  %74 = extractelement <4 x float> %72, i32 1
>  %75 = extractelement <4 x float> %72, i32 2
>  %76 = extractelement <4 x float> %72, i32 3
>  %77 = call float @llvm.pow.f32(float %73, float 0x40019999A0000000)
>  %78 = call float @llvm.pow.f32(float %74, float 0x40019999A0000000)
>  %79 = call float @llvm.pow.f32(float %75, float 0x40019999A0000000)
>  %80 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %81 = load <16 x i8>, <16 x i8> addrspace(2)* %80, align 16, !invariant.load !0
>  %82 = call float @llvm.SI.load.const(<16 x i8> %81, i32 380)
>  %83 = fcmp ogt float %82, 0x3FECCCCCC0000000
>  %84 = call float @llvm.SI.load.const(<16 x i8> %81, i32 368)
>  %85 = fcmp oeq float %77, %84
>  %86 = call float @llvm.SI.load.const(<16 x i8> %81, i32 372)
>  %87 = fcmp oeq float %78, %86
>  %88 = call float @llvm.SI.load.const(<16 x i8> %81, i32 376)
>  %89 = fcmp oeq float %79, %88
>  %90 = and i1 %87, %89
>  %91 = and i1 %85, %90
>  %92 = and i1 %83, %91
>  %93 = select i1 %92, float -1.000000e+00, float 0.000000e+00
>  call void @llvm.AMDGPU.kill(float %93)
>  %94 = fcmp oeq float %76, 0.000000e+00
>  %95 = sext i1 %94 to i32
>  %96 = bitcast i32 %95 to float
>  %97 = select i1 %94, float -1.000000e+00, float 0.000000e+00
>  call void @llvm.AMDGPU.kill(float %97)
>  br label %ENDIF1
>
>ENDIF1:                                           ; preds = %ENDIF, %IF2
>  %.0147 = phi float [ %76, %IF2 ], [ 0.000000e+00, %ENDIF ]
>  %.0145 = phi float [ %79, %IF2 ], [ 0.000000e+00, %ENDIF ]
>  %.0144 = phi float [ %78, %IF2 ], [ 0.000000e+00, %ENDIF ]
>  %.1143 = phi float [ %77, %IF2 ], [ 0.000000e+00, %ENDIF ]
>  %.0141 = phi float [ %96, %IF2 ], [ %.0142, %ENDIF ]
>  %98 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %99 = load <16 x i8>, <16 x i8> addrspace(2)* %98, align 16, !invariant.load !0
>  %100 = call float @llvm.SI.load.const(<16 x i8> %99, i32 592)
>  %101 = call float @llvm.SI.load.const(<16 x i8> %99, i32 596)
>  %102 = call float @llvm.SI.load.const(<16 x i8> %99, i32 600)
>  %103 = call float @llvm.SI.load.const(<16 x i8> %99, i32 604)
>  %104 = call float @llvm.SI.load.const(<16 x i8> %99, i32 632)
>  %105 = fcmp oeq float %104, 1.000000e+00
>  br i1 %105, label %IF5, label %ENDIF4
>
>IF5:                                              ; preds = %ENDIF1
>  %106 = call float @llvm.SI.fs.interp(i32 0, i32 0, i32 %6, <2 x i32> %8)
>  %107 = call float @llvm.SI.fs.interp(i32 1, i32 0, i32 %6, <2 x i32> %8)
>  %108 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 10, !amdgpu.uniform !0
>  %109 = load <8 x i32>, <8 x i32> addrspace(2)* %108, align 32, !invariant.load !0
>  %110 = bitcast [32 x <8 x i32>] addrspace(2)* %2 to [0 x <4 x i32>] addrspace(2)*
>  %111 = getelementptr [0 x <4 x i32>], [0 x <4 x i32>] addrspace(2)* %110, i64 0, i64 23, !amdgpu.uniform !0
>  %112 = load <4 x i32>, <4 x i32> addrspace(2)* %111, align 16, !invariant.load !0
>  %113 = bitcast float %106 to i32
>  %114 = bitcast float %107 to i32
>  %115 = insertelement <2 x i32> undef, i32 %113, i32 0
>  %116 = insertelement <2 x i32> %115, i32 %114, i32 1
>  %117 = call <4 x float> @llvm.SI.image.sample.v2i32(<2 x i32> %116, <8 x i32> %109, <4 x i32> %112, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %118 = extractelement <4 x float> %117, i32 0
>  %119 = extractelement <4 x float> %117, i32 1
>  %120 = extractelement <4 x float> %117, i32 2
>  %121 = call float @llvm.pow.f32(float %118, float 0x40019999A0000000)
>  %122 = call float @llvm.pow.f32(float %119, float 0x40019999A0000000)
>  %123 = call float @llvm.pow.f32(float %120, float 0x40019999A0000000)
>  br label %ENDIF4
>
>ENDIF4:                                           ; preds = %ENDIF1, %IF5
>  %.0152 = phi float [ 0.000000e+00, %IF5 ], [ %103, %ENDIF1 ]
>  %.0151 = phi float [ %123, %IF5 ], [ %102, %ENDIF1 ]
>  %.0150 = phi float [ %122, %IF5 ], [ %101, %ENDIF1 ]
>  %.0149 = phi float [ %121, %IF5 ], [ %100, %ENDIF1 ]
>  %124 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %125 = load <16 x i8>, <16 x i8> addrspace(2)* %124, align 16, !invariant.load !0
>  %126 = call float @llvm.SI.load.const(<16 x i8> %125, i32 528)
>  %127 = call float @llvm.SI.load.const(<16 x i8> %125, i32 532)
>  %128 = call float @llvm.SI.load.const(<16 x i8> %125, i32 536)
>  %129 = call float @llvm.SI.load.const(<16 x i8> %125, i32 540)
>  %130 = call float @llvm.SI.load.const(<16 x i8> %125, i32 628)
>  %131 = fcmp oeq float %130, 1.000000e+00
>  br i1 %131, label %IF8, label %ENDIF7
>
>IF8:                                              ; preds = %ENDIF4
>  %132 = call float @llvm.SI.fs.interp(i32 2, i32 0, i32 %6, <2 x i32> %8)
>  %133 = call float @llvm.SI.fs.interp(i32 3, i32 0, i32 %6, <2 x i32> %8)
>  %134 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 8, !amdgpu.uniform !0
>  %135 = load <8 x i32>, <8 x i32> addrspace(2)* %134, align 32, !invariant.load !0
>  %136 = bitcast [32 x <8 x i32>] addrspace(2)* %2 to [0 x <4 x i32>] addrspace(2)*
>  %137 = getelementptr [0 x <4 x i32>], [0 x <4 x i32>] addrspace(2)* %136, i64 0, i64 19, !amdgpu.uniform !0
>  %138 = load <4 x i32>, <4 x i32> addrspace(2)* %137, align 16, !invariant.load !0
>  %139 = bitcast float %132 to i32
>  %140 = bitcast float %133 to i32
>  %141 = insertelement <2 x i32> undef, i32 %139, i32 0
>  %142 = insertelement <2 x i32> %141, i32 %140, i32 1
>  %143 = call <4 x float> @llvm.SI.image.sample.v2i32(<2 x i32> %142, <8 x i32> %135, <4 x i32> %138, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %144 = extractelement <4 x float> %143, i32 0
>  %145 = extractelement <4 x float> %143, i32 1
>  %146 = extractelement <4 x float> %143, i32 2
>  %147 = call float @llvm.pow.f32(float %144, float 0x40019999A0000000)
>  %148 = call float @llvm.pow.f32(float %145, float 0x40019999A0000000)
>  %149 = call float @llvm.pow.f32(float %146, float 0x40019999A0000000)
>  br label %ENDIF7
>
>ENDIF7:                                           ; preds = %ENDIF4, %IF8
>  %.0156 = phi float [ 1.000000e+00, %IF8 ], [ %129, %ENDIF4 ]
>  %.0155 = phi float [ %149, %IF8 ], [ %128, %ENDIF4 ]
>  %.0154 = phi float [ %148, %IF8 ], [ %127, %ENDIF4 ]
>  %.0153 = phi float [ %147, %IF8 ], [ %126, %ENDIF4 ]
>  %150 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %151 = load <16 x i8>, <16 x i8> addrspace(2)* %150, align 16, !invariant.load !0
>  %152 = call float @llvm.SI.load.const(<16 x i8> %151, i32 620)
>  %153 = fcmp oeq float %152, 1.000000e+00
>  br i1 %153, label %IF11, label %ELSE12
>
>IF11:                                             ; preds = %ENDIF7
>  %154 = call float @llvm.SI.fs.interp(i32 0, i32 0, i32 %6, <2 x i32> %8)
>  %155 = call float @llvm.SI.fs.interp(i32 1, i32 0, i32 %6, <2 x i32> %8)
>  %156 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 6, !amdgpu.uniform !0
>  %157 = load <8 x i32>, <8 x i32> addrspace(2)* %156, align 32, !invariant.load !0
>  %158 = bitcast [32 x <8 x i32>] addrspace(2)* %2 to [0 x <4 x i32>] addrspace(2)*
>  %159 = getelementptr [0 x <4 x i32>], [0 x <4 x i32>] addrspace(2)* %158, i64 0, i64 15, !amdgpu.uniform !0
>  %160 = load <4 x i32>, <4 x i32> addrspace(2)* %159, align 16, !invariant.load !0
>  %161 = bitcast float %154 to i32
>  %162 = bitcast float %155 to i32
>  %163 = insertelement <2 x i32> undef, i32 %161, i32 0
>  %164 = insertelement <2 x i32> %163, i32 %162, i32 1
>  %165 = call <4 x float> @llvm.SI.image.sample.v2i32(<2 x i32> %164, <8 x i32> %157, <4 x i32> %160, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %166 = extractelement <4 x float> %165, i32 0
>  %167 = extractelement <4 x float> %165, i32 1
>  %168 = extractelement <4 x float> %165, i32 2
>  %169 = fmul float %166, 0x4000102040000000
>  %170 = fadd float %169, 0xBFF0204080000000
>  %171 = fmul float %167, 0x4000102040000000
>  %172 = fadd float %171, 0xBFF0204080000000
>  %173 = fmul float %168, 0x4000102040000000
>  %174 = fadd float %173, 0xBFF0204080000000
>  %175 = call i32 @llvm.amdgcn.mbcnt.lo(i32 -1, i32 0)
>  %176 = call i32 @llvm.amdgcn.mbcnt.hi(i32 -1, i32 %175), !range !1
>  %177 = and i32 %176, 60
>  %178 = or i32 %177, 1
>  %179 = call float @llvm.SI.fs.interp(i32 1, i32 3, i32 %6, <2 x i32> %8)
>  %180 = bitcast float %179 to i32
>  %181 = shl nuw nsw i32 %177, 2
>  %182 = call i32 @llvm.amdgcn.ds.bpermute(i32 %181, i32 %180)
>  %183 = shl nuw nsw i32 %178, 2
>  %184 = call i32 @llvm.amdgcn.ds.bpermute(i32 %183, i32 %180)
>  %185 = bitcast i32 %182 to float
>  %186 = bitcast i32 %184 to float
>  %187 = fsub float %186, %185
>  %188 = call float @llvm.SI.fs.interp(i32 2, i32 3, i32 %6, <2 x i32> %8)
>  %189 = bitcast float %188 to i32
>  %190 = shl nuw nsw i32 %177, 2
>  %191 = call i32 @llvm.amdgcn.ds.bpermute(i32 %190, i32 %189)
>  %192 = shl nuw nsw i32 %178, 2
>  %193 = call i32 @llvm.amdgcn.ds.bpermute(i32 %192, i32 %189)
>  %194 = bitcast i32 %191 to float
>  %195 = bitcast i32 %193 to float
>  %196 = fsub float %195, %194
>  %197 = call float @llvm.SI.fs.interp(i32 3, i32 3, i32 %6, <2 x i32> %8)
>  %198 = bitcast float %197 to i32
>  %199 = shl nuw nsw i32 %177, 2
>  %200 = call i32 @llvm.amdgcn.ds.bpermute(i32 %199, i32 %198)
>  %201 = shl nuw nsw i32 %178, 2
>  %202 = call i32 @llvm.amdgcn.ds.bpermute(i32 %201, i32 %198)
>  %203 = bitcast i32 %200 to float
>  %204 = bitcast i32 %202 to float
>  %205 = fsub float %204, %203
>  %206 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %207 = load <16 x i8>, <16 x i8> addrspace(2)* %206, align 16, !invariant.load !0
>  %208 = call float @llvm.SI.load.const(<16 x i8> %207, i32 672)
>  %209 = call float @llvm.SI.fs.interp(i32 1, i32 3, i32 %6, <2 x i32> %8)
>  %210 = fmul float %208, %209
>  %211 = call float @llvm.SI.load.const(<16 x i8> %207, i32 672)
>  %212 = call float @llvm.SI.fs.interp(i32 2, i32 3, i32 %6, <2 x i32> %8)
>  %213 = fmul float %211, %212
>  %214 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %215 = load <16 x i8>, <16 x i8> addrspace(2)* %214, align 16, !invariant.load !0
>  %216 = call float @llvm.SI.load.const(<16 x i8> %215, i32 672)
>  %217 = call float @llvm.SI.fs.interp(i32 3, i32 3, i32 %6, <2 x i32> %8)
>  %218 = fmul float %216, %217
>  %219 = call i32 @llvm.amdgcn.mbcnt.lo(i32 -1, i32 0)
>  %220 = call i32 @llvm.amdgcn.mbcnt.hi(i32 -1, i32 %219), !range !1
>  %221 = and i32 %220, 60
>  %222 = or i32 %221, 2
>  %223 = bitcast float %210 to i32
>  %224 = shl nuw nsw i32 %221, 2
>  %225 = call i32 @llvm.amdgcn.ds.bpermute(i32 %224, i32 %223)
>  %226 = shl nuw nsw i32 %222, 2
>  %227 = call i32 @llvm.amdgcn.ds.bpermute(i32 %226, i32 %223)
>  %228 = bitcast i32 %225 to float
>  %229 = bitcast i32 %227 to float
>  %230 = fsub float %229, %228
>  %231 = bitcast float %213 to i32
>  %232 = shl nuw nsw i32 %221, 2
>  %233 = call i32 @llvm.amdgcn.ds.bpermute(i32 %232, i32 %231)
>  %234 = shl nuw nsw i32 %222, 2
>  %235 = call i32 @llvm.amdgcn.ds.bpermute(i32 %234, i32 %231)
>  %236 = bitcast i32 %233 to float
>  %237 = bitcast i32 %235 to float
>  %238 = fsub float %237, %236
>  %239 = bitcast float %218 to i32
>  %240 = shl nuw nsw i32 %221, 2
>  %241 = call i32 @llvm.amdgcn.ds.bpermute(i32 %240, i32 %239)
>  %242 = shl nuw nsw i32 %222, 2
>  %243 = call i32 @llvm.amdgcn.ds.bpermute(i32 %242, i32 %239)
>  %244 = bitcast i32 %241 to float
>  %245 = bitcast i32 %243 to float
>  %246 = fsub float %245, %244
>  %247 = call i32 @llvm.amdgcn.mbcnt.lo(i32 -1, i32 0)
>  %248 = call i32 @llvm.amdgcn.mbcnt.hi(i32 -1, i32 %247), !range !1
>  %249 = and i32 %248, 60
>  %250 = or i32 %249, 1
>  %251 = call float @llvm.SI.fs.interp(i32 0, i32 0, i32 %6, <2 x i32> %8)
>  %252 = bitcast float %251 to i32
>  %253 = shl nuw nsw i32 %249, 2
>  %254 = call i32 @llvm.amdgcn.ds.bpermute(i32 %253, i32 %252)
>  %255 = shl nuw nsw i32 %250, 2
>  %256 = call i32 @llvm.amdgcn.ds.bpermute(i32 %255, i32 %252)
>  %257 = bitcast i32 %254 to float
>  %258 = bitcast i32 %256 to float
>  %259 = fsub float %258, %257
>  %260 = call float @llvm.SI.fs.interp(i32 1, i32 0, i32 %6, <2 x i32> %8)
>  %261 = bitcast float %260 to i32
>  %262 = shl nuw nsw i32 %249, 2
>  %263 = call i32 @llvm.amdgcn.ds.bpermute(i32 %262, i32 %261)
>  %264 = shl nuw nsw i32 %250, 2
>  %265 = call i32 @llvm.amdgcn.ds.bpermute(i32 %264, i32 %261)
>  %266 = bitcast i32 %263 to float
>  %267 = bitcast i32 %265 to float
>  %268 = fsub float %267, %266
>  %269 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %270 = load <16 x i8>, <16 x i8> addrspace(2)* %269, align 16, !invariant.load !0
>  %271 = call float @llvm.SI.load.const(<16 x i8> %270, i32 672)
>  %272 = call float @llvm.SI.fs.interp(i32 0, i32 0, i32 %6, <2 x i32> %8)
>  %273 = fmul float %271, %272
>  %274 = call float @llvm.SI.load.const(<16 x i8> %270, i32 672)
>  %275 = call float @llvm.SI.fs.interp(i32 1, i32 0, i32 %6, <2 x i32> %8)
>  %276 = fmul float %274, %275
>  %277 = call i32 @llvm.amdgcn.mbcnt.lo(i32 -1, i32 0)
>  %278 = call i32 @llvm.amdgcn.mbcnt.hi(i32 -1, i32 %277), !range !1
>  %279 = and i32 %278, 60
>  %280 = or i32 %279, 2
>  %281 = bitcast float %273 to i32
>  %282 = shl nuw nsw i32 %279, 2
>  %283 = call i32 @llvm.amdgcn.ds.bpermute(i32 %282, i32 %281)
>  %284 = shl nuw nsw i32 %280, 2
>  %285 = call i32 @llvm.amdgcn.ds.bpermute(i32 %284, i32 %281)
>  %286 = bitcast i32 %283 to float
>  %287 = bitcast i32 %285 to float
>  %288 = fsub float %287, %286
>  %289 = bitcast float %276 to i32
>  %290 = shl nuw nsw i32 %279, 2
>  %291 = call i32 @llvm.amdgcn.ds.bpermute(i32 %290, i32 %289)
>  %292 = shl nuw nsw i32 %280, 2
>  %293 = call i32 @llvm.amdgcn.ds.bpermute(i32 %292, i32 %289)
>  %294 = bitcast i32 %291 to float
>  %295 = bitcast i32 %293 to float
>  %296 = fsub float %295, %294
>  %297 = call float @llvm.SI.fs.interp(i32 1, i32 1, i32 %6, <2 x i32> %8)
>  %298 = fmul float %246, %297
>  %299 = call float @llvm.SI.fs.interp(i32 2, i32 1, i32 %6, <2 x i32> %8)
>  %300 = fmul float %230, %299
>  %301 = call float @llvm.SI.fs.interp(i32 0, i32 1, i32 %6, <2 x i32> %8)
>  %302 = fmul float %238, %301
>  %303 = call float @llvm.SI.fs.interp(i32 2, i32 1, i32 %6, <2 x i32> %8)
>  %304 = fmul float %238, %303
>  %305 = fsub float %304, %298
>  %306 = call float @llvm.SI.fs.interp(i32 0, i32 1, i32 %6, <2 x i32> %8)
>  %307 = fmul float %246, %306
>  %308 = fsub float %307, %300
>  %309 = call float @llvm.SI.fs.interp(i32 1, i32 1, i32 %6, <2 x i32> %8)
>  %310 = fmul float %230, %309
>  %311 = fsub float %310, %302
>  %312 = call float @llvm.SI.fs.interp(i32 2, i32 1, i32 %6, <2 x i32> %8)
>  %313 = fmul float %312, %196
>  %314 = call float @llvm.SI.fs.interp(i32 0, i32 1, i32 %6, <2 x i32> %8)
>  %315 = fmul float %314, %205
>  %316 = call float @llvm.SI.fs.interp(i32 1, i32 1, i32 %6, <2 x i32> %8)
>  %317 = fmul float %316, %187
>  %318 = call float @llvm.SI.fs.interp(i32 1, i32 1, i32 %6, <2 x i32> %8)
>  %319 = fmul float %318, %205
>  %320 = fsub float %319, %313
>  %321 = call float @llvm.SI.fs.interp(i32 2, i32 1, i32 %6, <2 x i32> %8)
>  %322 = fmul float %321, %187
>  %323 = fsub float %322, %315
>  %324 = call float @llvm.SI.fs.interp(i32 0, i32 1, i32 %6, <2 x i32> %8)
>  %325 = fmul float %324, %196
>  %326 = fsub float %325, %317
>  %327 = fmul float %305, %259
>  %328 = fmul float %308, %259
>  %329 = fmul float %311, %259
>  %330 = fmul float %320, %288
>  %331 = fadd float %330, %327
>  %332 = fmul float %323, %288
>  %333 = fadd float %332, %328
>  %334 = fmul float %326, %288
>  %335 = fadd float %334, %329
>  %336 = fmul float %305, %268
>  %337 = fmul float %308, %268
>  %338 = fmul float %311, %268
>  %339 = fmul float %320, %296
>  %340 = fadd float %339, %336
>  %341 = fmul float %323, %296
>  %342 = fadd float %341, %337
>  %343 = fmul float %326, %296
>  %344 = fadd float %343, %338
>  %345 = fmul float %331, %331
>  %346 = fmul float %333, %333
>  %347 = fadd float %346, %345
>  %348 = fmul float %335, %335
>  %349 = fadd float %347, %348
>  %350 = fmul float %340, %340
>  %351 = fmul float %342, %342
>  %352 = fadd float %351, %350
>  %353 = fmul float %344, %344
>  %354 = fadd float %352, %353
>  %355 = call float @llvm.maxnum.f32(float %349, float %354)
>  %356 = call float @llvm.sqrt.f32(float %355)
>  %357 = fdiv float 1.000000e+00, %356, !fpmath !2
>  %358 = fmul float %340, %357
>  %359 = fmul float %342, %357
>  %360 = fmul float %344, %357
>  %361 = fmul float %331, %357
>  %362 = fmul float %333, %357
>  %363 = fmul float %335, %357
>  %364 = fmul float %361, %170
>  %365 = fmul float %362, %170
>  %366 = fmul float %363, %170
>  %367 = fmul float %358, %172
>  %368 = fadd float %367, %364
>  %369 = fmul float %359, %172
>  %370 = fadd float %369, %365
>  %371 = fmul float %360, %172
>  %372 = fadd float %371, %366
>  %373 = call float @llvm.SI.fs.interp(i32 0, i32 1, i32 %6, <2 x i32> %8)
>  %374 = fmul float %373, %174
>  %375 = fadd float %374, %368
>  %376 = call float @llvm.SI.fs.interp(i32 1, i32 1, i32 %6, <2 x i32> %8)
>  %377 = fmul float %376, %174
>  %378 = fadd float %377, %370
>  %379 = call float @llvm.SI.fs.interp(i32 2, i32 1, i32 %6, <2 x i32> %8)
>  %380 = fmul float %379, %174
>  %381 = fadd float %380, %372
>  %382 = fmul float %375, %375
>  %383 = fmul float %378, %378
>  %384 = fadd float %383, %382
>  %385 = fmul float %381, %381
>  %386 = fadd float %384, %385
>  %387 = call float @llvm.sqrt.f32(float %386)
>  %388 = fdiv float 1.000000e+00, %387, !fpmath !2
>  %389 = fmul float %375, %388
>  %390 = fmul float %378, %388
>  %391 = fmul float %381, %388
>  %392 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %393 = load <16 x i8>, <16 x i8> addrspace(2)* %392, align 16, !invariant.load !0
>  %394 = call float @llvm.SI.load.const(<16 x i8> %393, i32 464)
>  %395 = fmul float %394, %389
>  %396 = call float @llvm.SI.load.const(<16 x i8> %393, i32 468)
>  %397 = fmul float %396, %389
>  %398 = call float @llvm.SI.load.const(<16 x i8> %393, i32 472)
>  %399 = fmul float %398, %389
>  %400 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %401 = load <16 x i8>, <16 x i8> addrspace(2)* %400, align 16, !invariant.load !0
>  %402 = call float @llvm.SI.load.const(<16 x i8> %401, i32 480)
>  %403 = fmul float %402, %390
>  %404 = fadd float %403, %395
>  %405 = call float @llvm.SI.load.const(<16 x i8> %401, i32 484)
>  %406 = fmul float %405, %390
>  %407 = fadd float %406, %397
>  %408 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %409 = load <16 x i8>, <16 x i8> addrspace(2)* %408, align 16, !invariant.load !0
>  %410 = call float @llvm.SI.load.const(<16 x i8> %409, i32 488)
>  %411 = fmul float %410, %390
>  %412 = fadd float %411, %399
>  %413 = call float @llvm.SI.load.const(<16 x i8> %409, i32 496)
>  %414 = fmul float %413, %391
>  %415 = fadd float %414, %404
>  %416 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %417 = load <16 x i8>, <16 x i8> addrspace(2)* %416, align 16, !invariant.load !0
>  %418 = call float @llvm.SI.load.const(<16 x i8> %417, i32 500)
>  %419 = fmul float %418, %391
>  %420 = fadd float %419, %407
>  %421 = call float @llvm.SI.load.const(<16 x i8> %417, i32 504)
>  %422 = fmul float %421, %391
>  %423 = fadd float %422, %412
>  %424 = fmul float %415, %415
>  %425 = fmul float %420, %420
>  %426 = fadd float %425, %424
>  %427 = fmul float %423, %423
>  %428 = fadd float %426, %427
>  %429 = call float @llvm.sqrt.f32(float %428)
>  %430 = fdiv float 1.000000e+00, %429, !fpmath !2
>  %431 = fmul float %415, %430
>  %432 = fmul float %420, %430
>  %433 = fmul float %423, %430
>  %434 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %435 = load <16 x i8>, <16 x i8> addrspace(2)* %434, align 16, !invariant.load !0
>  %436 = call float @llvm.SI.load.const(<16 x i8> %435, i32 400)
>  %437 = fmul float %436, %431
>  %438 = call float @llvm.SI.load.const(<16 x i8> %435, i32 404)
>  %439 = fmul float %438, %431
>  %440 = call float @llvm.SI.load.const(<16 x i8> %435, i32 408)
>  %441 = fmul float %440, %431
>  %442 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %443 = load <16 x i8>, <16 x i8> addrspace(2)* %442, align 16, !invariant.load !0
>  %444 = call float @llvm.SI.load.const(<16 x i8> %443, i32 416)
>  %445 = fmul float %444, %432
>  %446 = fadd float %445, %437
>  %447 = call float @llvm.SI.load.const(<16 x i8> %443, i32 420)
>  %448 = fmul float %447, %432
>  %449 = fadd float %448, %439
>  %450 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %451 = load <16 x i8>, <16 x i8> addrspace(2)* %450, align 16, !invariant.load !0
>  %452 = call float @llvm.SI.load.const(<16 x i8> %451, i32 424)
>  %453 = fmul float %452, %432
>  %454 = fadd float %453, %441
>  %455 = call float @llvm.SI.load.const(<16 x i8> %451, i32 432)
>  %456 = fmul float %455, %433
>  %457 = fadd float %456, %446
>  %458 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %459 = load <16 x i8>, <16 x i8> addrspace(2)* %458, align 16, !invariant.load !0
>  %460 = call float @llvm.SI.load.const(<16 x i8> %459, i32 436)
>  %461 = fmul float %460, %433
>  %462 = fadd float %461, %449
>  %463 = call float @llvm.SI.load.const(<16 x i8> %459, i32 440)
>  %464 = fmul float %463, %433
>  %465 = fadd float %464, %454
>  %466 = fmul float %457, %457
>  %467 = fmul float %462, %462
>  %468 = fadd float %467, %466
>  %469 = fmul float %465, %465
>  %470 = fadd float %468, %469
>  %471 = call float @llvm.sqrt.f32(float %470)
>  %472 = fdiv float 1.000000e+00, %471, !fpmath !2
>  %473 = fmul float %457, %472
>  %474 = fmul float %462, %472
>  %475 = fmul float %465, %472
>  br label %ENDIF10
>
>ELSE12:                                           ; preds = %ENDIF7
>  %476 = fmul float %23, %23
>  %477 = fmul float %24, %24
>  %478 = fadd float %477, %476
>  %479 = fmul float %25, %25
>  %480 = fadd float %478, %479
>  %481 = call float @llvm.sqrt.f32(float %480)
>  %482 = fdiv float 1.000000e+00, %481, !fpmath !2
>  %483 = fmul float %23, %482
>  %484 = fmul float %24, %482
>  %485 = fmul float %25, %482
>  %486 = fmul float %26, %26
>  %487 = fmul float %27, %27
>  %488 = fadd float %487, %486
>  %489 = fmul float %28, %28
>  %490 = fadd float %488, %489
>  %491 = call float @llvm.sqrt.f32(float %490)
>  %492 = fdiv float 1.000000e+00, %491, !fpmath !2
>  %493 = fmul float %26, %492
>  %494 = fmul float %27, %492
>  %495 = fmul float %28, %492
>  br label %ENDIF10
>
>ENDIF10:                                          ; preds = %ELSE12, %IF11
>  %.0201 = phi float [ %475, %IF11 ], [ %495, %ELSE12 ]
>  %.0200 = phi float [ %474, %IF11 ], [ %494, %ELSE12 ]
>  %.0199 = phi float [ %473, %IF11 ], [ %493, %ELSE12 ]
>  %.0195 = phi float [ %433, %IF11 ], [ %485, %ELSE12 ]
>  %.0192 = phi float [ %432, %IF11 ], [ %484, %ELSE12 ]
>  %.0189 = phi float [ %431, %IF11 ], [ %483, %ELSE12 ]
>  %496 = call i32 @llvm.amdgcn.mbcnt.lo(i32 -1, i32 0)
>  %497 = call i32 @llvm.amdgcn.mbcnt.hi(i32 -1, i32 %496), !range !1
>  %498 = and i32 %497, 60
>  %499 = or i32 %498, 1
>  %500 = bitcast float %.0189 to i32
>  %501 = shl nuw nsw i32 %498, 2
>  %502 = call i32 @llvm.amdgcn.ds.bpermute(i32 %501, i32 %500)
>  %503 = shl nuw nsw i32 %499, 2
>  %504 = call i32 @llvm.amdgcn.ds.bpermute(i32 %503, i32 %500)
>  %505 = bitcast i32 %502 to float
>  %506 = bitcast i32 %504 to float
>  %507 = fsub float %506, %505
>  %508 = bitcast float %.0192 to i32
>  %509 = shl nuw nsw i32 %498, 2
>  %510 = call i32 @llvm.amdgcn.ds.bpermute(i32 %509, i32 %508)
>  %511 = shl nuw nsw i32 %499, 2
>  %512 = call i32 @llvm.amdgcn.ds.bpermute(i32 %511, i32 %508)
>  %513 = bitcast i32 %510 to float
>  %514 = bitcast i32 %512 to float
>  %515 = fsub float %514, %513
>  %516 = bitcast float %.0195 to i32
>  %517 = shl nuw nsw i32 %498, 2
>  %518 = call i32 @llvm.amdgcn.ds.bpermute(i32 %517, i32 %516)
>  %519 = shl nuw nsw i32 %499, 2
>  %520 = call i32 @llvm.amdgcn.ds.bpermute(i32 %519, i32 %516)
>  %521 = bitcast i32 %518 to float
>  %522 = bitcast i32 %520 to float
>  %523 = fsub float %522, %521
>  %524 = call float @llvm.fabs.f32(float %507)
>  %525 = call float @llvm.fabs.f32(float %515)
>  %526 = call float @llvm.fabs.f32(float %523)
>  %527 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %528 = load <16 x i8>, <16 x i8> addrspace(2)* %527, align 16, !invariant.load !0
>  %529 = call float @llvm.SI.load.const(<16 x i8> %528, i32 672)
>  %530 = fmul float %529, %.0189
>  %531 = call float @llvm.SI.load.const(<16 x i8> %528, i32 672)
>  %532 = fmul float %531, %.0192
>  %533 = call float @llvm.SI.load.const(<16 x i8> %528, i32 672)
>  %534 = fmul float %533, %.0195
>  %535 = call i32 @llvm.amdgcn.mbcnt.lo(i32 -1, i32 0)
>  %536 = call i32 @llvm.amdgcn.mbcnt.hi(i32 -1, i32 %535), !range !1
>  %537 = and i32 %536, 60
>  %538 = or i32 %537, 2
>  %539 = bitcast float %530 to i32
>  %540 = shl nuw nsw i32 %537, 2
>  %541 = call i32 @llvm.amdgcn.ds.bpermute(i32 %540, i32 %539)
>  %542 = shl nuw nsw i32 %538, 2
>  %543 = call i32 @llvm.amdgcn.ds.bpermute(i32 %542, i32 %539)
>  %544 = bitcast i32 %541 to float
>  %545 = bitcast i32 %543 to float
>  %546 = fsub float %545, %544
>  %547 = bitcast float %532 to i32
>  %548 = shl nuw nsw i32 %537, 2
>  %549 = call i32 @llvm.amdgcn.ds.bpermute(i32 %548, i32 %547)
>  %550 = shl nuw nsw i32 %538, 2
>  %551 = call i32 @llvm.amdgcn.ds.bpermute(i32 %550, i32 %547)
>  %552 = bitcast i32 %549 to float
>  %553 = bitcast i32 %551 to float
>  %554 = fsub float %553, %552
>  %555 = bitcast float %534 to i32
>  %556 = shl nuw nsw i32 %537, 2
>  %557 = call i32 @llvm.amdgcn.ds.bpermute(i32 %556, i32 %555)
>  %558 = shl nuw nsw i32 %538, 2
>  %559 = call i32 @llvm.amdgcn.ds.bpermute(i32 %558, i32 %555)
>  %560 = bitcast i32 %557 to float
>  %561 = bitcast i32 %559 to float
>  %562 = fsub float %561, %560
>  %563 = call float @llvm.fabs.f32(float %546)
>  %564 = call float @llvm.fabs.f32(float %554)
>  %565 = call float @llvm.fabs.f32(float %562)
>  %566 = fadd float %524, %563
>  %567 = fadd float %525, %564
>  %568 = fadd float %526, %565
>  %569 = fmul float %566, %566
>  %570 = fmul float %567, %567
>  %571 = fadd float %570, %569
>  %572 = fmul float %568, %568
>  %573 = fadd float %571, %572
>  %574 = call float @llvm.sqrt.f32(float %573)
>  %575 = call float @llvm.AMDGPU.clamp.(float %574, float 0.000000e+00, float 1.000000e+00)
>  %576 = fmul float %575, %575
>  %577 = fmul float %576, 0x3F9EB851E0000000
>  %578 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %579 = load <16 x i8>, <16 x i8> addrspace(2)* %578, align 16, !invariant.load !0
>  %580 = call float @llvm.SI.load.const(<16 x i8> %579, i32 608)
>  %581 = fcmp oeq float %580, 1.000000e+00
>  br i1 %581, label %ENDIF13, label %ELSE15
>
>ELSE15:                                           ; preds = %ENDIF10
>  %582 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %583 = load <16 x i8>, <16 x i8> addrspace(2)* %582, align 16, !invariant.load !0
>  %584 = call float @llvm.SI.load.const(<16 x i8> %583, i32 544)
>  %585 = call float @llvm.SI.load.const(<16 x i8> %583, i32 548)
>  %586 = call float @llvm.SI.load.const(<16 x i8> %583, i32 552)
>  %587 = call float @llvm.SI.load.const(<16 x i8> %583, i32 556)
>  br label %ENDIF13
>
>ENDIF13:                                          ; preds = %ENDIF10, %ELSE15
>  %.0198 = phi float [ %587, %ELSE15 ], [ %.0147, %ENDIF10 ]
>  %.1196 = phi float [ %586, %ELSE15 ], [ %.0145, %ENDIF10 ]
>  %.1193 = phi float [ %585, %ELSE15 ], [ %.0144, %ENDIF10 ]
>  %.1190 = phi float [ %584, %ELSE15 ], [ %.1143, %ENDIF10 ]
>  %588 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %589 = load <16 x i8>, <16 x i8> addrspace(2)* %588, align 16, !invariant.load !0
>  %590 = call float @llvm.SI.load.const(<16 x i8> %589, i32 640)
>  %591 = fcmp oeq float %590, 1.000000e+00
>  br i1 %591, label %IF17, label %ENDIF16
>
>IF17:                                             ; preds = %ENDIF13
>  %592 = call float @llvm.SI.fs.interp(i32 2, i32 0, i32 %6, <2 x i32> %8)
>  %593 = call float @llvm.SI.fs.interp(i32 3, i32 0, i32 %6, <2 x i32> %8)
>  %594 = fsub float 1.000000e+00, %593
>  %595 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %596 = load <16 x i8>, <16 x i8> addrspace(2)* %595, align 16, !invariant.load !0
>  %597 = call float @llvm.SI.load.const(<16 x i8> %596, i32 336)
>  %598 = fmul float %592, %597
>  %599 = call float @llvm.SI.load.const(<16 x i8> %596, i32 340)
>  %600 = fmul float %594, %599
>  %601 = call float @llvm.SI.load.const(<16 x i8> %596, i32 344)
>  %602 = fadd float %598, %601
>  %603 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %604 = load <16 x i8>, <16 x i8> addrspace(2)* %603, align 16, !invariant.load !0
>  %605 = call float @llvm.SI.load.const(<16 x i8> %604, i32 348)
>  %606 = fadd float %600, %605
>  %607 = fsub float 1.000000e+00, %606
>  %608 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 12, !amdgpu.uniform !0
>  %609 = load <8 x i32>, <8 x i32> addrspace(2)* %608, align 32, !invariant.load !0
>  %610 = bitcast [32 x <8 x i32>] addrspace(2)* %2 to [0 x <4 x i32>] addrspace(2)*
>  %611 = getelementptr [0 x <4 x i32>], [0 x <4 x i32>] addrspace(2)* %610, i64 0, i64 27, !amdgpu.uniform !0
>  %612 = load <4 x i32>, <4 x i32> addrspace(2)* %611, align 16, !invariant.load !0
>  %613 = bitcast float %602 to i32
>  %614 = bitcast float %607 to i32
>  %615 = insertelement <2 x i32> undef, i32 %613, i32 0
>  %616 = insertelement <2 x i32> %615, i32 %614, i32 1
>  %617 = call <4 x float> @llvm.SI.image.sample.v2i32(<2 x i32> %616, <8 x i32> %609, <4 x i32> %612, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %618 = extractelement <4 x float> %617, i32 0
>  %619 = extractelement <4 x float> %617, i32 1
>  %620 = extractelement <4 x float> %617, i32 2
>  %621 = call float @llvm.pow.f32(float %618, float 0x40019999A0000000)
>  %622 = call float @llvm.pow.f32(float %619, float 0x40019999A0000000)
>  %623 = call float @llvm.pow.f32(float %620, float 0x40019999A0000000)
>  %624 = fmul float %.1190, %621
>  %625 = fmul float %.1193, %622
>  %626 = fmul float %.1196, %623
>  br label %ENDIF16
>
>ENDIF16:                                          ; preds = %ENDIF13, %IF17
>  %.2197 = phi float [ %626, %IF17 ], [ %.1196, %ENDIF13 ]
>  %.2194 = phi float [ %625, %IF17 ], [ %.1193, %ENDIF13 ]
>  %.2191 = phi float [ %624, %IF17 ], [ %.1190, %ENDIF13 ]
>  %627 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %628 = load <16 x i8>, <16 x i8> addrspace(2)* %627, align 16, !invariant.load !0
>  %629 = call float @llvm.SI.load.const(<16 x i8> %628, i32 384)
>  %630 = fcmp oeq float %629, 1.000000e+00
>  br i1 %630, label %IF20, label %ENDIF19
>
>IF20:                                             ; preds = %ENDIF16
>  %631 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %632 = load <16 x i8>, <16 x i8> addrspace(2)* %631, align 16, !invariant.load !0
>  %633 = call float @llvm.SI.load.const(<16 x i8> %632, i32 616)
>  %634 = fcmp oeq float %633, 1.000000e+00
>  br i1 %634, label %IF23, label %ELSE24
>
>ENDIF19:                                          ; preds = %ENDIF16, %ENDIF111
>  %.0138 = phi float [ %.0198, %ENDIF111 ], [ 0.000000e+00, %ENDIF16 ]
>  %.0137 = phi float [ %1394, %ENDIF111 ], [ 0.000000e+00, %ENDIF16 ]
>  %.0136 = phi float [ %1392, %ENDIF111 ], [ 0.000000e+00, %ENDIF16 ]
>  %.0135 = phi float [ %1390, %ENDIF111 ], [ 0.000000e+00, %ENDIF16 ]
>  %635 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %636 = load <16 x i8>, <16 x i8> addrspace(2)* %635, align 16, !invariant.load !0
>  %637 = call float @llvm.SI.load.const(<16 x i8> %636, i32 384)
>  %638 = fcmp oeq float %637, 1.000000e+00
>  br i1 %638, label %IF118, label %ELSE119
>
>IF23:                                             ; preds = %IF20
>  %639 = call float @llvm.SI.fs.interp(i32 0, i32 0, i32 %6, <2 x i32> %8)
>  %640 = call float @llvm.SI.fs.interp(i32 1, i32 0, i32 %6, <2 x i32> %8)
>  %641 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 4, !amdgpu.uniform !0
>  %642 = load <8 x i32>, <8 x i32> addrspace(2)* %641, align 32, !invariant.load !0
>  %643 = bitcast [32 x <8 x i32>] addrspace(2)* %2 to [0 x <4 x i32>] addrspace(2)*
>  %644 = getelementptr [0 x <4 x i32>], [0 x <4 x i32>] addrspace(2)* %643, i64 0, i64 11, !amdgpu.uniform !0
>  %645 = load <4 x i32>, <4 x i32> addrspace(2)* %644, align 16, !invariant.load !0
>  %646 = bitcast float %639 to i32
>  %647 = bitcast float %640 to i32
>  %648 = insertelement <2 x i32> undef, i32 %646, i32 0
>  %649 = insertelement <2 x i32> %648, i32 %647, i32 1
>  %650 = call <4 x float> @llvm.SI.image.sample.v2i32(<2 x i32> %649, <8 x i32> %642, <4 x i32> %645, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %651 = extractelement <4 x float> %650, i32 0
>  %652 = fsub float 1.000000e+00, %651
>  br label %ENDIF22
>
>ELSE24:                                           ; preds = %IF20
>  %653 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %654 = load <16 x i8>, <16 x i8> addrspace(2)* %653, align 16, !invariant.load !0
>  %655 = call float @llvm.SI.load.const(<16 x i8> %654, i32 576)
>  %656 = fcmp olt float %655, 5.110000e+02
>  br i1 %656, label %IF26, label %ENDIF22
>
>ENDIF22:                                          ; preds = %IF26, %ELSE24, %IF23
>  %.0157 = phi float [ %652, %IF23 ], [ %678, %IF26 ], [ 0.000000e+00, %ELSE24 ]
>  %657 = fadd float %.0157, %577
>  %658 = fmul float %657, %657
>  %659 = fadd float %658, %577
>  %660 = call float @llvm.maxnum.f32(float %657, float 0x3F50624DE0000000)
>  %661 = call float @llvm.AMDGPU.clamp.(float %660, float 0.000000e+00, float 1.000000e+00)
>  %662 = call float @llvm.maxnum.f32(float %659, float 0x3F50624DE0000000)
>  %663 = call float @llvm.AMDGPU.clamp.(float %662, float 0.000000e+00, float 1.000000e+00)
>  %664 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %665 = load <16 x i8>, <16 x i8> addrspace(2)* %664, align 16, !invariant.load !0
>  %666 = call float @llvm.SI.load.const(<16 x i8> %665, i32 612)
>  %667 = fcmp oeq float %666, 1.000000e+00
>  br i1 %667, label %IF29, label %ELSE30
>
>IF26:                                             ; preds = %ELSE24
>  %668 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %669 = load <16 x i8>, <16 x i8> addrspace(2)* %668, align 16, !invariant.load !0
>  %670 = call float @llvm.SI.load.const(<16 x i8> %669, i32 576)
>  %671 = fmul float %670, 4.000000e+00
>  %672 = fadd float %671, -2.000000e+00
>  %673 = call float @llvm.maxnum.f32(float %672, float 2.000000e+00)
>  %674 = call float @llvm.minnum.f32(float %673, float 2.048000e+03)
>  %675 = call float @llvm.log2.f32(float %674)
>  %676 = fadd float %675, -1.000000e+00
>  %677 = fmul float %676, 0x3FB99999A0000000
>  %678 = fsub float 1.000000e+00, %677
>  br label %ENDIF22
>
>IF29:                                             ; preds = %ENDIF22
>  %679 = call float @llvm.SI.fs.interp(i32 0, i32 0, i32 %6, <2 x i32> %8)
>  %680 = call float @llvm.SI.fs.interp(i32 1, i32 0, i32 %6, <2 x i32> %8)
>  %681 = getelementptr [32 x <8 x i32>], [32 x <8 x i32>] addrspace(2)* %2, i64 0, i64 2, !amdgpu.uniform !0
>  %682 = load <8 x i32>, <8 x i32> addrspace(2)* %681, align 32, !invariant.load !0
>  %683 = bitcast [32 x <8 x i32>] addrspace(2)* %2 to [0 x <4 x i32>] addrspace(2)*
>  %684 = getelementptr [0 x <4 x i32>], [0 x <4 x i32>] addrspace(2)* %683, i64 0, i64 7, !amdgpu.uniform !0
>  %685 = load <4 x i32>, <4 x i32> addrspace(2)* %684, align 16, !invariant.load !0
>  %686 = bitcast float %679 to i32
>  %687 = bitcast float %680 to i32
>  %688 = insertelement <2 x i32> undef, i32 %686, i32 0
>  %689 = insertelement <2 x i32> %688, i32 %687, i32 1
>  %690 = call <4 x float> @llvm.SI.image.sample.v2i32(<2 x i32> %689, <8 x i32> %682, <4 x i32> %685, i32 15, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0)
>  %691 = extractelement <4 x float> %690, i32 0
>  %692 = extractelement <4 x float> %690, i32 1
>  %693 = extractelement <4 x float> %690, i32 2
>  %694 = call float @llvm.pow.f32(float %691, float 0x40019999A0000000)
>  %695 = call float @llvm.pow.f32(float %692, float 0x40019999A0000000)
>  %696 = call float @llvm.pow.f32(float %693, float 0x40019999A0000000)
>  br label %ENDIF28
>
>ELSE30:                                           ; preds = %ENDIF22
>  %697 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %698 = load <16 x i8>, <16 x i8> addrspace(2)* %697, align 16, !invariant.load !0
>  %699 = call float @llvm.SI.load.const(<16 x i8> %698, i32 560)
>  %700 = call float @llvm.SI.load.const(<16 x i8> %698, i32 564)
>  %701 = call float @llvm.SI.load.const(<16 x i8> %698, i32 568)
>  br label %ENDIF28
>
>ENDIF28:                                          ; preds = %ELSE30, %IF29
>  %.0176 = phi float [ %696, %IF29 ], [ %701, %ELSE30 ]
>  %.0175 = phi float [ %695, %IF29 ], [ %700, %ELSE30 ]
>  %.0174 = phi float [ %694, %IF29 ], [ %699, %ELSE30 ]
>  %702 = call float @llvm.SI.fs.interp(i32 0, i32 4, i32 %6, <2 x i32> %8)
>  %703 = call float @llvm.SI.fs.interp(i32 1, i32 4, i32 %6, <2 x i32> %8)
>  %704 = call float @llvm.SI.fs.interp(i32 2, i32 4, i32 %6, <2 x i32> %8)
>  %705 = fmul float %702, %702
>  %706 = fmul float %703, %703
>  %707 = fadd float %706, %705
>  %708 = fmul float %704, %704
>  %709 = fadd float %707, %708
>  %710 = call float @llvm.sqrt.f32(float %709)
>  %711 = fdiv float 1.000000e+00, %710, !fpmath !2
>  %712 = fmul float %702, %711
>  %713 = fsub float -0.000000e+00, %712
>  %714 = fmul float %703, %711
>  %715 = fsub float -0.000000e+00, %714
>  %716 = fmul float %704, %711
>  %717 = fsub float -0.000000e+00, %716
>  %718 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %719 = load <16 x i8>, <16 x i8> addrspace(2)* %718, align 16, !invariant.load !0
>  %720 = call float @llvm.SI.load.const(<16 x i8> %719, i32 400)
>  %721 = fmul float %720, %713
>  %722 = call float @llvm.SI.load.const(<16 x i8> %719, i32 404)
>  %723 = fmul float %722, %713
>  %724 = call float @llvm.SI.load.const(<16 x i8> %719, i32 408)
>  %725 = fmul float %724, %713
>  %726 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %727 = load <16 x i8>, <16 x i8> addrspace(2)* %726, align 16, !invariant.load !0
>  %728 = call float @llvm.SI.load.const(<16 x i8> %727, i32 416)
>  %729 = fmul float %728, %715
>  %730 = fadd float %729, %721
>  %731 = call float @llvm.SI.load.const(<16 x i8> %727, i32 420)
>  %732 = fmul float %731, %715
>  %733 = fadd float %732, %723
>  %734 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %735 = load <16 x i8>, <16 x i8> addrspace(2)* %734, align 16, !invariant.load !0
>  %736 = call float @llvm.SI.load.const(<16 x i8> %735, i32 424)
>  %737 = fmul float %736, %715
>  %738 = fadd float %737, %725
>  %739 = call float @llvm.SI.load.const(<16 x i8> %735, i32 432)
>  %740 = fmul float %739, %717
>  %741 = fadd float %740, %730
>  %742 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 0, !amdgpu.uniform !0
>  %743 = load <16 x i8>, <16 x i8> addrspace(2)* %742, align 16, !invariant.load !0
>  %744 = call float @llvm.SI.load.const(<16 x i8> %743, i32 436)
>  %745 = fmul float %744, %717
>  %746 = fadd float %745, %733
>  %747 = call float @llvm.SI.load.const(<16 x i8> %743, i32 440)
>  %748 = fmul float %747, %717
>  %749 = fadd float %748, %738
>  %750 = fmul float %.0199, %741
>  %751 = fmul float %.0200, %746
>  %752 = fadd float %751, %750
>  %753 = fmul float %.0201, %749
>  %754 = fadd float %752, %753
>  %755 = call float @llvm.AMDGPU.clamp.(float %754, float 0.000000e+00, float 1.000000e+00)
>  %756 = getelementptr [16 x <16 x i8>], [16 x <16 x i8>] addrspace(2)* %1, i64 0, i64 1
>  %757 = load <16 x i8>, <16 x i8> addrspace(2)* %756, align 16
>  %758 = bitcast float %.0141 to i32
>  %759 = icmp eq i32 %758, 0
>  %760 = bitcast float %.0141 to i32
>  %761 = icmp eq i32 %760, 0
>  %762 = fmul float %663, %663
>  %763 = fmul float %663, 5.000000e-01
>  %764 = fsub float 1.000000e+00, %755
>  %765 = fmul float %763, %764
>  %766 = fadd float %755, %765
>  %767 = fmul float %.0175, 5.000000e+01
>  %768 = bitcast float %.0141 to i32
>  %769 = icmp eq i32 %768, 0
>  br label %LOOP.outer
>
>LOOP.outer:                                       ; preds = %ENDIF84, %ENDIF28
>  %.0211.ph = phi float [ undef, [1mSept 21 13:16:07.099 info [OSVR: org.osvr.SteamVR]: OSVR client context shut down for org.osvr.SteamVR
>[00m[1mSept 21 13:16:07.099 info [OSVR]: /home/chris/build/osvr-core/src/osvr-core/src/osvr/ClientKit/DisplayC.cpp:50: OSVR_DisplayConfigObject destructor
>[00m

Actions: View

Attachments on bug 97887: 126700 | 126706

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