Attachment 77558 Details for Bug 63236 – kwin command output (stdout and stderr)

kwin command output (stdout and stderr)

kwin.log (text/plain), 87.73 KB, created by Eugene on 2013-04-07 16:28:19 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Eugene

Created: 2013-04-07 16:28:19 UTC

Size: 87.73 KB

patch

obsolete

>QDBusConnection: session D-Bus connection created before QCoreApplication. Application may misbehave.
>kwin(6871) KActivities::ConsumerPrivate::ConsumerPrivate: We are checking whether the service is present true
>kwin(6871) KActivities::ConsumerPrivate::initializeCachedData: Locking mutex for currentActivity
>kwin(6871) KActivities::ConsumerPrivate::initializeCachedData: Locking mutex for listActivities
>kwin(6871) KActivities::ConsumerPrivate::initializeCachedData: Locking mutex for runningActivities
>kwin(6871) KWin::Extensions::init: Extensions: shape: 0x "11"  composite: 0x "4"  render: 0x "b"  fixes: 0x "50"  non_native_pixmaps:  true
>kwin(6871) KDecorationPlugins::canLoad: kwin : path  "/usr/lib/kde4/kwin3_oxygen.so"  for  "kwin3_oxygen"
>kwin(6871) KWin::Workspace::updateClientArea: screens:  1 desktops:  4
>kwin(6871) KWin::Workspace::updateClientArea: Done.
>QCoreApplication::sendPostedEvents: Cannot send posted events for objects in another thread
>QCoreApplication::sendPostedEvents: Cannot send posted events for objects in another thread
>kwin(6871) waitForCallFinished: Trying to lock mutex
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, ASN: 18249647
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, final: 'ID: 31457576 ;WMCLASS: "plasma" : "plasma" ;Caption: "plasma-desktop" ' : 18249647
>kwin(6871) KWin::Workspace::allowClientActivation: Activation: No client active, allowing
>kwin(6871) KWin::Workspace::updateClientArea: screens:  1 desktops:  4
>kwin(6871) KWin::Workspace::updateClientArea: Done.
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, ASN: 4294967295
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, final: 'ID: 31457558 ;WMCLASS: "plasma" : "plasma" ;Caption: "plasma-desktop" ' : 18446744073709551615
>kwin(6871) KWin::Workspace::allowClientActivation: Activation: No client active, allowing
>kwin(6871) KWin::Workspace::updateClientArea: screens:  1 desktops:  4
>kwin(6871) KWin::Workspace::updateClientArea: Done.
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, ASN: 18333213
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, final: 'ID: 65011900 ;WMCLASS: "firefox" : "navigator" ;Caption: "BASH Shell: How To Redirect stderr To stdout ( redirect stderr to a File ) - Mozilla Firefox" ' : 18333213
>kwin(6871) KWin::Workspace::allowClientActivation: Activation: No client active, allowing
>kwin(6871) KWin::Workspace::updateClientArea: screens:  1 desktops:  4
>kwin(6871) KWin::Workspace::updateClientArea: Done.
>kwin(6871) KWin::Client::checkActivities: no activities!?!?
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, ASN: 18398909
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, final: 'ID: 35651613 ;WMCLASS: "konsole" : "konsole" ;Caption: "~ : bash â Konsole" ' : 18398909
>kwin(6871) KWin::Workspace::allowClientActivation: Activation: No client active, allowing
>kwin(6871) KWin::Workspace::updateClientArea: screens:  1 desktops:  4
>kwin(6871) KWin::Workspace::updateClientArea: Done.
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, ASN: 18383029
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, final: 'ID: 29360139 ;WMCLASS: "dolphin" : "dolphin" ;Caption: "eugene â Dolphin" ' : 18383029
>kwin(6871) KWin::Workspace::allowClientActivation: Activation: No client active, allowing
>kwin(6871) KWin::Workspace::updateClientArea: screens:  1 desktops:  4
>kwin(6871) KWin::Workspace::updateClientArea: Done.
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, ASN: 4294967295
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, final: 'ID: 31457549 ;WMCLASS: "plasma" : "plasma" ;Caption: "plasma-desktop" ' : 18446744073709551615
>kwin(6871) KWin::Workspace::allowClientActivation: Activation: No client active, allowing
>kwin(6871) KWin::Workspace::updateClientArea: screens:  1 desktops:  4
>kwin(6871) KWin::Workspace::updateClientArea: Done.
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, ASN: 4294967295
>kwin(6871) KWin::Client::readUserTimeMapTimestamp: User timestamp, final: 'ID: 31457567 ;WMCLASS: "plasma" : "plasma" ;Caption: "plasma-desktop" ' : 18446744073709551615
>kwin(6871) KWin::Workspace::allowClientActivation: Activation: No client active, allowing
>kwin(6871) KWin::Workspace::updateClientArea: screens:  1 desktops:  4
>kwin(6871) KWin::Workspace::updateClientArea: Done.
>kwin(6871) KWin::Workspace::updateClientArea: screens:  1 desktops:  4
>kwin(6871) KWin::Workspace::updateClientArea: Done.
>kwin(6871) KActivities::ConsumerPrivate::listActivitiesCallFinished: Unlocked mutex
>kwin(6871) KActivities::Consumer::listActivities: Returning listActivities ("d49aafc5-4e01-4abe-9698-d906cd512df0")
>QCoreApplication::sendPostedEvents: Cannot send posted events for objects in another thread
>QCoreApplication::sendPostedEvents: Cannot send posted events for objects in another thread
>kwin(6871) waitForCallFinished: Trying to lock mutex
>kwin(6871) KActivities::ConsumerPrivate::currentActivityCallFinished: Unlocked mutex
>kwin(6871) KActivities::Consumer::currentActivity: Returning currentActivity "d49aafc5-4e01-4abe-9698-d906cd512df0"
>kwin(6871) KActivities::ConsumerPrivate::runningActivitiesCallFinished: Unlocked mutex
>kwin(6871) KWin::Compositor::slotCompositingOptionsInitialized: Initializing OpenGL compositing
>kwin(6871) KWin::GlxBackend::initBufferConfigs: Drawable visual (depth  24 ): 0x "140"
>kwin(6871) KWin::GlxBackend::initBufferConfigs: Drawable visual (depth  32 ): 0x "6a"
>kwin(6871) KWin::GlxBackend::initBuffer: Buffer visual (depth  24 ): 0x "144"
>OpenGL vendor string:                   X.Org
>OpenGL renderer string:                 Gallium 0.4 on AMD PITCAIRN
>OpenGL version string:                  2.1 Mesa 9.1.1
>OpenGL shading language version string: 1.20
>Driver:                                 Unknown
>GPU class:                              Unknown
>OpenGL version:                         2.1
>GLSL version:                           1.20
>Mesa version:                           9.1.1
>X server version:                       1.14
>Linux kernel version:                   3.8.5
>Direct rendering:                       yes
>Requires strict binding:                yes
>GLSL shaders:                           yes
>Texture NPOT support:                   yes
>Virtual Machine:                        no
>kwin(6871) KWin::GlxBackend::init: DB: true , Direct: true
>kwin(6871) KWin::SceneOpenGL2::SceneOpenGL2: Color correction: false
>kwin(6871) KWin::ShaderManager::initShaders: Ortho Shader is valid
>kwin(6871) KWin::ShaderManager::initShaders: Generic Shader is valid
>kwin(6871) KWin::ShaderManager::initShaders: Color Shader is valid
>kwin(6871) KWin::SceneOpenGL2::SceneOpenGL2: OpenGL 2 compositing successfully initialized
>kwin(6871) KWin::currentRefreshRate: Vertical Refresh rate  60 Hz
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_slidingpopups"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_blur"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_desktopgrid"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_fade"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_slide"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_presentwindows"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_dashboard"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_login"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_outline"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_maximize"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_logout"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_screenshot"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_translucency"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_highlightwindow"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_zoom"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_dialogparent"
>kwin(6871) KWin::EffectsHandlerImpl::loadEffect: Trying to load  "kwin4_effect_minimizeanimation"
>
># Machine code for function main: Post SSA
>Function Live Ins: %SGPR0_SGPR1 in %vreg0, %SGPR4_SGPR5 in %vreg1, %SGPR2_SGPR3 in %vreg2, %SGPR6 in %vreg3, %VGPR0 in %vreg1035, %VGPR1 in %vreg1036
>
>BB#0: derived from LLVM BB %main_body
>    Live Ins: %SGPR0_SGPR1 %SGPR4_SGPR5 %SGPR2_SGPR3 %SGPR6 %VGPR0 %VGPR1
>	%vreg1036<def> = COPY %VGPR1; VReg_32:%vreg1036
>	%vreg1035<def> = COPY %VGPR0; VReg_32:%vreg1035
>	%vreg3<def> = COPY %SGPR6; SReg_32:%vreg3
>	%vreg2<def> = COPY %SGPR2_SGPR3; SReg_64:%vreg2
>	%vreg1<def> = COPY %SGPR4_SGPR5; SReg_64:%vreg1
>	%vreg0<def> = COPY %SGPR0_SGPR1; SReg_64:%vreg0
>	%EXEC<def> = S_WQM_B64 %EXEC
>	%vreg1028<def> = S_MOV_B32 %vreg3<kill>; M0Reg:%vreg1028 SReg_32:%vreg3
>	%vreg8:sub0<def,read-undef> = V_INTERP_P1_F32 %vreg1035, 0, 0, %vreg1028, %EXEC<imp-use>; VReg_64:%vreg8 VReg_32:%vreg1035 M0Reg:%vreg1028
>	%vreg8:sub0<def,tied1> = V_INTERP_P2_F32 %vreg8:sub0<tied0>, %vreg1036, 0, 0, %vreg1028, %EXEC<imp-use>; VReg_64:%vreg8 VReg_32:%vreg1036 M0Reg:%vreg1028
>	%vreg8:sub1<def> = V_INTERP_P1_F32 %vreg1035, 1, 0, %vreg1028, %EXEC<imp-use>; VReg_64:%vreg8 VReg_32:%vreg1035 M0Reg:%vreg1028
>	%vreg8:sub1<def,tied1> = V_INTERP_P2_F32 %vreg8:sub1<tied0>, %vreg1036, 1, 0, %vreg1028, %EXEC<imp-use>; VReg_64:%vreg8 VReg_32:%vreg1036 M0Reg:%vreg1028
>	%vreg10<def> = V_INTERP_P1_F32 %vreg1035, 3, 0, %vreg1028, %EXEC<imp-use>; VReg_32:%vreg10,%vreg1035 M0Reg:%vreg1028
>	%vreg10<def,dead,tied1> = V_INTERP_P2_F32 %vreg10<tied0>, %vreg1036, 3, 0, %vreg1028, %EXEC<imp-use>; VReg_32:%vreg10,%vreg1036 M0Reg:%vreg1028
>	%vreg11<def> = V_INTERP_P1_F32 %vreg1035<kill>, 2, 0, %vreg1028, %EXEC<imp-use>; VReg_32:%vreg11,%vreg1035 M0Reg:%vreg1028
>	%vreg11<def,dead,tied1> = V_INTERP_P2_F32 %vreg11<tied0>, %vreg1036<kill>, 2, 0, %vreg1028<kill>, %EXEC<imp-use>; VReg_32:%vreg11,%vreg1036 M0Reg:%vreg1028
>	%vreg12<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%13] SReg_128:%vreg12 SReg_64:%vreg2
>	%vreg13<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%10] SReg_256:%vreg13 SReg_64:%vreg1
>	%vreg14<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg8:sub0, %vreg13<kill>, %vreg12<kill>, %EXEC<imp-use>; VReg_128:%vreg14 VReg_64:%vreg8 SReg_256:%vreg13 SReg_128:%vreg12
>	%vreg15<def> = S_LOAD_DWORD_IMM %vreg0, 69; mem:LD4[%42] SReg_32:%vreg15 SReg_64:%vreg0
>	%vreg17<def> = COPY %vreg15<kill>; VReg_32:%vreg17 SReg_32:%vreg15
>	%vreg23:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg17<kill>, %EXEC<imp-use>; VReg_64:%vreg23,%vreg8 VReg_32:%vreg17
>	%vreg18<def> = S_LOAD_DWORD_IMM %vreg0, 68; mem:LD4[%37] SReg_32:%vreg18 SReg_64:%vreg0
>	%vreg20<def> = COPY %vreg18<kill>; VReg_32:%vreg20 SReg_32:%vreg18
>	%vreg23:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg20<kill>, %EXEC<imp-use>; VReg_64:%vreg23,%vreg8 VReg_32:%vreg20
>	%vreg25<def> = S_LOAD_DWORD_IMM %vreg0, 0; mem:LD4[%21] SReg_32:%vreg25 SReg_64:%vreg0
>	%vreg26<def> = S_LOAD_DWORD_IMM %vreg0, 1; mem:LD4[%25] SReg_32:%vreg26 SReg_64:%vreg0
>	%vreg27<def> = S_LOAD_DWORD_IMM %vreg0, 2; mem:LD4[%29] SReg_32:%vreg27 SReg_64:%vreg0
>	%vreg28<def> = S_LOAD_DWORD_IMM %vreg0, 3; mem:LD4[%33] SReg_32:%vreg28 SReg_64:%vreg0
>	%vreg29<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%54] SReg_128:%vreg29 SReg_64:%vreg2
>	%vreg30<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%51] SReg_256:%vreg30 SReg_64:%vreg1
>	%vreg31<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg23:sub0, %vreg30<kill>, %vreg29<kill>, %EXEC<imp-use>; VReg_128:%vreg31 VReg_64:%vreg23 SReg_256:%vreg30 SReg_128:%vreg29
>	%vreg33<def> = S_LOAD_DWORD_IMM %vreg0, 7; mem:LD4[%77] SReg_32:%vreg33 SReg_64:%vreg0
>	%vreg35<def> = COPY %vreg33<kill>; VReg_32:%vreg35 SReg_32:%vreg33
>	%vreg34<def> = V_MUL_F32_e32 %vreg31:sub3, %vreg35<kill>, %EXEC<imp-use>; VReg_32:%vreg34,%vreg35 VReg_128:%vreg31
>	%vreg38<def> = COPY %vreg28<kill>; VReg_32:%vreg38 SReg_32:%vreg28
>	%vreg37<def> = V_MUL_F32_e32 %vreg14:sub3, %vreg38<kill>, %EXEC<imp-use>; VReg_32:%vreg37,%vreg38 VReg_128:%vreg14
>	%vreg39<def> = V_ADD_F32_e32 %vreg34<kill>, %vreg37<kill>, %EXEC<imp-use>; VReg_32:%vreg39,%vreg34,%vreg37
>	%vreg40<def> = S_LOAD_DWORD_IMM %vreg0, 69; mem:LD4[%86] SReg_32:%vreg40 SReg_64:%vreg0
>	%vreg42<def> = COPY %vreg40<kill>; VReg_32:%vreg42 SReg_32:%vreg40
>	%vreg48:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg42<kill>, %EXEC<imp-use>; VReg_64:%vreg48,%vreg8 VReg_32:%vreg42
>	%vreg43<def> = S_LOAD_DWORD_IMM %vreg0, 68; mem:LD4[%82] SReg_32:%vreg43 SReg_64:%vreg0
>	%vreg45<def> = COPY %vreg43<kill>; VReg_32:%vreg45 SReg_32:%vreg43
>	%vreg48:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg45<kill>, %EXEC<imp-use>; VReg_64:%vreg48,%vreg8 VReg_32:%vreg45
>	%vreg50<def> = S_LOAD_DWORD_IMM %vreg0, 4; mem:LD4[%62] SReg_32:%vreg50 SReg_64:%vreg0
>	%vreg51<def> = S_LOAD_DWORD_IMM %vreg0, 5; mem:LD4[%67] SReg_32:%vreg51 SReg_64:%vreg0
>	%vreg52<def> = S_LOAD_DWORD_IMM %vreg0, 6; mem:LD4[%72] SReg_32:%vreg52 SReg_64:%vreg0
>	%vreg53<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%97] SReg_128:%vreg53 SReg_64:%vreg2
>	%vreg54<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%94] SReg_256:%vreg54 SReg_64:%vreg1
>	%vreg55<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg48:sub0, %vreg54<kill>, %vreg53<kill>, %EXEC<imp-use>; VReg_128:%vreg55 VReg_64:%vreg48 SReg_256:%vreg54 SReg_128:%vreg53
>	%vreg57<def> = S_LOAD_DWORD_IMM %vreg0, 7; mem:LD4[%120] SReg_32:%vreg57 SReg_64:%vreg0
>	%vreg59<def> = COPY %vreg57<kill>; VReg_32:%vreg59 SReg_32:%vreg57
>	%vreg58<def> = V_MUL_F32_e32 %vreg55:sub3, %vreg59<kill>, %EXEC<imp-use>; VReg_32:%vreg58,%vreg59 VReg_128:%vreg55
>	%vreg60<def> = V_ADD_F32_e32 %vreg58<kill>, %vreg39<kill>, %EXEC<imp-use>; VReg_32:%vreg60,%vreg58,%vreg39
>	%vreg61<def> = S_LOAD_DWORD_IMM %vreg0, 73; mem:LD4[%130] SReg_32:%vreg61 SReg_64:%vreg0
>	%vreg63<def> = COPY %vreg61<kill>; VReg_32:%vreg63 SReg_32:%vreg61
>	%vreg69:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg63<kill>, %EXEC<imp-use>; VReg_64:%vreg69,%vreg8 VReg_32:%vreg63
>	%vreg64<def> = S_LOAD_DWORD_IMM %vreg0, 72; mem:LD4[%125] SReg_32:%vreg64 SReg_64:%vreg0
>	%vreg66<def> = COPY %vreg64<kill>; VReg_32:%vreg66 SReg_32:%vreg64
>	%vreg69:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg66<kill>, %EXEC<imp-use>; VReg_64:%vreg69,%vreg8 VReg_32:%vreg66
>	%vreg71<def> = S_LOAD_DWORD_IMM %vreg0, 4; mem:LD4[%105] SReg_32:%vreg71 SReg_64:%vreg0
>	%vreg72<def> = S_LOAD_DWORD_IMM %vreg0, 5; mem:LD4[%110] SReg_32:%vreg72 SReg_64:%vreg0
>	%vreg73<def> = S_LOAD_DWORD_IMM %vreg0, 6; mem:LD4[%115] SReg_32:%vreg73 SReg_64:%vreg0
>	%vreg74<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%142] SReg_128:%vreg74 SReg_64:%vreg2
>	%vreg75<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%139] SReg_256:%vreg75 SReg_64:%vreg1
>	%vreg76<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg69:sub0, %vreg75<kill>, %vreg74<kill>, %EXEC<imp-use>; VReg_128:%vreg76 VReg_64:%vreg69 SReg_256:%vreg75 SReg_128:%vreg74
>	%vreg78<def> = S_LOAD_DWORD_IMM %vreg0, 11; mem:LD4[%165] SReg_32:%vreg78 SReg_64:%vreg0
>	%vreg80<def> = COPY %vreg78<kill>; VReg_32:%vreg80 SReg_32:%vreg78
>	%vreg79<def> = V_MUL_F32_e32 %vreg76:sub3, %vreg80<kill>, %EXEC<imp-use>; VReg_32:%vreg79,%vreg80 VReg_128:%vreg76
>	%vreg81<def> = V_ADD_F32_e32 %vreg79<kill>, %vreg60<kill>, %EXEC<imp-use>; VReg_32:%vreg81,%vreg79,%vreg60
>	%vreg82<def> = S_LOAD_DWORD_IMM %vreg0, 73; mem:LD4[%174] SReg_32:%vreg82 SReg_64:%vreg0
>	%vreg84<def> = COPY %vreg82<kill>; VReg_32:%vreg84 SReg_32:%vreg82
>	%vreg90:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg84<kill>, %EXEC<imp-use>; VReg_64:%vreg90,%vreg8 VReg_32:%vreg84
>	%vreg85<def> = S_LOAD_DWORD_IMM %vreg0, 72; mem:LD4[%170] SReg_32:%vreg85 SReg_64:%vreg0
>	%vreg87<def> = COPY %vreg85<kill>; VReg_32:%vreg87 SReg_32:%vreg85
>	%vreg90:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg87<kill>, %EXEC<imp-use>; VReg_64:%vreg90,%vreg8 VReg_32:%vreg87
>	%vreg92<def> = S_LOAD_DWORD_IMM %vreg0, 8; mem:LD4[%150] SReg_32:%vreg92 SReg_64:%vreg0
>	%vreg93<def> = S_LOAD_DWORD_IMM %vreg0, 9; mem:LD4[%155] SReg_32:%vreg93 SReg_64:%vreg0
>	%vreg94<def> = S_LOAD_DWORD_IMM %vreg0, 10; mem:LD4[%160] SReg_32:%vreg94 SReg_64:%vreg0
>	%vreg95<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%185] SReg_128:%vreg95 SReg_64:%vreg2
>	%vreg96<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%182] SReg_256:%vreg96 SReg_64:%vreg1
>	%vreg97<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg90:sub0, %vreg96<kill>, %vreg95<kill>, %EXEC<imp-use>; VReg_128:%vreg97 VReg_64:%vreg90 SReg_256:%vreg96 SReg_128:%vreg95
>	%vreg99<def> = S_LOAD_DWORD_IMM %vreg0, 11; mem:LD4[%208] SReg_32:%vreg99 SReg_64:%vreg0
>	%vreg101<def> = COPY %vreg99<kill>; VReg_32:%vreg101 SReg_32:%vreg99
>	%vreg100<def> = V_MUL_F32_e32 %vreg97:sub3, %vreg101<kill>, %EXEC<imp-use>; VReg_32:%vreg100,%vreg101 VReg_128:%vreg97
>	%vreg102<def> = V_ADD_F32_e32 %vreg100<kill>, %vreg81<kill>, %EXEC<imp-use>; VReg_32:%vreg102,%vreg100,%vreg81
>	%vreg103<def> = S_LOAD_DWORD_IMM %vreg0, 77; mem:LD4[%218] SReg_32:%vreg103 SReg_64:%vreg0
>	%vreg105<def> = COPY %vreg103<kill>; VReg_32:%vreg105 SReg_32:%vreg103
>	%vreg111:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg105<kill>, %EXEC<imp-use>; VReg_64:%vreg111,%vreg8 VReg_32:%vreg105
>	%vreg106<def> = S_LOAD_DWORD_IMM %vreg0, 76; mem:LD4[%213] SReg_32:%vreg106 SReg_64:%vreg0
>	%vreg108<def> = COPY %vreg106<kill>; VReg_32:%vreg108 SReg_32:%vreg106
>	%vreg111:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg108<kill>, %EXEC<imp-use>; VReg_64:%vreg111,%vreg8 VReg_32:%vreg108
>	%vreg113<def> = S_LOAD_DWORD_IMM %vreg0, 8; mem:LD4[%193] SReg_32:%vreg113 SReg_64:%vreg0
>	%vreg114<def> = S_LOAD_DWORD_IMM %vreg0, 9; mem:LD4[%198] SReg_32:%vreg114 SReg_64:%vreg0
>	%vreg115<def> = S_LOAD_DWORD_IMM %vreg0, 10; mem:LD4[%203] SReg_32:%vreg115 SReg_64:%vreg0
>	%vreg116<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%230] SReg_128:%vreg116 SReg_64:%vreg2
>	%vreg117<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%227] SReg_256:%vreg117 SReg_64:%vreg1
>	%vreg118<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg111:sub0, %vreg117<kill>, %vreg116<kill>, %EXEC<imp-use>; VReg_128:%vreg118 VReg_64:%vreg111 SReg_256:%vreg117 SReg_128:%vreg116
>	%vreg120<def> = S_LOAD_DWORD_IMM %vreg0, 15; mem:LD4[%253] SReg_32:%vreg120 SReg_64:%vreg0
>	%vreg122<def> = COPY %vreg120<kill>; VReg_32:%vreg122 SReg_32:%vreg120
>	%vreg121<def> = V_MUL_F32_e32 %vreg118:sub3, %vreg122<kill>, %EXEC<imp-use>; VReg_32:%vreg121,%vreg122 VReg_128:%vreg118
>	%vreg123<def> = V_ADD_F32_e32 %vreg121<kill>, %vreg102<kill>, %EXEC<imp-use>; VReg_32:%vreg123,%vreg121,%vreg102
>	%vreg124<def> = S_LOAD_DWORD_IMM %vreg0, 77; mem:LD4[%262] SReg_32:%vreg124 SReg_64:%vreg0
>	%vreg126<def> = COPY %vreg124<kill>; VReg_32:%vreg126 SReg_32:%vreg124
>	%vreg132:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg126<kill>, %EXEC<imp-use>; VReg_64:%vreg132,%vreg8 VReg_32:%vreg126
>	%vreg127<def> = S_LOAD_DWORD_IMM %vreg0, 76; mem:LD4[%258] SReg_32:%vreg127 SReg_64:%vreg0
>	%vreg129<def> = COPY %vreg127<kill>; VReg_32:%vreg129 SReg_32:%vreg127
>	%vreg132:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg129<kill>, %EXEC<imp-use>; VReg_64:%vreg132,%vreg8 VReg_32:%vreg129
>	%vreg134<def> = S_LOAD_DWORD_IMM %vreg0, 12; mem:LD4[%238] SReg_32:%vreg134 SReg_64:%vreg0
>	%vreg135<def> = S_LOAD_DWORD_IMM %vreg0, 13; mem:LD4[%243] SReg_32:%vreg135 SReg_64:%vreg0
>	%vreg136<def> = S_LOAD_DWORD_IMM %vreg0, 14; mem:LD4[%248] SReg_32:%vreg136 SReg_64:%vreg0
>	%vreg137<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%273] SReg_128:%vreg137 SReg_64:%vreg2
>	%vreg138<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%270] SReg_256:%vreg138 SReg_64:%vreg1
>	%vreg139<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg132:sub0, %vreg138<kill>, %vreg137<kill>, %EXEC<imp-use>; VReg_128:%vreg139 VReg_64:%vreg132 SReg_256:%vreg138 SReg_128:%vreg137
>	%vreg141<def> = S_LOAD_DWORD_IMM %vreg0, 15; mem:LD4[%296] SReg_32:%vreg141 SReg_64:%vreg0
>	%vreg143<def> = COPY %vreg141<kill>; VReg_32:%vreg143 SReg_32:%vreg141
>	%vreg142<def> = V_MUL_F32_e32 %vreg139:sub3, %vreg143<kill>, %EXEC<imp-use>; VReg_32:%vreg142,%vreg143 VReg_128:%vreg139
>	%vreg144<def> = V_ADD_F32_e32 %vreg142<kill>, %vreg123<kill>, %EXEC<imp-use>; VReg_32:%vreg144,%vreg142,%vreg123
>	%vreg145<def> = S_LOAD_DWORD_IMM %vreg0, 81; mem:LD4[%306] SReg_32:%vreg145 SReg_64:%vreg0
>	%vreg147<def> = COPY %vreg145<kill>; VReg_32:%vreg147 SReg_32:%vreg145
>	%vreg153:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg147<kill>, %EXEC<imp-use>; VReg_64:%vreg153,%vreg8 VReg_32:%vreg147
>	%vreg148<def> = S_LOAD_DWORD_IMM %vreg0, 80; mem:LD4[%301] SReg_32:%vreg148 SReg_64:%vreg0
>	%vreg150<def> = COPY %vreg148<kill>; VReg_32:%vreg150 SReg_32:%vreg148
>	%vreg153:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg150<kill>, %EXEC<imp-use>; VReg_64:%vreg153,%vreg8 VReg_32:%vreg150
>	%vreg155<def> = S_LOAD_DWORD_IMM %vreg0, 12; mem:LD4[%281] SReg_32:%vreg155 SReg_64:%vreg0
>	%vreg156<def> = S_LOAD_DWORD_IMM %vreg0, 13; mem:LD4[%286] SReg_32:%vreg156 SReg_64:%vreg0
>	%vreg157<def> = S_LOAD_DWORD_IMM %vreg0, 14; mem:LD4[%291] SReg_32:%vreg157 SReg_64:%vreg0
>	%vreg158<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%318] SReg_128:%vreg158 SReg_64:%vreg2
>	%vreg159<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%315] SReg_256:%vreg159 SReg_64:%vreg1
>	%vreg160<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg153:sub0, %vreg159<kill>, %vreg158<kill>, %EXEC<imp-use>; VReg_128:%vreg160 VReg_64:%vreg153 SReg_256:%vreg159 SReg_128:%vreg158
>	%vreg162<def> = S_LOAD_DWORD_IMM %vreg0, 19; mem:LD4[%341] SReg_32:%vreg162 SReg_64:%vreg0
>	%vreg164<def> = COPY %vreg162<kill>; VReg_32:%vreg164 SReg_32:%vreg162
>	%vreg163<def> = V_MUL_F32_e32 %vreg160:sub3, %vreg164<kill>, %EXEC<imp-use>; VReg_32:%vreg163,%vreg164 VReg_128:%vreg160
>	%vreg165<def> = V_ADD_F32_e32 %vreg163<kill>, %vreg144<kill>, %EXEC<imp-use>; VReg_32:%vreg165,%vreg163,%vreg144
>	%vreg166<def> = S_LOAD_DWORD_IMM %vreg0, 81; mem:LD4[%350] SReg_32:%vreg166 SReg_64:%vreg0
>	%vreg168<def> = COPY %vreg166<kill>; VReg_32:%vreg168 SReg_32:%vreg166
>	%vreg174:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg168<kill>, %EXEC<imp-use>; VReg_64:%vreg174,%vreg8 VReg_32:%vreg168
>	%vreg169<def> = S_LOAD_DWORD_IMM %vreg0, 80; mem:LD4[%346] SReg_32:%vreg169 SReg_64:%vreg0
>	%vreg171<def> = COPY %vreg169<kill>; VReg_32:%vreg171 SReg_32:%vreg169
>	%vreg174:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg171<kill>, %EXEC<imp-use>; VReg_64:%vreg174,%vreg8 VReg_32:%vreg171
>	%vreg176<def> = S_LOAD_DWORD_IMM %vreg0, 16; mem:LD4[%326] SReg_32:%vreg176 SReg_64:%vreg0
>	%vreg177<def> = S_LOAD_DWORD_IMM %vreg0, 17; mem:LD4[%331] SReg_32:%vreg177 SReg_64:%vreg0
>	%vreg178<def> = S_LOAD_DWORD_IMM %vreg0, 18; mem:LD4[%336] SReg_32:%vreg178 SReg_64:%vreg0
>	%vreg179<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%361] SReg_128:%vreg179 SReg_64:%vreg2
>	%vreg180<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%358] SReg_256:%vreg180 SReg_64:%vreg1
>	%vreg181<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg174:sub0, %vreg180<kill>, %vreg179<kill>, %EXEC<imp-use>; VReg_128:%vreg181 VReg_64:%vreg174 SReg_256:%vreg180 SReg_128:%vreg179
>	%vreg183<def> = S_LOAD_DWORD_IMM %vreg0, 19; mem:LD4[%384] SReg_32:%vreg183 SReg_64:%vreg0
>	%vreg185<def> = COPY %vreg183<kill>; VReg_32:%vreg185 SReg_32:%vreg183
>	%vreg184<def> = V_MUL_F32_e32 %vreg181:sub3, %vreg185<kill>, %EXEC<imp-use>; VReg_32:%vreg184,%vreg185 VReg_128:%vreg181
>	%vreg186<def> = V_ADD_F32_e32 %vreg184<kill>, %vreg165<kill>, %EXEC<imp-use>; VReg_32:%vreg186,%vreg184,%vreg165
>	%vreg187<def> = S_LOAD_DWORD_IMM %vreg0, 85; mem:LD4[%394] SReg_32:%vreg187 SReg_64:%vreg0
>	%vreg189<def> = COPY %vreg187<kill>; VReg_32:%vreg189 SReg_32:%vreg187
>	%vreg195:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg189<kill>, %EXEC<imp-use>; VReg_64:%vreg195,%vreg8 VReg_32:%vreg189
>	%vreg190<def> = S_LOAD_DWORD_IMM %vreg0, 84; mem:LD4[%389] SReg_32:%vreg190 SReg_64:%vreg0
>	%vreg192<def> = COPY %vreg190<kill>; VReg_32:%vreg192 SReg_32:%vreg190
>	%vreg195:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg192<kill>, %EXEC<imp-use>; VReg_64:%vreg195,%vreg8 VReg_32:%vreg192
>	%vreg197<def> = S_LOAD_DWORD_IMM %vreg0, 16; mem:LD4[%369] SReg_32:%vreg197 SReg_64:%vreg0
>	%vreg198<def> = S_LOAD_DWORD_IMM %vreg0, 17; mem:LD4[%374] SReg_32:%vreg198 SReg_64:%vreg0
>	%vreg199<def> = S_LOAD_DWORD_IMM %vreg0, 18; mem:LD4[%379] SReg_32:%vreg199 SReg_64:%vreg0
>	%vreg200<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%406] SReg_128:%vreg200 SReg_64:%vreg2
>	%vreg201<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%403] SReg_256:%vreg201 SReg_64:%vreg1
>	%vreg202<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg195:sub0, %vreg201<kill>, %vreg200<kill>, %EXEC<imp-use>; VReg_128:%vreg202 VReg_64:%vreg195 SReg_256:%vreg201 SReg_128:%vreg200
>	%vreg204<def> = S_LOAD_DWORD_IMM %vreg0, 23; mem:LD4[%429] SReg_32:%vreg204 SReg_64:%vreg0
>	%vreg206<def> = COPY %vreg204<kill>; VReg_32:%vreg206 SReg_32:%vreg204
>	%vreg205<def> = V_MUL_F32_e32 %vreg202:sub3, %vreg206<kill>, %EXEC<imp-use>; VReg_32:%vreg205,%vreg206 VReg_128:%vreg202
>	%vreg207<def> = V_ADD_F32_e32 %vreg205<kill>, %vreg186<kill>, %EXEC<imp-use>; VReg_32:%vreg207,%vreg205,%vreg186
>	%vreg208<def> = S_LOAD_DWORD_IMM %vreg0, 85; mem:LD4[%438] SReg_32:%vreg208 SReg_64:%vreg0
>	%vreg210<def> = COPY %vreg208<kill>; VReg_32:%vreg210 SReg_32:%vreg208
>	%vreg216:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg210<kill>, %EXEC<imp-use>; VReg_64:%vreg216,%vreg8 VReg_32:%vreg210
>	%vreg211<def> = S_LOAD_DWORD_IMM %vreg0, 84; mem:LD4[%434] SReg_32:%vreg211 SReg_64:%vreg0
>	%vreg213<def> = COPY %vreg211<kill>; VReg_32:%vreg213 SReg_32:%vreg211
>	%vreg216:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg213<kill>, %EXEC<imp-use>; VReg_64:%vreg216,%vreg8 VReg_32:%vreg213
>	%vreg218<def> = S_LOAD_DWORD_IMM %vreg0, 20; mem:LD4[%414] SReg_32:%vreg218 SReg_64:%vreg0
>	%vreg219<def> = S_LOAD_DWORD_IMM %vreg0, 21; mem:LD4[%419] SReg_32:%vreg219 SReg_64:%vreg0
>	%vreg220<def> = S_LOAD_DWORD_IMM %vreg0, 22; mem:LD4[%424] SReg_32:%vreg220 SReg_64:%vreg0
>	%vreg221<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%449] SReg_128:%vreg221 SReg_64:%vreg2
>	%vreg222<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%446] SReg_256:%vreg222 SReg_64:%vreg1
>	%vreg223<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg216:sub0, %vreg222<kill>, %vreg221<kill>, %EXEC<imp-use>; VReg_128:%vreg223 VReg_64:%vreg216 SReg_256:%vreg222 SReg_128:%vreg221
>	%vreg225<def> = S_LOAD_DWORD_IMM %vreg0, 23; mem:LD4[%472] SReg_32:%vreg225 SReg_64:%vreg0
>	%vreg227<def> = COPY %vreg225<kill>; VReg_32:%vreg227 SReg_32:%vreg225
>	%vreg226<def> = V_MUL_F32_e32 %vreg223:sub3, %vreg227<kill>, %EXEC<imp-use>; VReg_32:%vreg226,%vreg227 VReg_128:%vreg223
>	%vreg228<def> = V_ADD_F32_e32 %vreg226<kill>, %vreg207<kill>, %EXEC<imp-use>; VReg_32:%vreg228,%vreg226,%vreg207
>	%vreg229<def> = S_LOAD_DWORD_IMM %vreg0, 89; mem:LD4[%482] SReg_32:%vreg229 SReg_64:%vreg0
>	%vreg231<def> = COPY %vreg229<kill>; VReg_32:%vreg231 SReg_32:%vreg229
>	%vreg237:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg231<kill>, %EXEC<imp-use>; VReg_64:%vreg237,%vreg8 VReg_32:%vreg231
>	%vreg232<def> = S_LOAD_DWORD_IMM %vreg0, 88; mem:LD4[%477] SReg_32:%vreg232 SReg_64:%vreg0
>	%vreg234<def> = COPY %vreg232<kill>; VReg_32:%vreg234 SReg_32:%vreg232
>	%vreg237:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg234<kill>, %EXEC<imp-use>; VReg_64:%vreg237,%vreg8 VReg_32:%vreg234
>	%vreg239<def> = S_LOAD_DWORD_IMM %vreg0, 20; mem:LD4[%457] SReg_32:%vreg239 SReg_64:%vreg0
>	%vreg240<def> = S_LOAD_DWORD_IMM %vreg0, 21; mem:LD4[%462] SReg_32:%vreg240 SReg_64:%vreg0
>	%vreg241<def> = S_LOAD_DWORD_IMM %vreg0, 22; mem:LD4[%467] SReg_32:%vreg241 SReg_64:%vreg0
>	%vreg242<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%494] SReg_128:%vreg242 SReg_64:%vreg2
>	%vreg243<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%491] SReg_256:%vreg243 SReg_64:%vreg1
>	%vreg244<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg237:sub0, %vreg243<kill>, %vreg242<kill>, %EXEC<imp-use>; VReg_128:%vreg244 VReg_64:%vreg237 SReg_256:%vreg243 SReg_128:%vreg242
>	%vreg246<def> = S_LOAD_DWORD_IMM %vreg0, 27; mem:LD4[%517] SReg_32:%vreg246 SReg_64:%vreg0
>	%vreg248<def> = COPY %vreg246<kill>; VReg_32:%vreg248 SReg_32:%vreg246
>	%vreg247<def> = V_MUL_F32_e32 %vreg244:sub3, %vreg248<kill>, %EXEC<imp-use>; VReg_32:%vreg247,%vreg248 VReg_128:%vreg244
>	%vreg249<def> = V_ADD_F32_e32 %vreg247<kill>, %vreg228<kill>, %EXEC<imp-use>; VReg_32:%vreg249,%vreg247,%vreg228
>	%vreg250<def> = S_LOAD_DWORD_IMM %vreg0, 89; mem:LD4[%526] SReg_32:%vreg250 SReg_64:%vreg0
>	%vreg252<def> = COPY %vreg250<kill>; VReg_32:%vreg252 SReg_32:%vreg250
>	%vreg258:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg252<kill>, %EXEC<imp-use>; VReg_64:%vreg258,%vreg8 VReg_32:%vreg252
>	%vreg253<def> = S_LOAD_DWORD_IMM %vreg0, 88; mem:LD4[%522] SReg_32:%vreg253 SReg_64:%vreg0
>	%vreg255<def> = COPY %vreg253<kill>; VReg_32:%vreg255 SReg_32:%vreg253
>	%vreg258:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg255<kill>, %EXEC<imp-use>; VReg_64:%vreg258,%vreg8 VReg_32:%vreg255
>	%vreg260<def> = S_LOAD_DWORD_IMM %vreg0, 24; mem:LD4[%502] SReg_32:%vreg260 SReg_64:%vreg0
>	%vreg261<def> = S_LOAD_DWORD_IMM %vreg0, 25; mem:LD4[%507] SReg_32:%vreg261 SReg_64:%vreg0
>	%vreg262<def> = S_LOAD_DWORD_IMM %vreg0, 26; mem:LD4[%512] SReg_32:%vreg262 SReg_64:%vreg0
>	%vreg263<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%537] SReg_128:%vreg263 SReg_64:%vreg2
>	%vreg264<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%534] SReg_256:%vreg264 SReg_64:%vreg1
>	%vreg265<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg258:sub0, %vreg264<kill>, %vreg263<kill>, %EXEC<imp-use>; VReg_128:%vreg265 VReg_64:%vreg258 SReg_256:%vreg264 SReg_128:%vreg263
>	%vreg267<def> = S_LOAD_DWORD_IMM %vreg0, 27; mem:LD4[%560] SReg_32:%vreg267 SReg_64:%vreg0
>	%vreg269<def> = COPY %vreg267<kill>; VReg_32:%vreg269 SReg_32:%vreg267
>	%vreg268<def> = V_MUL_F32_e32 %vreg265:sub3, %vreg269<kill>, %EXEC<imp-use>; VReg_32:%vreg268,%vreg269 VReg_128:%vreg265
>	%vreg270<def> = V_ADD_F32_e32 %vreg268<kill>, %vreg249<kill>, %EXEC<imp-use>; VReg_32:%vreg270,%vreg268,%vreg249
>	%vreg271<def> = S_LOAD_DWORD_IMM %vreg0, 93; mem:LD4[%570] SReg_32:%vreg271 SReg_64:%vreg0
>	%vreg273<def> = COPY %vreg271<kill>; VReg_32:%vreg273 SReg_32:%vreg271
>	%vreg279:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg273<kill>, %EXEC<imp-use>; VReg_64:%vreg279,%vreg8 VReg_32:%vreg273
>	%vreg274<def> = S_LOAD_DWORD_IMM %vreg0, 92; mem:LD4[%565] SReg_32:%vreg274 SReg_64:%vreg0
>	%vreg276<def> = COPY %vreg274<kill>; VReg_32:%vreg276 SReg_32:%vreg274
>	%vreg279:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg276<kill>, %EXEC<imp-use>; VReg_64:%vreg279,%vreg8 VReg_32:%vreg276
>	%vreg281<def> = S_LOAD_DWORD_IMM %vreg0, 24; mem:LD4[%545] SReg_32:%vreg281 SReg_64:%vreg0
>	%vreg282<def> = S_LOAD_DWORD_IMM %vreg0, 25; mem:LD4[%550] SReg_32:%vreg282 SReg_64:%vreg0
>	%vreg283<def> = S_LOAD_DWORD_IMM %vreg0, 26; mem:LD4[%555] SReg_32:%vreg283 SReg_64:%vreg0
>	%vreg284<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%582] SReg_128:%vreg284 SReg_64:%vreg2
>	%vreg285<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%579] SReg_256:%vreg285 SReg_64:%vreg1
>	%vreg286<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg279:sub0, %vreg285<kill>, %vreg284<kill>, %EXEC<imp-use>; VReg_128:%vreg286 VReg_64:%vreg279 SReg_256:%vreg285 SReg_128:%vreg284
>	%vreg288<def> = S_LOAD_DWORD_IMM %vreg0, 31; mem:LD4[%605] SReg_32:%vreg288 SReg_64:%vreg0
>	%vreg290<def> = COPY %vreg288<kill>; VReg_32:%vreg290 SReg_32:%vreg288
>	%vreg289<def> = V_MUL_F32_e32 %vreg286:sub3, %vreg290<kill>, %EXEC<imp-use>; VReg_32:%vreg289,%vreg290 VReg_128:%vreg286
>	%vreg291<def> = V_ADD_F32_e32 %vreg289<kill>, %vreg270<kill>, %EXEC<imp-use>; VReg_32:%vreg291,%vreg289,%vreg270
>	%vreg292<def> = S_LOAD_DWORD_IMM %vreg0, 93; mem:LD4[%614] SReg_32:%vreg292 SReg_64:%vreg0
>	%vreg294<def> = COPY %vreg292<kill>; VReg_32:%vreg294 SReg_32:%vreg292
>	%vreg300:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg294<kill>, %EXEC<imp-use>; VReg_64:%vreg300,%vreg8 VReg_32:%vreg294
>	%vreg295<def> = S_LOAD_DWORD_IMM %vreg0, 92; mem:LD4[%610] SReg_32:%vreg295 SReg_64:%vreg0
>	%vreg297<def> = COPY %vreg295<kill>; VReg_32:%vreg297 SReg_32:%vreg295
>	%vreg300:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg297<kill>, %EXEC<imp-use>; VReg_64:%vreg300,%vreg8 VReg_32:%vreg297
>	%vreg302<def> = S_LOAD_DWORD_IMM %vreg0, 28; mem:LD4[%590] SReg_32:%vreg302 SReg_64:%vreg0
>	%vreg303<def> = S_LOAD_DWORD_IMM %vreg0, 29; mem:LD4[%595] SReg_32:%vreg303 SReg_64:%vreg0
>	%vreg304<def> = S_LOAD_DWORD_IMM %vreg0, 30; mem:LD4[%600] SReg_32:%vreg304 SReg_64:%vreg0
>	%vreg305<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%625] SReg_128:%vreg305 SReg_64:%vreg2
>	%vreg306<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%622] SReg_256:%vreg306 SReg_64:%vreg1
>	%vreg307<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg300:sub0, %vreg306<kill>, %vreg305<kill>, %EXEC<imp-use>; VReg_128:%vreg307 VReg_64:%vreg300 SReg_256:%vreg306 SReg_128:%vreg305
>	%vreg309<def> = S_LOAD_DWORD_IMM %vreg0, 31; mem:LD4[%648] SReg_32:%vreg309 SReg_64:%vreg0
>	%vreg311<def> = COPY %vreg309<kill>; VReg_32:%vreg311 SReg_32:%vreg309
>	%vreg310<def> = V_MUL_F32_e32 %vreg307:sub3, %vreg311<kill>, %EXEC<imp-use>; VReg_32:%vreg310,%vreg311 VReg_128:%vreg307
>	%vreg312<def> = V_ADD_F32_e32 %vreg310<kill>, %vreg291<kill>, %EXEC<imp-use>; VReg_32:%vreg312,%vreg310,%vreg291
>	%vreg313<def> = S_LOAD_DWORD_IMM %vreg0, 97; mem:LD4[%658] SReg_32:%vreg313 SReg_64:%vreg0
>	%vreg315<def> = COPY %vreg313<kill>; VReg_32:%vreg315 SReg_32:%vreg313
>	%vreg321:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg315<kill>, %EXEC<imp-use>; VReg_64:%vreg321,%vreg8 VReg_32:%vreg315
>	%vreg316<def> = S_LOAD_DWORD_IMM %vreg0, 96; mem:LD4[%653] SReg_32:%vreg316 SReg_64:%vreg0
>	%vreg318<def> = COPY %vreg316<kill>; VReg_32:%vreg318 SReg_32:%vreg316
>	%vreg321:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg318<kill>, %EXEC<imp-use>; VReg_64:%vreg321,%vreg8 VReg_32:%vreg318
>	%vreg323<def> = S_LOAD_DWORD_IMM %vreg0, 28; mem:LD4[%633] SReg_32:%vreg323 SReg_64:%vreg0
>	%vreg324<def> = S_LOAD_DWORD_IMM %vreg0, 29; mem:LD4[%638] SReg_32:%vreg324 SReg_64:%vreg0
>	%vreg325<def> = S_LOAD_DWORD_IMM %vreg0, 30; mem:LD4[%643] SReg_32:%vreg325 SReg_64:%vreg0
>	%vreg326<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%670] SReg_128:%vreg326 SReg_64:%vreg2
>	%vreg327<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%667] SReg_256:%vreg327 SReg_64:%vreg1
>	%vreg328<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg321:sub0, %vreg327<kill>, %vreg326<kill>, %EXEC<imp-use>; VReg_128:%vreg328 VReg_64:%vreg321 SReg_256:%vreg327 SReg_128:%vreg326
>	%vreg330<def> = S_LOAD_DWORD_IMM %vreg0, 35; mem:LD4[%693] SReg_32:%vreg330 SReg_64:%vreg0
>	%vreg332<def> = COPY %vreg330<kill>; VReg_32:%vreg332 SReg_32:%vreg330
>	%vreg331<def> = V_MUL_F32_e32 %vreg328:sub3, %vreg332<kill>, %EXEC<imp-use>; VReg_32:%vreg331,%vreg332 VReg_128:%vreg328
>	%vreg333<def> = V_ADD_F32_e32 %vreg331<kill>, %vreg312<kill>, %EXEC<imp-use>; VReg_32:%vreg333,%vreg331,%vreg312
>	%vreg334<def> = S_LOAD_DWORD_IMM %vreg0, 97; mem:LD4[%702] SReg_32:%vreg334 SReg_64:%vreg0
>	%vreg336<def> = COPY %vreg334<kill>; VReg_32:%vreg336 SReg_32:%vreg334
>	%vreg342:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg336<kill>, %EXEC<imp-use>; VReg_64:%vreg342,%vreg8 VReg_32:%vreg336
>	%vreg337<def> = S_LOAD_DWORD_IMM %vreg0, 96; mem:LD4[%698] SReg_32:%vreg337 SReg_64:%vreg0
>	%vreg339<def> = COPY %vreg337<kill>; VReg_32:%vreg339 SReg_32:%vreg337
>	%vreg342:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg339<kill>, %EXEC<imp-use>; VReg_64:%vreg342,%vreg8 VReg_32:%vreg339
>	%vreg344<def> = S_LOAD_DWORD_IMM %vreg0, 32; mem:LD4[%678] SReg_32:%vreg344 SReg_64:%vreg0
>	%vreg345<def> = S_LOAD_DWORD_IMM %vreg0, 33; mem:LD4[%683] SReg_32:%vreg345 SReg_64:%vreg0
>	%vreg346<def> = S_LOAD_DWORD_IMM %vreg0, 34; mem:LD4[%688] SReg_32:%vreg346 SReg_64:%vreg0
>	%vreg347<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%713] SReg_128:%vreg347 SReg_64:%vreg2
>	%vreg348<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%710] SReg_256:%vreg348 SReg_64:%vreg1
>	%vreg349<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg342:sub0, %vreg348<kill>, %vreg347<kill>, %EXEC<imp-use>; VReg_128:%vreg349 VReg_64:%vreg342 SReg_256:%vreg348 SReg_128:%vreg347
>	%vreg351<def> = S_LOAD_DWORD_IMM %vreg0, 35; mem:LD4[%736] SReg_32:%vreg351 SReg_64:%vreg0
>	%vreg353<def> = COPY %vreg351<kill>; VReg_32:%vreg353 SReg_32:%vreg351
>	%vreg352<def> = V_MUL_F32_e32 %vreg349:sub3, %vreg353<kill>, %EXEC<imp-use>; VReg_32:%vreg352,%vreg353 VReg_128:%vreg349
>	%vreg354<def> = V_ADD_F32_e32 %vreg352<kill>, %vreg333<kill>, %EXEC<imp-use>; VReg_32:%vreg354,%vreg352,%vreg333
>	%vreg355<def> = S_LOAD_DWORD_IMM %vreg0, 101; mem:LD4[%746] SReg_32:%vreg355 SReg_64:%vreg0
>	%vreg357<def> = COPY %vreg355<kill>; VReg_32:%vreg357 SReg_32:%vreg355
>	%vreg363:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg357<kill>, %EXEC<imp-use>; VReg_64:%vreg363,%vreg8 VReg_32:%vreg357
>	%vreg358<def> = S_LOAD_DWORD_IMM %vreg0, 100; mem:LD4[%741] SReg_32:%vreg358 SReg_64:%vreg0
>	%vreg360<def> = COPY %vreg358<kill>; VReg_32:%vreg360 SReg_32:%vreg358
>	%vreg363:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg360<kill>, %EXEC<imp-use>; VReg_64:%vreg363,%vreg8 VReg_32:%vreg360
>	%vreg365<def> = S_LOAD_DWORD_IMM %vreg0, 32; mem:LD4[%721] SReg_32:%vreg365 SReg_64:%vreg0
>	%vreg366<def> = S_LOAD_DWORD_IMM %vreg0, 33; mem:LD4[%726] SReg_32:%vreg366 SReg_64:%vreg0
>	%vreg367<def> = S_LOAD_DWORD_IMM %vreg0, 34; mem:LD4[%731] SReg_32:%vreg367 SReg_64:%vreg0
>	%vreg368<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%758] SReg_128:%vreg368 SReg_64:%vreg2
>	%vreg369<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%755] SReg_256:%vreg369 SReg_64:%vreg1
>	%vreg370<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg363:sub0, %vreg369<kill>, %vreg368<kill>, %EXEC<imp-use>; VReg_128:%vreg370 VReg_64:%vreg363 SReg_256:%vreg369 SReg_128:%vreg368
>	%vreg372<def> = S_LOAD_DWORD_IMM %vreg0, 39; mem:LD4[%781] SReg_32:%vreg372 SReg_64:%vreg0
>	%vreg374<def> = COPY %vreg372<kill>; VReg_32:%vreg374 SReg_32:%vreg372
>	%vreg373<def> = V_MUL_F32_e32 %vreg370:sub3, %vreg374<kill>, %EXEC<imp-use>; VReg_32:%vreg373,%vreg374 VReg_128:%vreg370
>	%vreg375<def> = V_ADD_F32_e32 %vreg373<kill>, %vreg354<kill>, %EXEC<imp-use>; VReg_32:%vreg375,%vreg373,%vreg354
>	%vreg376<def> = S_LOAD_DWORD_IMM %vreg0, 101; mem:LD4[%790] SReg_32:%vreg376 SReg_64:%vreg0
>	%vreg378<def> = COPY %vreg376<kill>; VReg_32:%vreg378 SReg_32:%vreg376
>	%vreg384:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg378<kill>, %EXEC<imp-use>; VReg_64:%vreg384,%vreg8 VReg_32:%vreg378
>	%vreg379<def> = S_LOAD_DWORD_IMM %vreg0, 100; mem:LD4[%786] SReg_32:%vreg379 SReg_64:%vreg0
>	%vreg381<def> = COPY %vreg379<kill>; VReg_32:%vreg381 SReg_32:%vreg379
>	%vreg384:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg381<kill>, %EXEC<imp-use>; VReg_64:%vreg384,%vreg8 VReg_32:%vreg381
>	%vreg386<def> = S_LOAD_DWORD_IMM %vreg0, 36; mem:LD4[%766] SReg_32:%vreg386 SReg_64:%vreg0
>	%vreg387<def> = S_LOAD_DWORD_IMM %vreg0, 37; mem:LD4[%771] SReg_32:%vreg387 SReg_64:%vreg0
>	%vreg388<def> = S_LOAD_DWORD_IMM %vreg0, 38; mem:LD4[%776] SReg_32:%vreg388 SReg_64:%vreg0
>	%vreg389<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%801] SReg_128:%vreg389 SReg_64:%vreg2
>	%vreg390<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%798] SReg_256:%vreg390 SReg_64:%vreg1
>	%vreg391<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg384:sub0, %vreg390<kill>, %vreg389<kill>, %EXEC<imp-use>; VReg_128:%vreg391 VReg_64:%vreg384 SReg_256:%vreg390 SReg_128:%vreg389
>	%vreg393<def> = S_LOAD_DWORD_IMM %vreg0, 39; mem:LD4[%824] SReg_32:%vreg393 SReg_64:%vreg0
>	%vreg395<def> = COPY %vreg393<kill>; VReg_32:%vreg395 SReg_32:%vreg393
>	%vreg394<def> = V_MUL_F32_e32 %vreg391:sub3, %vreg395<kill>, %EXEC<imp-use>; VReg_32:%vreg394,%vreg395 VReg_128:%vreg391
>	%vreg396<def> = V_ADD_F32_e32 %vreg394<kill>, %vreg375<kill>, %EXEC<imp-use>; VReg_32:%vreg396,%vreg394,%vreg375
>	%vreg397<def> = S_LOAD_DWORD_IMM %vreg0, 105; mem:LD4[%834] SReg_32:%vreg397 SReg_64:%vreg0
>	%vreg399<def> = COPY %vreg397<kill>; VReg_32:%vreg399 SReg_32:%vreg397
>	%vreg405:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg399<kill>, %EXEC<imp-use>; VReg_64:%vreg405,%vreg8 VReg_32:%vreg399
>	%vreg400<def> = S_LOAD_DWORD_IMM %vreg0, 104; mem:LD4[%829] SReg_32:%vreg400 SReg_64:%vreg0
>	%vreg402<def> = COPY %vreg400<kill>; VReg_32:%vreg402 SReg_32:%vreg400
>	%vreg405:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg402<kill>, %EXEC<imp-use>; VReg_64:%vreg405,%vreg8 VReg_32:%vreg402
>	%vreg407<def> = S_LOAD_DWORD_IMM %vreg0, 36; mem:LD4[%809] SReg_32:%vreg407 SReg_64:%vreg0
>	%vreg408<def> = S_LOAD_DWORD_IMM %vreg0, 37; mem:LD4[%814] SReg_32:%vreg408 SReg_64:%vreg0
>	%vreg409<def> = S_LOAD_DWORD_IMM %vreg0, 38; mem:LD4[%819] SReg_32:%vreg409 SReg_64:%vreg0
>	%vreg410<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%846] SReg_128:%vreg410 SReg_64:%vreg2
>	%vreg411<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%843] SReg_256:%vreg411 SReg_64:%vreg1
>	%vreg412<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg405:sub0, %vreg411<kill>, %vreg410<kill>, %EXEC<imp-use>; VReg_128:%vreg412 VReg_64:%vreg405 SReg_256:%vreg411 SReg_128:%vreg410
>	%vreg414<def> = S_LOAD_DWORD_IMM %vreg0, 43; mem:LD4[%869] SReg_32:%vreg414 SReg_64:%vreg0
>	%vreg416<def> = COPY %vreg414<kill>; VReg_32:%vreg416 SReg_32:%vreg414
>	%vreg415<def> = V_MUL_F32_e32 %vreg412:sub3, %vreg416<kill>, %EXEC<imp-use>; VReg_32:%vreg415,%vreg416 VReg_128:%vreg412
>	%vreg417<def> = V_ADD_F32_e32 %vreg415<kill>, %vreg396<kill>, %EXEC<imp-use>; VReg_32:%vreg417,%vreg415,%vreg396
>	%vreg418<def> = S_LOAD_DWORD_IMM %vreg0, 105; mem:LD4[%878] SReg_32:%vreg418 SReg_64:%vreg0
>	%vreg420<def> = COPY %vreg418<kill>; VReg_32:%vreg420 SReg_32:%vreg418
>	%vreg426:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg420<kill>, %EXEC<imp-use>; VReg_64:%vreg426,%vreg8 VReg_32:%vreg420
>	%vreg421<def> = S_LOAD_DWORD_IMM %vreg0, 104; mem:LD4[%874] SReg_32:%vreg421 SReg_64:%vreg0
>	%vreg423<def> = COPY %vreg421<kill>; VReg_32:%vreg423 SReg_32:%vreg421
>	%vreg426:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg423<kill>, %EXEC<imp-use>; VReg_64:%vreg426,%vreg8 VReg_32:%vreg423
>	%vreg428<def> = S_LOAD_DWORD_IMM %vreg0, 40; mem:LD4[%854] SReg_32:%vreg428 SReg_64:%vreg0
>	%vreg429<def> = S_LOAD_DWORD_IMM %vreg0, 41; mem:LD4[%859] SReg_32:%vreg429 SReg_64:%vreg0
>	%vreg430<def> = S_LOAD_DWORD_IMM %vreg0, 42; mem:LD4[%864] SReg_32:%vreg430 SReg_64:%vreg0
>	%vreg431<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%889] SReg_128:%vreg431 SReg_64:%vreg2
>	%vreg432<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%886] SReg_256:%vreg432 SReg_64:%vreg1
>	%vreg433<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg426:sub0, %vreg432<kill>, %vreg431<kill>, %EXEC<imp-use>; VReg_128:%vreg433 VReg_64:%vreg426 SReg_256:%vreg432 SReg_128:%vreg431
>	%vreg435<def> = S_LOAD_DWORD_IMM %vreg0, 43; mem:LD4[%912] SReg_32:%vreg435 SReg_64:%vreg0
>	%vreg437<def> = COPY %vreg435<kill>; VReg_32:%vreg437 SReg_32:%vreg435
>	%vreg436<def> = V_MUL_F32_e32 %vreg433:sub3, %vreg437<kill>, %EXEC<imp-use>; VReg_32:%vreg436,%vreg437 VReg_128:%vreg433
>	%vreg438<def> = V_ADD_F32_e32 %vreg436<kill>, %vreg417<kill>, %EXEC<imp-use>; VReg_32:%vreg438,%vreg436,%vreg417
>	%vreg439<def> = S_LOAD_DWORD_IMM %vreg0, 109; mem:LD4[%922] SReg_32:%vreg439 SReg_64:%vreg0
>	%vreg441<def> = COPY %vreg439<kill>; VReg_32:%vreg441 SReg_32:%vreg439
>	%vreg447:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg441<kill>, %EXEC<imp-use>; VReg_64:%vreg447,%vreg8 VReg_32:%vreg441
>	%vreg442<def> = S_LOAD_DWORD_IMM %vreg0, 108; mem:LD4[%917] SReg_32:%vreg442 SReg_64:%vreg0
>	%vreg444<def> = COPY %vreg442<kill>; VReg_32:%vreg444 SReg_32:%vreg442
>	%vreg447:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg444<kill>, %EXEC<imp-use>; VReg_64:%vreg447,%vreg8 VReg_32:%vreg444
>	%vreg449<def> = S_LOAD_DWORD_IMM %vreg0, 40; mem:LD4[%897] SReg_32:%vreg449 SReg_64:%vreg0
>	%vreg450<def> = S_LOAD_DWORD_IMM %vreg0, 41; mem:LD4[%902] SReg_32:%vreg450 SReg_64:%vreg0
>	%vreg451<def> = S_LOAD_DWORD_IMM %vreg0, 42; mem:LD4[%907] SReg_32:%vreg451 SReg_64:%vreg0
>	%vreg452<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%934] SReg_128:%vreg452 SReg_64:%vreg2
>	%vreg453<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%931] SReg_256:%vreg453 SReg_64:%vreg1
>	%vreg454<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg447:sub0, %vreg453<kill>, %vreg452<kill>, %EXEC<imp-use>; VReg_128:%vreg454 VReg_64:%vreg447 SReg_256:%vreg453 SReg_128:%vreg452
>	%vreg456<def> = S_LOAD_DWORD_IMM %vreg0, 47; mem:LD4[%957] SReg_32:%vreg456 SReg_64:%vreg0
>	%vreg458<def> = COPY %vreg456<kill>; VReg_32:%vreg458 SReg_32:%vreg456
>	%vreg457<def> = V_MUL_F32_e32 %vreg454:sub3, %vreg458<kill>, %EXEC<imp-use>; VReg_32:%vreg457,%vreg458 VReg_128:%vreg454
>	%vreg459<def> = V_ADD_F32_e32 %vreg457<kill>, %vreg438<kill>, %EXEC<imp-use>; VReg_32:%vreg459,%vreg457,%vreg438
>	%vreg460<def> = S_LOAD_DWORD_IMM %vreg0, 109; mem:LD4[%966] SReg_32:%vreg460 SReg_64:%vreg0
>	%vreg462<def> = COPY %vreg460<kill>; VReg_32:%vreg462 SReg_32:%vreg460
>	%vreg468:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg462<kill>, %EXEC<imp-use>; VReg_64:%vreg468,%vreg8 VReg_32:%vreg462
>	%vreg463<def> = S_LOAD_DWORD_IMM %vreg0, 108; mem:LD4[%962] SReg_32:%vreg463 SReg_64:%vreg0
>	%vreg465<def> = COPY %vreg463<kill>; VReg_32:%vreg465 SReg_32:%vreg463
>	%vreg468:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg465<kill>, %EXEC<imp-use>; VReg_64:%vreg468,%vreg8 VReg_32:%vreg465
>	%vreg470<def> = S_LOAD_DWORD_IMM %vreg0, 44; mem:LD4[%942] SReg_32:%vreg470 SReg_64:%vreg0
>	%vreg471<def> = S_LOAD_DWORD_IMM %vreg0, 45; mem:LD4[%947] SReg_32:%vreg471 SReg_64:%vreg0
>	%vreg472<def> = S_LOAD_DWORD_IMM %vreg0, 46; mem:LD4[%952] SReg_32:%vreg472 SReg_64:%vreg0
>	%vreg473<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%977] SReg_128:%vreg473 SReg_64:%vreg2
>	%vreg474<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%974] SReg_256:%vreg474 SReg_64:%vreg1
>	%vreg475<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg468:sub0, %vreg474<kill>, %vreg473<kill>, %EXEC<imp-use>; VReg_128:%vreg475 VReg_64:%vreg468 SReg_256:%vreg474 SReg_128:%vreg473
>	%vreg477<def> = S_LOAD_DWORD_IMM %vreg0, 47; mem:LD4[%1000] SReg_32:%vreg477 SReg_64:%vreg0
>	%vreg479<def> = COPY %vreg477<kill>; VReg_32:%vreg479 SReg_32:%vreg477
>	%vreg478<def> = V_MUL_F32_e32 %vreg475:sub3, %vreg479<kill>, %EXEC<imp-use>; VReg_32:%vreg478,%vreg479 VReg_128:%vreg475
>	%vreg480<def> = V_ADD_F32_e32 %vreg478<kill>, %vreg459<kill>, %EXEC<imp-use>; VReg_32:%vreg480,%vreg478,%vreg459
>	%vreg481<def> = S_LOAD_DWORD_IMM %vreg0, 113; mem:LD4[%1010] SReg_32:%vreg481 SReg_64:%vreg0
>	%vreg483<def> = COPY %vreg481<kill>; VReg_32:%vreg483 SReg_32:%vreg481
>	%vreg489:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg483<kill>, %EXEC<imp-use>; VReg_64:%vreg489,%vreg8 VReg_32:%vreg483
>	%vreg484<def> = S_LOAD_DWORD_IMM %vreg0, 112; mem:LD4[%1005] SReg_32:%vreg484 SReg_64:%vreg0
>	%vreg486<def> = COPY %vreg484<kill>; VReg_32:%vreg486 SReg_32:%vreg484
>	%vreg489:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg486<kill>, %EXEC<imp-use>; VReg_64:%vreg489,%vreg8 VReg_32:%vreg486
>	%vreg491<def> = S_LOAD_DWORD_IMM %vreg0, 44; mem:LD4[%985] SReg_32:%vreg491 SReg_64:%vreg0
>	%vreg492<def> = S_LOAD_DWORD_IMM %vreg0, 45; mem:LD4[%990] SReg_32:%vreg492 SReg_64:%vreg0
>	%vreg493<def> = S_LOAD_DWORD_IMM %vreg0, 46; mem:LD4[%995] SReg_32:%vreg493 SReg_64:%vreg0
>	%vreg494<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%1022] SReg_128:%vreg494 SReg_64:%vreg2
>	%vreg495<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%1019] SReg_256:%vreg495 SReg_64:%vreg1
>	%vreg496<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg489:sub0, %vreg495<kill>, %vreg494<kill>, %EXEC<imp-use>; VReg_128:%vreg496 VReg_64:%vreg489 SReg_256:%vreg495 SReg_128:%vreg494
>	%vreg498<def> = S_LOAD_DWORD_IMM %vreg0, 51; mem:LD4[%1045] SReg_32:%vreg498 SReg_64:%vreg0
>	%vreg500<def> = COPY %vreg498<kill>; VReg_32:%vreg500 SReg_32:%vreg498
>	%vreg499<def> = V_MUL_F32_e32 %vreg496:sub3, %vreg500<kill>, %EXEC<imp-use>; VReg_32:%vreg499,%vreg500 VReg_128:%vreg496
>	%vreg501<def> = V_ADD_F32_e32 %vreg499<kill>, %vreg480<kill>, %EXEC<imp-use>; VReg_32:%vreg501,%vreg499,%vreg480
>	%vreg502<def> = S_LOAD_DWORD_IMM %vreg0, 113; mem:LD4[%1054] SReg_32:%vreg502 SReg_64:%vreg0
>	%vreg504<def> = COPY %vreg502<kill>; VReg_32:%vreg504 SReg_32:%vreg502
>	%vreg510:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg504<kill>, %EXEC<imp-use>; VReg_64:%vreg510,%vreg8 VReg_32:%vreg504
>	%vreg505<def> = S_LOAD_DWORD_IMM %vreg0, 112; mem:LD4[%1050] SReg_32:%vreg505 SReg_64:%vreg0
>	%vreg507<def> = COPY %vreg505<kill>; VReg_32:%vreg507 SReg_32:%vreg505
>	%vreg510:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg507<kill>, %EXEC<imp-use>; VReg_64:%vreg510,%vreg8 VReg_32:%vreg507
>	%vreg512<def> = S_LOAD_DWORD_IMM %vreg0, 48; mem:LD4[%1030] SReg_32:%vreg512 SReg_64:%vreg0
>	%vreg513<def> = S_LOAD_DWORD_IMM %vreg0, 49; mem:LD4[%1035] SReg_32:%vreg513 SReg_64:%vreg0
>	%vreg514<def> = S_LOAD_DWORD_IMM %vreg0, 50; mem:LD4[%1040] SReg_32:%vreg514 SReg_64:%vreg0
>	%vreg515<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%1065] SReg_128:%vreg515 SReg_64:%vreg2
>	%vreg516<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%1062] SReg_256:%vreg516 SReg_64:%vreg1
>	%vreg517<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg510:sub0, %vreg516<kill>, %vreg515<kill>, %EXEC<imp-use>; VReg_128:%vreg517 VReg_64:%vreg510 SReg_256:%vreg516 SReg_128:%vreg515
>	%vreg519<def> = S_LOAD_DWORD_IMM %vreg0, 51; mem:LD4[%1088] SReg_32:%vreg519 SReg_64:%vreg0
>	%vreg521<def> = COPY %vreg519<kill>; VReg_32:%vreg521 SReg_32:%vreg519
>	%vreg520<def> = V_MUL_F32_e32 %vreg517:sub3, %vreg521<kill>, %EXEC<imp-use>; VReg_32:%vreg520,%vreg521 VReg_128:%vreg517
>	%vreg522<def> = V_ADD_F32_e32 %vreg520<kill>, %vreg501<kill>, %EXEC<imp-use>; VReg_32:%vreg522,%vreg520,%vreg501
>	%vreg523<def> = S_LOAD_DWORD_IMM %vreg0, 117; mem:LD4[%1098] SReg_32:%vreg523 SReg_64:%vreg0
>	%vreg525<def> = COPY %vreg523<kill>; VReg_32:%vreg525 SReg_32:%vreg523
>	%vreg531:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg525<kill>, %EXEC<imp-use>; VReg_64:%vreg531,%vreg8 VReg_32:%vreg525
>	%vreg526<def> = S_LOAD_DWORD_IMM %vreg0, 116; mem:LD4[%1093] SReg_32:%vreg526 SReg_64:%vreg0
>	%vreg528<def> = COPY %vreg526<kill>; VReg_32:%vreg528 SReg_32:%vreg526
>	%vreg531:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg528<kill>, %EXEC<imp-use>; VReg_64:%vreg531,%vreg8 VReg_32:%vreg528
>	%vreg533<def> = S_LOAD_DWORD_IMM %vreg0, 48; mem:LD4[%1073] SReg_32:%vreg533 SReg_64:%vreg0
>	%vreg534<def> = S_LOAD_DWORD_IMM %vreg0, 49; mem:LD4[%1078] SReg_32:%vreg534 SReg_64:%vreg0
>	%vreg535<def> = S_LOAD_DWORD_IMM %vreg0, 50; mem:LD4[%1083] SReg_32:%vreg535 SReg_64:%vreg0
>	%vreg536<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%1110] SReg_128:%vreg536 SReg_64:%vreg2
>	%vreg537<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%1107] SReg_256:%vreg537 SReg_64:%vreg1
>	%vreg538<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg531:sub0, %vreg537<kill>, %vreg536<kill>, %EXEC<imp-use>; VReg_128:%vreg538 VReg_64:%vreg531 SReg_256:%vreg537 SReg_128:%vreg536
>	%vreg540<def> = S_LOAD_DWORD_IMM %vreg0, 55; mem:LD4[%1133] SReg_32:%vreg540 SReg_64:%vreg0
>	%vreg542<def> = COPY %vreg540<kill>; VReg_32:%vreg542 SReg_32:%vreg540
>	%vreg541<def> = V_MUL_F32_e32 %vreg538:sub3, %vreg542<kill>, %EXEC<imp-use>; VReg_32:%vreg541,%vreg542 VReg_128:%vreg538
>	%vreg543<def> = V_ADD_F32_e32 %vreg541<kill>, %vreg522<kill>, %EXEC<imp-use>; VReg_32:%vreg543,%vreg541,%vreg522
>	%vreg544<def> = S_LOAD_DWORD_IMM %vreg0, 117; mem:LD4[%1142] SReg_32:%vreg544 SReg_64:%vreg0
>	%vreg546<def> = COPY %vreg544<kill>; VReg_32:%vreg546 SReg_32:%vreg544
>	%vreg552:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg546<kill>, %EXEC<imp-use>; VReg_64:%vreg552,%vreg8 VReg_32:%vreg546
>	%vreg547<def> = S_LOAD_DWORD_IMM %vreg0, 116; mem:LD4[%1138] SReg_32:%vreg547 SReg_64:%vreg0
>	%vreg549<def> = COPY %vreg547<kill>; VReg_32:%vreg549 SReg_32:%vreg547
>	%vreg552:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg549<kill>, %EXEC<imp-use>; VReg_64:%vreg552,%vreg8 VReg_32:%vreg549
>	%vreg554<def> = S_LOAD_DWORD_IMM %vreg0, 52; mem:LD4[%1118] SReg_32:%vreg554 SReg_64:%vreg0
>	%vreg555<def> = S_LOAD_DWORD_IMM %vreg0, 53; mem:LD4[%1123] SReg_32:%vreg555 SReg_64:%vreg0
>	%vreg556<def> = S_LOAD_DWORD_IMM %vreg0, 54; mem:LD4[%1128] SReg_32:%vreg556 SReg_64:%vreg0
>	%vreg557<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%1153] SReg_128:%vreg557 SReg_64:%vreg2
>	%vreg558<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%1150] SReg_256:%vreg558 SReg_64:%vreg1
>	%vreg559<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg552:sub0, %vreg558<kill>, %vreg557<kill>, %EXEC<imp-use>; VReg_128:%vreg559 VReg_64:%vreg552 SReg_256:%vreg558 SReg_128:%vreg557
>	%vreg561<def> = S_LOAD_DWORD_IMM %vreg0, 55; mem:LD4[%1176] SReg_32:%vreg561 SReg_64:%vreg0
>	%vreg563<def> = COPY %vreg561<kill>; VReg_32:%vreg563 SReg_32:%vreg561
>	%vreg562<def> = V_MUL_F32_e32 %vreg559:sub3, %vreg563<kill>, %EXEC<imp-use>; VReg_32:%vreg562,%vreg563 VReg_128:%vreg559
>	%vreg564<def> = V_ADD_F32_e32 %vreg562<kill>, %vreg543<kill>, %EXEC<imp-use>; VReg_32:%vreg564,%vreg562,%vreg543
>	%vreg565<def> = S_LOAD_DWORD_IMM %vreg0, 121; mem:LD4[%1186] SReg_32:%vreg565 SReg_64:%vreg0
>	%vreg567<def> = COPY %vreg565<kill>; VReg_32:%vreg567 SReg_32:%vreg565
>	%vreg573:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg567<kill>, %EXEC<imp-use>; VReg_64:%vreg573,%vreg8 VReg_32:%vreg567
>	%vreg568<def> = S_LOAD_DWORD_IMM %vreg0, 120; mem:LD4[%1181] SReg_32:%vreg568 SReg_64:%vreg0
>	%vreg570<def> = COPY %vreg568<kill>; VReg_32:%vreg570 SReg_32:%vreg568
>	%vreg573:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg570<kill>, %EXEC<imp-use>; VReg_64:%vreg573,%vreg8 VReg_32:%vreg570
>	%vreg575<def> = S_LOAD_DWORD_IMM %vreg0, 52; mem:LD4[%1161] SReg_32:%vreg575 SReg_64:%vreg0
>	%vreg576<def> = S_LOAD_DWORD_IMM %vreg0, 53; mem:LD4[%1166] SReg_32:%vreg576 SReg_64:%vreg0
>	%vreg577<def> = S_LOAD_DWORD_IMM %vreg0, 54; mem:LD4[%1171] SReg_32:%vreg577 SReg_64:%vreg0
>	%vreg578<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%1198] SReg_128:%vreg578 SReg_64:%vreg2
>	%vreg579<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%1195] SReg_256:%vreg579 SReg_64:%vreg1
>	%vreg580<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg573:sub0, %vreg579<kill>, %vreg578<kill>, %EXEC<imp-use>; VReg_128:%vreg580 VReg_64:%vreg573 SReg_256:%vreg579 SReg_128:%vreg578
>	%vreg582<def> = S_LOAD_DWORD_IMM %vreg0, 59; mem:LD4[%1221] SReg_32:%vreg582 SReg_64:%vreg0
>	%vreg584<def> = COPY %vreg582<kill>; VReg_32:%vreg584 SReg_32:%vreg582
>	%vreg583<def> = V_MUL_F32_e32 %vreg580:sub3, %vreg584<kill>, %EXEC<imp-use>; VReg_32:%vreg583,%vreg584 VReg_128:%vreg580
>	%vreg585<def> = V_ADD_F32_e32 %vreg583<kill>, %vreg564<kill>, %EXEC<imp-use>; VReg_32:%vreg585,%vreg583,%vreg564
>	%vreg586<def> = S_LOAD_DWORD_IMM %vreg0, 121; mem:LD4[%1230] SReg_32:%vreg586 SReg_64:%vreg0
>	%vreg588<def> = COPY %vreg586<kill>; VReg_32:%vreg588 SReg_32:%vreg586
>	%vreg594:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg588<kill>, %EXEC<imp-use>; VReg_64:%vreg594,%vreg8 VReg_32:%vreg588
>	%vreg589<def> = S_LOAD_DWORD_IMM %vreg0, 120; mem:LD4[%1226] SReg_32:%vreg589 SReg_64:%vreg0
>	%vreg591<def> = COPY %vreg589<kill>; VReg_32:%vreg591 SReg_32:%vreg589
>	%vreg594:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg591<kill>, %EXEC<imp-use>; VReg_64:%vreg594,%vreg8 VReg_32:%vreg591
>	%vreg596<def> = S_LOAD_DWORD_IMM %vreg0, 56; mem:LD4[%1206] SReg_32:%vreg596 SReg_64:%vreg0
>	%vreg597<def> = S_LOAD_DWORD_IMM %vreg0, 57; mem:LD4[%1211] SReg_32:%vreg597 SReg_64:%vreg0
>	%vreg598<def> = S_LOAD_DWORD_IMM %vreg0, 58; mem:LD4[%1216] SReg_32:%vreg598 SReg_64:%vreg0
>	%vreg599<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%1241] SReg_128:%vreg599 SReg_64:%vreg2
>	%vreg600<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%1238] SReg_256:%vreg600 SReg_64:%vreg1
>	%vreg601<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg594:sub0, %vreg600<kill>, %vreg599<kill>, %EXEC<imp-use>; VReg_128:%vreg601 VReg_64:%vreg594 SReg_256:%vreg600 SReg_128:%vreg599
>	%vreg603<def> = S_LOAD_DWORD_IMM %vreg0, 59; mem:LD4[%1264] SReg_32:%vreg603 SReg_64:%vreg0
>	%vreg605<def> = COPY %vreg603<kill>; VReg_32:%vreg605 SReg_32:%vreg603
>	%vreg604<def> = V_MUL_F32_e32 %vreg601:sub3, %vreg605<kill>, %EXEC<imp-use>; VReg_32:%vreg604,%vreg605 VReg_128:%vreg601
>	%vreg606<def> = V_ADD_F32_e32 %vreg604<kill>, %vreg585<kill>, %EXEC<imp-use>; VReg_32:%vreg606,%vreg604,%vreg585
>	%vreg607<def> = S_LOAD_DWORD_IMM %vreg0, 125; mem:LD4[%1274] SReg_32:%vreg607 SReg_64:%vreg0
>	%vreg609<def> = COPY %vreg607<kill>; VReg_32:%vreg609 SReg_32:%vreg607
>	%vreg615:sub1<def,read-undef> = V_SUB_F32_e32 %vreg8:sub1, %vreg609<kill>, %EXEC<imp-use>; VReg_64:%vreg615,%vreg8 VReg_32:%vreg609
>	%vreg610<def> = S_LOAD_DWORD_IMM %vreg0, 124; mem:LD4[%1269] SReg_32:%vreg610 SReg_64:%vreg0
>	%vreg612<def> = COPY %vreg610<kill>; VReg_32:%vreg612 SReg_32:%vreg610
>	%vreg615:sub0<def> = V_SUB_F32_e32 %vreg8:sub0, %vreg612<kill>, %EXEC<imp-use>; VReg_64:%vreg615,%vreg8 VReg_32:%vreg612
>	%vreg617<def> = S_LOAD_DWORD_IMM %vreg0, 56; mem:LD4[%1249] SReg_32:%vreg617 SReg_64:%vreg0
>	%vreg618<def> = S_LOAD_DWORD_IMM %vreg0, 57; mem:LD4[%1254] SReg_32:%vreg618 SReg_64:%vreg0
>	%vreg619<def> = S_LOAD_DWORD_IMM %vreg0, 58; mem:LD4[%1259] SReg_32:%vreg619 SReg_64:%vreg0
>	%vreg620<def> = S_LOAD_DWORDX4_IMM %vreg2, 0; mem:LD16[%1286] SReg_128:%vreg620 SReg_64:%vreg2
>	%vreg621<def> = S_LOAD_DWORDX8_IMM %vreg1, 0; mem:LD32[%1283] SReg_256:%vreg621 SReg_64:%vreg1
>	%vreg622<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg615:sub0, %vreg621<kill>, %vreg620<kill>, %EXEC<imp-use>; VReg_128:%vreg622 VReg_64:%vreg615 SReg_256:%vreg621 SReg_128:%vreg620
>	%vreg624<def> = S_LOAD_DWORD_IMM %vreg0, 63; mem:LD4[%1309] SReg_32:%vreg624 SReg_64:%vreg0
>	%vreg626<def> = COPY %vreg624<kill>; VReg_32:%vreg626 SReg_32:%vreg624
>	%vreg625<def> = V_MUL_F32_e32 %vreg622:sub3, %vreg626<kill>, %EXEC<imp-use>; VReg_32:%vreg625,%vreg626 VReg_128:%vreg622
>	%vreg627<def> = V_ADD_F32_e32 %vreg625<kill>, %vreg606<kill>, %EXEC<imp-use>; VReg_32:%vreg627,%vreg625,%vreg606
>	%vreg628<def> = S_LOAD_DWORD_IMM %vreg0, 125; mem:LD4[%1318] SReg_32:%vreg628 SReg_64:%vreg0
>	%vreg630<def> = COPY %vreg628<kill>; VReg_32:%vreg630 SReg_32:%vreg628
>	%vreg636:sub1<def,read-undef> = V_ADD_F32_e32 %vreg8:sub1, %vreg630<kill>, %EXEC<imp-use>; VReg_64:%vreg636,%vreg8 VReg_32:%vreg630
>	%vreg631<def> = S_LOAD_DWORD_IMM %vreg0, 124; mem:LD4[%1314] SReg_32:%vreg631 SReg_64:%vreg0
>	%vreg633<def> = COPY %vreg631<kill>; VReg_32:%vreg633 SReg_32:%vreg631
>	%vreg636:sub0<def> = V_ADD_F32_e32 %vreg8:sub0, %vreg633<kill>, %EXEC<imp-use>; VReg_64:%vreg636,%vreg8 VReg_32:%vreg633
>	%vreg638<def> = S_LOAD_DWORD_IMM %vreg0, 60; mem:LD4[%1294] SReg_32:%vreg638 SReg_64:%vreg0
>	%vreg639<def> = S_LOAD_DWORD_IMM %vreg0, 61; mem:LD4[%1299] SReg_32:%vreg639 SReg_64:%vreg0
>	%vreg640<def> = S_LOAD_DWORD_IMM %vreg0, 62; mem:LD4[%1304] SReg_32:%vreg640 SReg_64:%vreg0
>	%vreg641<def> = S_LOAD_DWORDX4_IMM %vreg2<kill>, 0; mem:LD16[%1329] SReg_128:%vreg641 SReg_64:%vreg2
>	%vreg642<def> = S_LOAD_DWORDX8_IMM %vreg1<kill>, 0; mem:LD32[%1326] SReg_256:%vreg642 SReg_64:%vreg1
>	%vreg643<def> = IMAGE_SAMPLE 15, 0, 0, 0, 0, 0, 0, 0, %vreg636:sub0, %vreg642<kill>, %vreg641<kill>, %EXEC<imp-use>; VReg_128:%vreg643 VReg_64:%vreg636 SReg_256:%vreg642 SReg_128:%vreg641
>	%vreg645<def> = S_LOAD_DWORD_IMM %vreg0, 63; mem:LD4[%1352] SReg_32:%vreg645 SReg_64:%vreg0
>	%vreg647<def> = COPY %vreg645<kill>; VReg_32:%vreg647 SReg_32:%vreg645
>	%vreg646<def> = V_MUL_F32_e32 %vreg643:sub3, %vreg647<kill>, %EXEC<imp-use>; VReg_32:%vreg646,%vreg647 VReg_128:%vreg643
>	%vreg648<def> = V_ADD_F32_e32 %vreg646<kill>, %vreg627<kill>, %EXEC<imp-use>; VReg_32:%vreg648,%vreg646,%vreg627
>	%vreg649<def> = V_ADD_F32_e64 %vreg648<kill>, 128, 128, 0, 1, 0, 0, %EXEC<imp-use>; VReg_32:%vreg649,%vreg648
>	%vreg652<def> = COPY %vreg52<kill>; VReg_32:%vreg652 SReg_32:%vreg52
>	%vreg651<def> = V_MUL_F32_e32 %vreg31:sub2, %vreg652<kill>, %EXEC<imp-use>; VReg_32:%vreg651,%vreg652 VReg_128:%vreg31
>	%vreg655<def> = COPY %vreg27<kill>; VReg_32:%vreg655 SReg_32:%vreg27
>	%vreg654<def> = V_MUL_F32_e32 %vreg14:sub2, %vreg655<kill>, %EXEC<imp-use>; VReg_32:%vreg654,%vreg655 VReg_128:%vreg14
>	%vreg656<def> = V_ADD_F32_e32 %vreg651<kill>, %vreg654<kill>, %EXEC<imp-use>; VReg_32:%vreg656,%vreg651,%vreg654
>	%vreg659<def> = COPY %vreg73<kill>; VReg_32:%vreg659 SReg_32:%vreg73
>	%vreg658<def> = V_MUL_F32_e32 %vreg55:sub2, %vreg659<kill>, %EXEC<imp-use>; VReg_32:%vreg658,%vreg659 VReg_128:%vreg55
>	%vreg660<def> = V_ADD_F32_e32 %vreg658<kill>, %vreg656<kill>, %EXEC<imp-use>; VReg_32:%vreg660,%vreg658,%vreg656
>	%vreg663<def> = COPY %vreg94<kill>; VReg_32:%vreg663 SReg_32:%vreg94
>	%vreg662<def> = V_MUL_F32_e32 %vreg76:sub2, %vreg663<kill>, %EXEC<imp-use>; VReg_32:%vreg662,%vreg663 VReg_128:%vreg76
>	%vreg664<def> = V_ADD_F32_e32 %vreg662<kill>, %vreg660<kill>, %EXEC<imp-use>; VReg_32:%vreg664,%vreg662,%vreg660
>	%vreg667<def> = COPY %vreg115<kill>; VReg_32:%vreg667 SReg_32:%vreg115
>	%vreg666<def> = V_MUL_F32_e32 %vreg97:sub2, %vreg667<kill>, %EXEC<imp-use>; VReg_32:%vreg666,%vreg667 VReg_128:%vreg97
>	%vreg668<def> = V_ADD_F32_e32 %vreg666<kill>, %vreg664<kill>, %EXEC<imp-use>; VReg_32:%vreg668,%vreg666,%vreg664
>	%vreg671<def> = COPY %vreg136<kill>; VReg_32:%vreg671 SReg_32:%vreg136
>	%vreg670<def> = V_MUL_F32_e32 %vreg118:sub2, %vreg671<kill>, %EXEC<imp-use>; VReg_32:%vreg670,%vreg671 VReg_128:%vreg118
>	%vreg672<def> = V_ADD_F32_e32 %vreg670<kill>, %vreg668<kill>, %EXEC<imp-use>; VReg_32:%vreg672,%vreg670,%vreg668
>	%vreg675<def> = COPY %vreg157<kill>; VReg_32:%vreg675 SReg_32:%vreg157
>	%vreg674<def> = V_MUL_F32_e32 %vreg139:sub2, %vreg675<kill>, %EXEC<imp-use>; VReg_32:%vreg674,%vreg675 VReg_128:%vreg139
>	%vreg676<def> = V_ADD_F32_e32 %vreg674<kill>, %vreg672<kill>, %EXEC<imp-use>; VReg_32:%vreg676,%vreg674,%vreg672
>	%vreg679<def> = COPY %vreg178<kill>; VReg_32:%vreg679 SReg_32:%vreg178
>	%vreg678<def> = V_MUL_F32_e32 %vreg160:sub2, %vreg679<kill>, %EXEC<imp-use>; VReg_32:%vreg678,%vreg679 VReg_128:%vreg160
>	%vreg680<def> = V_ADD_F32_e32 %vreg678<kill>, %vreg676<kill>, %EXEC<imp-use>; VReg_32:%vreg680,%vreg678,%vreg676
>	%vreg683<def> = COPY %vreg199<kill>; VReg_32:%vreg683 SReg_32:%vreg199
>	%vreg682<def> = V_MUL_F32_e32 %vreg181:sub2, %vreg683<kill>, %EXEC<imp-use>; VReg_32:%vreg682,%vreg683 VReg_128:%vreg181
>	%vreg684<def> = V_ADD_F32_e32 %vreg682<kill>, %vreg680<kill>, %EXEC<imp-use>; VReg_32:%vreg684,%vreg682,%vreg680
>	%vreg687<def> = COPY %vreg220<kill>; VReg_32:%vreg687 SReg_32:%vreg220
>	%vreg686<def> = V_MUL_F32_e32 %vreg202:sub2, %vreg687<kill>, %EXEC<imp-use>; VReg_32:%vreg686,%vreg687 VReg_128:%vreg202
>	%vreg688<def> = V_ADD_F32_e32 %vreg686<kill>, %vreg684<kill>, %EXEC<imp-use>; VReg_32:%vreg688,%vreg686,%vreg684
>	%vreg691<def> = COPY %vreg241<kill>; VReg_32:%vreg691 SReg_32:%vreg241
>	%vreg690<def> = V_MUL_F32_e32 %vreg223:sub2, %vreg691<kill>, %EXEC<imp-use>; VReg_32:%vreg690,%vreg691 VReg_128:%vreg223
>	%vreg692<def> = V_ADD_F32_e32 %vreg690<kill>, %vreg688<kill>, %EXEC<imp-use>; VReg_32:%vreg692,%vreg690,%vreg688
>	%vreg695<def> = COPY %vreg262<kill>; VReg_32:%vreg695 SReg_32:%vreg262
>	%vreg694<def> = V_MUL_F32_e32 %vreg244:sub2, %vreg695<kill>, %EXEC<imp-use>; VReg_32:%vreg694,%vreg695 VReg_128:%vreg244
>	%vreg696<def> = V_ADD_F32_e32 %vreg694<kill>, %vreg692<kill>, %EXEC<imp-use>; VReg_32:%vreg696,%vreg694,%vreg692
>	%vreg699<def> = COPY %vreg283<kill>; VReg_32:%vreg699 SReg_32:%vreg283
>	%vreg698<def> = V_MUL_F32_e32 %vreg265:sub2, %vreg699<kill>, %EXEC<imp-use>; VReg_32:%vreg698,%vreg699 VReg_128:%vreg265
>	%vreg700<def> = V_ADD_F32_e32 %vreg698<kill>, %vreg696<kill>, %EXEC<imp-use>; VReg_32:%vreg700,%vreg698,%vreg696
>	%vreg703<def> = COPY %vreg304<kill>; VReg_32:%vreg703 SReg_32:%vreg304
>	%vreg702<def> = V_MUL_F32_e32 %vreg286:sub2, %vreg703<kill>, %EXEC<imp-use>; VReg_32:%vreg702,%vreg703 VReg_128:%vreg286
>	%vreg704<def> = V_ADD_F32_e32 %vreg702<kill>, %vreg700<kill>, %EXEC<imp-use>; VReg_32:%vreg704,%vreg702,%vreg700
>	%vreg707<def> = COPY %vreg325<kill>; VReg_32:%vreg707 SReg_32:%vreg325
>	%vreg706<def> = V_MUL_F32_e32 %vreg307:sub2, %vreg707<kill>, %EXEC<imp-use>; VReg_32:%vreg706,%vreg707 VReg_128:%vreg307
>	%vreg708<def> = V_ADD_F32_e32 %vreg706<kill>, %vreg704<kill>, %EXEC<imp-use>; VReg_32:%vreg708,%vreg706,%vreg704
>	%vreg711<def> = COPY %vreg346<kill>; VReg_32:%vreg711 SReg_32:%vreg346
>	%vreg710<def> = V_MUL_F32_e32 %vreg328:sub2, %vreg711<kill>, %EXEC<imp-use>; VReg_32:%vreg710,%vreg711 VReg_128:%vreg328
>	%vreg712<def> = V_ADD_F32_e32 %vreg710<kill>, %vreg708<kill>, %EXEC<imp-use>; VReg_32:%vreg712,%vreg710,%vreg708
>	%vreg715<def> = COPY %vreg367<kill>; VReg_32:%vreg715 SReg_32:%vreg367
>	%vreg714<def> = V_MUL_F32_e32 %vreg349:sub2, %vreg715<kill>, %EXEC<imp-use>; VReg_32:%vreg714,%vreg715 VReg_128:%vreg349
>	%vreg716<def> = V_ADD_F32_e32 %vreg714<kill>, %vreg712<kill>, %EXEC<imp-use>; VReg_32:%vreg716,%vreg714,%vreg712
>	%vreg719<def> = COPY %vreg388<kill>; VReg_32:%vreg719 SReg_32:%vreg388
>	%vreg718<def> = V_MUL_F32_e32 %vreg370:sub2, %vreg719<kill>, %EXEC<imp-use>; VReg_32:%vreg718,%vreg719 VReg_128:%vreg370
>	%vreg720<def> = V_ADD_F32_e32 %vreg718<kill>, %vreg716<kill>, %EXEC<imp-use>; VReg_32:%vreg720,%vreg718,%vreg716
>	%vreg723<def> = COPY %vreg409<kill>; VReg_32:%vreg723 SReg_32:%vreg409
>	%vreg722<def> = V_MUL_F32_e32 %vreg391:sub2, %vreg723<kill>, %EXEC<imp-use>; VReg_32:%vreg722,%vreg723 VReg_128:%vreg391
>	%vreg724<def> = V_ADD_F32_e32 %vreg722<kill>, %vreg720<kill>, %EXEC<imp-use>; VReg_32:%vreg724,%vreg722,%vreg720
>	%vreg727<def> = COPY %vreg430<kill>; VReg_32:%vreg727 SReg_32:%vreg430
>	%vreg726<def> = V_MUL_F32_e32 %vreg412:sub2, %vreg727<kill>, %EXEC<imp-use>; VReg_32:%vreg726,%vreg727 VReg_128:%vreg412
>	%vreg728<def> = V_ADD_F32_e32 %vreg726<kill>, %vreg724<kill>, %EXEC<imp-use>; VReg_32:%vreg728,%vreg726,%vreg724
>	%vreg731<def> = COPY %vreg451<kill>; VReg_32:%vreg731 SReg_32:%vreg451
>	%vreg730<def> = V_MUL_F32_e32 %vreg433:sub2, %vreg731<kill>, %EXEC<imp-use>; VReg_32:%vreg730,%vreg731 VReg_128:%vreg433
>	%vreg732<def> = V_ADD_F32_e32 %vreg730<kill>, %vreg728<kill>, %EXEC<imp-use>; VReg_32:%vreg732,%vreg730,%vreg728
>	%vreg735<def> = COPY %vreg472<kill>; VReg_32:%vreg735 SReg_32:%vreg472
>	%vreg734<def> = V_MUL_F32_e32 %vreg454:sub2, %vreg735<kill>, %EXEC<imp-use>; VReg_32:%vreg734,%vreg735 VReg_128:%vreg454
>	%vreg736<def> = V_ADD_F32_e32 %vreg734<kill>, %vreg732<kill>, %EXEC<imp-use>; VReg_32:%vreg736,%vreg734,%vreg732
>	%vreg739<def> = COPY %vreg493<kill>; VReg_32:%vreg739 SReg_32:%vreg493
>	%vreg738<def> = V_MUL_F32_e32 %vreg475:sub2, %vreg739<kill>, %EXEC<imp-use>; VReg_32:%vreg738,%vreg739 VReg_128:%vreg475
>	%vreg740<def> = V_ADD_F32_e32 %vreg738<kill>, %vreg736<kill>, %EXEC<imp-use>; VReg_32:%vreg740,%vreg738,%vreg736
>	%vreg743<def> = COPY %vreg514<kill>; VReg_32:%vreg743 SReg_32:%vreg514
>	%vreg742<def> = V_MUL_F32_e32 %vreg496:sub2, %vreg743<kill>, %EXEC<imp-use>; VReg_32:%vreg742,%vreg743 VReg_128:%vreg496
>	%vreg744<def> = V_ADD_F32_e32 %vreg742<kill>, %vreg740<kill>, %EXEC<imp-use>; VReg_32:%vreg744,%vreg742,%vreg740
>	%vreg747<def> = COPY %vreg535<kill>; VReg_32:%vreg747 SReg_32:%vreg535
>	%vreg746<def> = V_MUL_F32_e32 %vreg517:sub2, %vreg747<kill>, %EXEC<imp-use>; VReg_32:%vreg746,%vreg747 VReg_128:%vreg517
>	%vreg748<def> = V_ADD_F32_e32 %vreg746<kill>, %vreg744<kill>, %EXEC<imp-use>; VReg_32:%vreg748,%vreg746,%vreg744
>	%vreg751<def> = COPY %vreg556<kill>; VReg_32:%vreg751 SReg_32:%vreg556
>	%vreg750<def> = V_MUL_F32_e32 %vreg538:sub2, %vreg751<kill>, %EXEC<imp-use>; VReg_32:%vreg750,%vreg751 VReg_128:%vreg538
>	%vreg752<def> = V_ADD_F32_e32 %vreg750<kill>, %vreg748<kill>, %EXEC<imp-use>; VReg_32:%vreg752,%vreg750,%vreg748
>	%vreg755<def> = COPY %vreg577<kill>; VReg_32:%vreg755 SReg_32:%vreg577
>	%vreg754<def> = V_MUL_F32_e32 %vreg559:sub2, %vreg755<kill>, %EXEC<imp-use>; VReg_32:%vreg754,%vreg755 VReg_128:%vreg559
>	%vreg756<def> = V_ADD_F32_e32 %vreg754<kill>, %vreg752<kill>, %EXEC<imp-use>; VReg_32:%vreg756,%vreg754,%vreg752
>	%vreg759<def> = COPY %vreg598<kill>; VReg_32:%vreg759 SReg_32:%vreg598
>	%vreg758<def> = V_MUL_F32_e32 %vreg580:sub2, %vreg759<kill>, %EXEC<imp-use>; VReg_32:%vreg758,%vreg759 VReg_128:%vreg580
>	%vreg760<def> = V_ADD_F32_e32 %vreg758<kill>, %vreg756<kill>, %EXEC<imp-use>; VReg_32:%vreg760,%vreg758,%vreg756
>	%vreg763<def> = COPY %vreg619<kill>; VReg_32:%vreg763 SReg_32:%vreg619
>	%vreg762<def> = V_MUL_F32_e32 %vreg601:sub2, %vreg763<kill>, %EXEC<imp-use>; VReg_32:%vreg762,%vreg763 VReg_128:%vreg601
>	%vreg764<def> = V_ADD_F32_e32 %vreg762<kill>, %vreg760<kill>, %EXEC<imp-use>; VReg_32:%vreg764,%vreg762,%vreg760
>	%vreg767<def> = COPY %vreg640<kill>; VReg_32:%vreg767 SReg_32:%vreg640
>	%vreg766<def> = V_MUL_F32_e32 %vreg622:sub2, %vreg767<kill>, %EXEC<imp-use>; VReg_32:%vreg766,%vreg767 VReg_128:%vreg622
>	%vreg768<def> = V_ADD_F32_e32 %vreg766<kill>, %vreg764<kill>, %EXEC<imp-use>; VReg_32:%vreg768,%vreg766,%vreg764
>	%vreg770<def> = S_LOAD_DWORD_IMM %vreg0, 62; mem:LD4[%1347] SReg_32:%vreg770 SReg_64:%vreg0
>	%vreg772<def> = COPY %vreg770<kill>; VReg_32:%vreg772 SReg_32:%vreg770
>	%vreg771<def> = V_MUL_F32_e32 %vreg643:sub2, %vreg772<kill>, %EXEC<imp-use>; VReg_32:%vreg771,%vreg772 VReg_128:%vreg643
>	%vreg773<def> = V_ADD_F32_e32 %vreg771<kill>, %vreg768<kill>, %EXEC<imp-use>; VReg_32:%vreg773,%vreg771,%vreg768
>	%vreg774<def> = V_ADD_F32_e64 %vreg773<kill>, 128, 128, 0, 1, 0, 0, %EXEC<imp-use>; VReg_32:%vreg774,%vreg773
>	%vreg775<def> = V_CVT_PKRTZ_F16_F32_e32 %vreg774<kill>, %vreg649<kill>, %EXEC<imp-use>; VReg_32:%vreg775,%vreg774,%vreg649
>	%vreg778<def> = COPY %vreg51<kill>; VReg_32:%vreg778 SReg_32:%vreg51
>	%vreg777<def> = V_MUL_F32_e32 %vreg31:sub1, %vreg778<kill>, %EXEC<imp-use>; VReg_32:%vreg777,%vreg778 VReg_128:%vreg31
>	%vreg781<def> = COPY %vreg26<kill>; VReg_32:%vreg781 SReg_32:%vreg26
>	%vreg780<def> = V_MUL_F32_e32 %vreg14:sub1, %vreg781<kill>, %EXEC<imp-use>; VReg_32:%vreg780,%vreg781 VReg_128:%vreg14
>	%vreg782<def> = V_ADD_F32_e32 %vreg777<kill>, %vreg780<kill>, %EXEC<imp-use>; VReg_32:%vreg782,%vreg777,%vreg780
>	%vreg785<def> = COPY %vreg72<kill>; VReg_32:%vreg785 SReg_32:%vreg72
>	%vreg784<def> = V_MUL_F32_e32 %vreg55:sub1, %vreg785<kill>, %EXEC<imp-use>; VReg_32:%vreg784,%vreg785 VReg_128:%vreg55
>	%vreg786<def> = V_ADD_F32_e32 %vreg784<kill>, %vreg782<kill>, %EXEC<imp-use>; VReg_32:%vreg786,%vreg784,%vreg782
>	%vreg789<def> = COPY %vreg93<kill>; VReg_32:%vreg789 SReg_32:%vreg93
>	%vreg788<def> = V_MUL_F32_e32 %vreg76:sub1, %vreg789<kill>, %EXEC<imp-use>; VReg_32:%vreg788,%vreg789 VReg_128:%vreg76
>	%vreg790<def> = V_ADD_F32_e32 %vreg788<kill>, %vreg786<kill>, %EXEC<imp-use>; VReg_32:%vreg790,%vreg788,%vreg786
>	%vreg793<def> = COPY %vreg114<kill>; VReg_32:%vreg793 SReg_32:%vreg114
>	%vreg792<def> = V_MUL_F32_e32 %vreg97:sub1, %vreg793<kill>, %EXEC<imp-use>; VReg_32:%vreg792,%vreg793 VReg_128:%vreg97
>	%vreg794<def> = V_ADD_F32_e32 %vreg792<kill>, %vreg790<kill>, %EXEC<imp-use>; VReg_32:%vreg794,%vreg792,%vreg790
>	%vreg797<def> = COPY %vreg135<kill>; VReg_32:%vreg797 SReg_32:%vreg135
>	%vreg796<def> = V_MUL_F32_e32 %vreg118:sub1, %vreg797<kill>, %EXEC<imp-use>; VReg_32:%vreg796,%vreg797 VReg_128:%vreg118
>	%vreg798<def> = V_ADD_F32_e32 %vreg796<kill>, %vreg794<kill>, %EXEC<imp-use>; VReg_32:%vreg798,%vreg796,%vreg794
>	%vreg801<def> = COPY %vreg156<kill>; VReg_32:%vreg801 SReg_32:%vreg156
>	%vreg800<def> = V_MUL_F32_e32 %vreg139:sub1, %vreg801<kill>, %EXEC<imp-use>; VReg_32:%vreg800,%vreg801 VReg_128:%vreg139
>	%vreg802<def> = V_ADD_F32_e32 %vreg800<kill>, %vreg798<kill>, %EXEC<imp-use>; VReg_32:%vreg802,%vreg800,%vreg798
>	%vreg805<def> = COPY %vreg177<kill>; VReg_32:%vreg805 SReg_32:%vreg177
>	%vreg804<def> = V_MUL_F32_e32 %vreg160:sub1, %vreg805<kill>, %EXEC<imp-use>; VReg_32:%vreg804,%vreg805 VReg_128:%vreg160
>	%vreg806<def> = V_ADD_F32_e32 %vreg804<kill>, %vreg802<kill>, %EXEC<imp-use>; VReg_32:%vreg806,%vreg804,%vreg802
>	%vreg809<def> = COPY %vreg198<kill>; VReg_32:%vreg809 SReg_32:%vreg198
>	%vreg808<def> = V_MUL_F32_e32 %vreg181:sub1, %vreg809<kill>, %EXEC<imp-use>; VReg_32:%vreg808,%vreg809 VReg_128:%vreg181
>	%vreg810<def> = V_ADD_F32_e32 %vreg808<kill>, %vreg806<kill>, %EXEC<imp-use>; VReg_32:%vreg810,%vreg808,%vreg806
>	%vreg813<def> = COPY %vreg219<kill>; VReg_32:%vreg813 SReg_32:%vreg219
>	%vreg812<def> = V_MUL_F32_e32 %vreg202:sub1, %vreg813<kill>, %EXEC<imp-use>; VReg_32:%vreg812,%vreg813 VReg_128:%vreg202
>	%vreg814<def> = V_ADD_F32_e32 %vreg812<kill>, %vreg810<kill>, %EXEC<imp-use>; VReg_32:%vreg814,%vreg812,%vreg810
>	%vreg817<def> = COPY %vreg240<kill>; VReg_32:%vreg817 SReg_32:%vreg240
>	%vreg816<def> = V_MUL_F32_e32 %vreg223:sub1, %vreg817<kill>, %EXEC<imp-use>; VReg_32:%vreg816,%vreg817 VReg_128:%vreg223
>	%vreg818<def> = V_ADD_F32_e32 %vreg816<kill>, %vreg814<kill>, %EXEC<imp-use>; VReg_32:%vreg818,%vreg816,%vreg814
>	%vreg821<def> = COPY %vreg261<kill>; VReg_32:%vreg821 SReg_32:%vreg261
>	%vreg820<def> = V_MUL_F32_e32 %vreg244:sub1, %vreg821<kill>, %EXEC<imp-use>; VReg_32:%vreg820,%vreg821 VReg_128:%vreg244
>	%vreg822<def> = V_ADD_F32_e32 %vreg820<kill>, %vreg818<kill>, %EXEC<imp-use>; VReg_32:%vreg822,%vreg820,%vreg818
>	%vreg825<def> = COPY %vreg282<kill>; VReg_32:%vreg825 SReg_32:%vreg282
>	%vreg824<def> = V_MUL_F32_e32 %vreg265:sub1, %vreg825<kill>, %EXEC<imp-use>; VReg_32:%vreg824,%vreg825 VReg_128:%vreg265
>	%vreg826<def> = V_ADD_F32_e32 %vreg824<kill>, %vreg822<kill>, %EXEC<imp-use>; VReg_32:%vreg826,%vreg824,%vreg822
>	%vreg829<def> = COPY %vreg303<kill>; VReg_32:%vreg829 SReg_32:%vreg303
>	%vreg828<def> = V_MUL_F32_e32 %vreg286:sub1, %vreg829<kill>, %EXEC<imp-use>; VReg_32:%vreg828,%vreg829 VReg_128:%vreg286
>	%vreg830<def> = V_ADD_F32_e32 %vreg828<kill>, %vreg826<kill>, %EXEC<imp-use>; VReg_32:%vreg830,%vreg828,%vreg826
>	%vreg833<def> = COPY %vreg324<kill>; VReg_32:%vreg833 SReg_32:%vreg324
>	%vreg832<def> = V_MUL_F32_e32 %vreg307:sub1, %vreg833<kill>, %EXEC<imp-use>; VReg_32:%vreg832,%vreg833 VReg_128:%vreg307
>	%vreg834<def> = V_ADD_F32_e32 %vreg832<kill>, %vreg830<kill>, %EXEC<imp-use>; VReg_32:%vreg834,%vreg832,%vreg830
>	%vreg837<def> = COPY %vreg345<kill>; VReg_32:%vreg837 SReg_32:%vreg345
>	%vreg836<def> = V_MUL_F32_e32 %vreg328:sub1, %vreg837<kill>, %EXEC<imp-use>; VReg_32:%vreg836,%vreg837 VReg_128:%vreg328
>	%vreg838<def> = V_ADD_F32_e32 %vreg836<kill>, %vreg834<kill>, %EXEC<imp-use>; VReg_32:%vreg838,%vreg836,%vreg834
>	%vreg841<def> = COPY %vreg366<kill>; VReg_32:%vreg841 SReg_32:%vreg366
>	%vreg840<def> = V_MUL_F32_e32 %vreg349:sub1, %vreg841<kill>, %EXEC<imp-use>; VReg_32:%vreg840,%vreg841 VReg_128:%vreg349
>	%vreg842<def> = V_ADD_F32_e32 %vreg840<kill>, %vreg838<kill>, %EXEC<imp-use>; VReg_32:%vreg842,%vreg840,%vreg838
>	%vreg845<def> = COPY %vreg387<kill>; VReg_32:%vreg845 SReg_32:%vreg387
>	%vreg844<def> = V_MUL_F32_e32 %vreg370:sub1, %vreg845<kill>, %EXEC<imp-use>; VReg_32:%vreg844,%vreg845 VReg_128:%vreg370
>	%vreg846<def> = V_ADD_F32_e32 %vreg844<kill>, %vreg842<kill>, %EXEC<imp-use>; VReg_32:%vreg846,%vreg844,%vreg842
>	%vreg849<def> = COPY %vreg408<kill>; VReg_32:%vreg849 SReg_32:%vreg408
>	%vreg848<def> = V_MUL_F32_e32 %vreg391:sub1, %vreg849<kill>, %EXEC<imp-use>; VReg_32:%vreg848,%vreg849 VReg_128:%vreg391
>	%vreg850<def> = V_ADD_F32_e32 %vreg848<kill>, %vreg846<kill>, %EXEC<imp-use>; VReg_32:%vreg850,%vreg848,%vreg846
>	%vreg853<def> = COPY %vreg429<kill>; VReg_32:%vreg853 SReg_32:%vreg429
>	%vreg852<def> = V_MUL_F32_e32 %vreg412:sub1, %vreg853<kill>, %EXEC<imp-use>; VReg_32:%vreg852,%vreg853 VReg_128:%vreg412
>	%vreg854<def> = V_ADD_F32_e32 %vreg852<kill>, %vreg850<kill>, %EXEC<imp-use>; VReg_32:%vreg854,%vreg852,%vreg850
>	%vreg857<def> = COPY %vreg450<kill>; VReg_32:%vreg857 SReg_32:%vreg450
>	%vreg856<def> = V_MUL_F32_e32 %vreg433:sub1, %vreg857<kill>, %EXEC<imp-use>; VReg_32:%vreg856,%vreg857 VReg_128:%vreg433
>	%vreg858<def> = V_ADD_F32_e32 %vreg856<kill>, %vreg854<kill>, %EXEC<imp-use>; VReg_32:%vreg858,%vreg856,%vreg854
>	%vreg861<def> = COPY %vreg471<kill>; VReg_32:%vreg861 SReg_32:%vreg471
>	%vreg860<def> = V_MUL_F32_e32 %vreg454:sub1, %vreg861<kill>, %EXEC<imp-use>; VReg_32:%vreg860,%vreg861 VReg_128:%vreg454
>	%vreg862<def> = V_ADD_F32_e32 %vreg860<kill>, %vreg858<kill>, %EXEC<imp-use>; VReg_32:%vreg862,%vreg860,%vreg858
>	%vreg865<def> = COPY %vreg492<kill>; VReg_32:%vreg865 SReg_32:%vreg492
>	%vreg864<def> = V_MUL_F32_e32 %vreg475:sub1, %vreg865<kill>, %EXEC<imp-use>; VReg_32:%vreg864,%vreg865 VReg_128:%vreg475
>	%vreg866<def> = V_ADD_F32_e32 %vreg864<kill>, %vreg862<kill>, %EXEC<imp-use>; VReg_32:%vreg866,%vreg864,%vreg862
>	%vreg869<def> = COPY %vreg513<kill>; VReg_32:%vreg869 SReg_32:%vreg513
>	%vreg868<def> = V_MUL_F32_e32 %vreg496:sub1, %vreg869<kill>, %EXEC<imp-use>; VReg_32:%vreg868,%vreg869 VReg_128:%vreg496
>	%vreg870<def> = V_ADD_F32_e32 %vreg868<kill>, %vreg866<kill>, %EXEC<imp-use>; VReg_32:%vreg870,%vreg868,%vreg866
>	%vreg873<def> = COPY %vreg534<kill>; VReg_32:%vreg873 SReg_32:%vreg534
>	%vreg872<def> = V_MUL_F32_e32 %vreg517:sub1, %vreg873<kill>, %EXEC<imp-use>; VReg_32:%vreg872,%vreg873 VReg_128:%vreg517
>	%vreg874<def> = V_ADD_F32_e32 %vreg872<kill>, %vreg870<kill>, %EXEC<imp-use>; VReg_32:%vreg874,%vreg872,%vreg870
>	%vreg877<def> = COPY %vreg555<kill>; VReg_32:%vreg877 SReg_32:%vreg555
>	%vreg876<def> = V_MUL_F32_e32 %vreg538:sub1, %vreg877<kill>, %EXEC<imp-use>; VReg_32:%vreg876,%vreg877 VReg_128:%vreg538
>	%vreg878<def> = V_ADD_F32_e32 %vreg876<kill>, %vreg874<kill>, %EXEC<imp-use>; VReg_32:%vreg878,%vreg876,%vreg874
>	%vreg881<def> = COPY %vreg576<kill>; VReg_32:%vreg881 SReg_32:%vreg576
>	%vreg880<def> = V_MUL_F32_e32 %vreg559:sub1, %vreg881<kill>, %EXEC<imp-use>; VReg_32:%vreg880,%vreg881 VReg_128:%vreg559
>	%vreg882<def> = V_ADD_F32_e32 %vreg880<kill>, %vreg878<kill>, %EXEC<imp-use>; VReg_32:%vreg882,%vreg880,%vreg878
>	%vreg885<def> = COPY %vreg597<kill>; VReg_32:%vreg885 SReg_32:%vreg597
>	%vreg884<def> = V_MUL_F32_e32 %vreg580:sub1, %vreg885<kill>, %EXEC<imp-use>; VReg_32:%vreg884,%vreg885 VReg_128:%vreg580
>	%vreg886<def> = V_ADD_F32_e32 %vreg884<kill>, %vreg882<kill>, %EXEC<imp-use>; VReg_32:%vreg886,%vreg884,%vreg882
>	%vreg889<def> = COPY %vreg618<kill>; VReg_32:%vreg889 SReg_32:%vreg618
>	%vreg888<def> = V_MUL_F32_e32 %vreg601:sub1, %vreg889<kill>, %EXEC<imp-use>; VReg_32:%vreg888,%vreg889 VReg_128:%vreg601
>	%vreg890<def> = V_ADD_F32_e32 %vreg888<kill>, %vreg886<kill>, %EXEC<imp-use>; VReg_32:%vreg890,%vreg888,%vreg886
>	%vreg893<def> = COPY %vreg639<kill>; VReg_32:%vreg893 SReg_32:%vreg639
>	%vreg892<def> = V_MUL_F32_e32 %vreg622:sub1, %vreg893<kill>, %EXEC<imp-use>; VReg_32:%vreg892,%vreg893 VReg_128:%vreg622
>	%vreg894<def> = V_ADD_F32_e32 %vreg892<kill>, %vreg890<kill>, %EXEC<imp-use>; VReg_32:%vreg894,%vreg892,%vreg890
>	%vreg896<def> = S_LOAD_DWORD_IMM %vreg0, 61; mem:LD4[%1342] SReg_32:%vreg896 SReg_64:%vreg0
>	%vreg898<def> = COPY %vreg896<kill>; VReg_32:%vreg898 SReg_32:%vreg896
>	%vreg897<def> = V_MUL_F32_e32 %vreg643:sub1, %vreg898<kill>, %EXEC<imp-use>; VReg_32:%vreg897,%vreg898 VReg_128:%vreg643
>	%vreg899<def> = V_ADD_F32_e32 %vreg897<kill>, %vreg894<kill>, %EXEC<imp-use>; VReg_32:%vreg899,%vreg897,%vreg894
>	%vreg900<def> = V_ADD_F32_e64 %vreg899<kill>, 128, 128, 0, 1, 0, 0, %EXEC<imp-use>; VReg_32:%vreg900,%vreg899
>	%vreg903<def> = COPY %vreg50<kill>; VReg_32:%vreg903 SReg_32:%vreg50
>	%vreg902<def> = V_MUL_F32_e32 %vreg31:sub0, %vreg903<kill>, %EXEC<imp-use>; VReg_32:%vreg902,%vreg903 VReg_128:%vreg31
>	%vreg906<def> = COPY %vreg25<kill>; VReg_32:%vreg906 SReg_32:%vreg25
>	%vreg905<def> = V_MUL_F32_e32 %vreg14:sub0, %vreg906<kill>, %EXEC<imp-use>; VReg_32:%vreg905,%vreg906 VReg_128:%vreg14
>	%vreg907<def> = V_ADD_F32_e32 %vreg902<kill>, %vreg905<kill>, %EXEC<imp-use>; VReg_32:%vreg907,%vreg902,%vreg905
>	%vreg910<def> = COPY %vreg71<kill>; VReg_32:%vreg910 SReg_32:%vreg71
>	%vreg909<def> = V_MUL_F32_e32 %vreg55:sub0, %vreg910<kill>, %EXEC<imp-use>; VReg_32:%vreg909,%vreg910 VReg_128:%vreg55
>	%vreg911<def> = V_ADD_F32_e32 %vreg909<kill>, %vreg907<kill>, %EXEC<imp-use>; VReg_32:%vreg911,%vreg909,%vreg907
>	%vreg914<def> = COPY %vreg92<kill>; VReg_32:%vreg914 SReg_32:%vreg92
>	%vreg913<def> = V_MUL_F32_e32 %vreg76:sub0, %vreg914<kill>, %EXEC<imp-use>; VReg_32:%vreg913,%vreg914 VReg_128:%vreg76
>	%vreg915<def> = V_ADD_F32_e32 %vreg913<kill>, %vreg911<kill>, %EXEC<imp-use>; VReg_32:%vreg915,%vreg913,%vreg911
>	%vreg918<def> = COPY %vreg113<kill>; VReg_32:%vreg918 SReg_32:%vreg113
>	%vreg917<def> = V_MUL_F32_e32 %vreg97:sub0, %vreg918<kill>, %EXEC<imp-use>; VReg_32:%vreg917,%vreg918 VReg_128:%vreg97
>	%vreg919<def> = V_ADD_F32_e32 %vreg917<kill>, %vreg915<kill>, %EXEC<imp-use>; VReg_32:%vreg919,%vreg917,%vreg915
>	%vreg922<def> = COPY %vreg134<kill>; VReg_32:%vreg922 SReg_32:%vreg134
>	%vreg921<def> = V_MUL_F32_e32 %vreg118:sub0, %vreg922<kill>, %EXEC<imp-use>; VReg_32:%vreg921,%vreg922 VReg_128:%vreg118
>	%vreg923<def> = V_ADD_F32_e32 %vreg921<kill>, %vreg919<kill>, %EXEC<imp-use>; VReg_32:%vreg923,%vreg921,%vreg919
>	%vreg926<def> = COPY %vreg155<kill>; VReg_32:%vreg926 SReg_32:%vreg155
>	%vreg925<def> = V_MUL_F32_e32 %vreg139:sub0, %vreg926<kill>, %EXEC<imp-use>; VReg_32:%vreg925,%vreg926 VReg_128:%vreg139
>	%vreg927<def> = V_ADD_F32_e32 %vreg925<kill>, %vreg923<kill>, %EXEC<imp-use>; VReg_32:%vreg927,%vreg925,%vreg923
>	%vreg930<def> = COPY %vreg176<kill>; VReg_32:%vreg930 SReg_32:%vreg176
>	%vreg929<def> = V_MUL_F32_e32 %vreg160:sub0, %vreg930<kill>, %EXEC<imp-use>; VReg_32:%vreg929,%vreg930 VReg_128:%vreg160
>	%vreg931<def> = V_ADD_F32_e32 %vreg929<kill>, %vreg927<kill>, %EXEC<imp-use>; VReg_32:%vreg931,%vreg929,%vreg927
>	%vreg934<def> = COPY %vreg197<kill>; VReg_32:%vreg934 SReg_32:%vreg197
>	%vreg933<def> = V_MUL_F32_e32 %vreg181:sub0, %vreg934<kill>, %EXEC<imp-use>; VReg_32:%vreg933,%vreg934 VReg_128:%vreg181
>	%vreg935<def> = V_ADD_F32_e32 %vreg933<kill>, %vreg931<kill>, %EXEC<imp-use>; VReg_32:%vreg935,%vreg933,%vreg931
>	%vreg938<def> = COPY %vreg218<kill>; VReg_32:%vreg938 SReg_32:%vreg218
>	%vreg937<def> = V_MUL_F32_e32 %vreg202:sub0, %vreg938<kill>, %EXEC<imp-use>; VReg_32:%vreg937,%vreg938 VReg_128:%vreg202
>	%vreg939<def> = V_ADD_F32_e32 %vreg937<kill>, %vreg935<kill>, %EXEC<imp-use>; VReg_32:%vreg939,%vreg937,%vreg935
>	%vreg942<def> = COPY %vreg239<kill>; VReg_32:%vreg942 SReg_32:%vreg239
>	%vreg941<def> = V_MUL_F32_e32 %vreg223:sub0, %vreg942<kill>, %EXEC<imp-use>; VReg_32:%vreg941,%vreg942 VReg_128:%vreg223
>	%vreg943<def> = V_ADD_F32_e32 %vreg941<kill>, %vreg939<kill>, %EXEC<imp-use>; VReg_32:%vreg943,%vreg941,%vreg939
>	%vreg946<def> = COPY %vreg260<kill>; VReg_32:%vreg946 SReg_32:%vreg260
>	%vreg945<def> = V_MUL_F32_e32 %vreg244:sub0, %vreg946<kill>, %EXEC<imp-use>; VReg_32:%vreg945,%vreg946 VReg_128:%vreg244
>	%vreg947<def> = V_ADD_F32_e32 %vreg945<kill>, %vreg943<kill>, %EXEC<imp-use>; VReg_32:%vreg947,%vreg945,%vreg943
>	%vreg950<def> = COPY %vreg281<kill>; VReg_32:%vreg950 SReg_32:%vreg281
>	%vreg949<def> = V_MUL_F32_e32 %vreg265:sub0, %vreg950<kill>, %EXEC<imp-use>; VReg_32:%vreg949,%vreg950 VReg_128:%vreg265
>	%vreg951<def> = V_ADD_F32_e32 %vreg949<kill>, %vreg947<kill>, %EXEC<imp-use>; VReg_32:%vreg951,%vreg949,%vreg947
>	%vreg954<def> = COPY %vreg302<kill>; VReg_32:%vreg954 SReg_32:%vreg302
>	%vreg953<def> = V_MUL_F32_e32 %vreg286:sub0, %vreg954<kill>, %EXEC<imp-use>; VReg_32:%vreg953,%vreg954 VReg_128:%vreg286
>	%vreg955<def> = V_ADD_F32_e32 %vreg953<kill>, %vreg951<kill>, %EXEC<imp-use>; VReg_32:%vreg955,%vreg953,%vreg951
>	%vreg958<def> = COPY %vreg323<kill>; VReg_32:%vreg958 SReg_32:%vreg323
>	%vreg957<def> = V_MUL_F32_e32 %vreg307:sub0, %vreg958<kill>, %EXEC<imp-use>; VReg_32:%vreg957,%vreg958 VReg_128:%vreg307
>	%vreg959<def> = V_ADD_F32_e32 %vreg957<kill>, %vreg955<kill>, %EXEC<imp-use>; VReg_32:%vreg959,%vreg957,%vreg955
>	%vreg962<def> = COPY %vreg344<kill>; VReg_32:%vreg962 SReg_32:%vreg344
>	%vreg961<def> = V_MUL_F32_e32 %vreg328:sub0, %vreg962<kill>, %EXEC<imp-use>; VReg_32:%vreg961,%vreg962 VReg_128:%vreg328
>	%vreg963<def> = V_ADD_F32_e32 %vreg961<kill>, %vreg959<kill>, %EXEC<imp-use>; VReg_32:%vreg963,%vreg961,%vreg959
>	%vreg966<def> = COPY %vreg365<kill>; VReg_32:%vreg966 SReg_32:%vreg365
>	%vreg965<def> = V_MUL_F32_e32 %vreg349:sub0, %vreg966<kill>, %EXEC<imp-use>; VReg_32:%vreg965,%vreg966 VReg_128:%vreg349
>	%vreg967<def> = V_ADD_F32_e32 %vreg965<kill>, %vreg963<kill>, %EXEC<imp-use>; VReg_32:%vreg967,%vreg965,%vreg963
>	%vreg970<def> = COPY %vreg386<kill>; VReg_32:%vreg970 SReg_32:%vreg386
>	%vreg969<def> = V_MUL_F32_e32 %vreg370:sub0, %vreg970<kill>, %EXEC<imp-use>; VReg_32:%vreg969,%vreg970 VReg_128:%vreg370
>	%vreg971<def> = V_ADD_F32_e32 %vreg969<kill>, %vreg967<kill>, %EXEC<imp-use>; VReg_32:%vreg971,%vreg969,%vreg967
>	%vreg974<def> = COPY %vreg407<kill>; VReg_32:%vreg974 SReg_32:%vreg407
>	%vreg973<def> = V_MUL_F32_e32 %vreg391:sub0, %vreg974<kill>, %EXEC<imp-use>; VReg_32:%vreg973,%vreg974 VReg_128:%vreg391
>	%vreg975<def> = V_ADD_F32_e32 %vreg973<kill>, %vreg971<kill>, %EXEC<imp-use>; VReg_32:%vreg975,%vreg973,%vreg971
>	%vreg978<def> = COPY %vreg428<kill>; VReg_32:%vreg978 SReg_32:%vreg428
>	%vreg977<def> = V_MUL_F32_e32 %vreg412:sub0, %vreg978<kill>, %EXEC<imp-use>; VReg_32:%vreg977,%vreg978 VReg_128:%vreg412
>	%vreg979<def> = V_ADD_F32_e32 %vreg977<kill>, %vreg975<kill>, %EXEC<imp-use>; VReg_32:%vreg979,%vreg977,%vreg975
>	%vreg982<def> = COPY %vreg449<kill>; VReg_32:%vreg982 SReg_32:%vreg449
>	%vreg981<def> = V_MUL_F32_e32 %vreg433:sub0, %vreg982<kill>, %EXEC<imp-use>; VReg_32:%vreg981,%vreg982 VReg_128:%vreg433
>	%vreg983<def> = V_ADD_F32_e32 %vreg981<kill>, %vreg979<kill>, %EXEC<imp-use>; VReg_32:%vreg983,%vreg981,%vreg979
>	%vreg986<def> = COPY %vreg470<kill>; VReg_32:%vreg986 SReg_32:%vreg470
>	%vreg985<def> = V_MUL_F32_e32 %vreg454:sub0, %vreg986<kill>, %EXEC<imp-use>; VReg_32:%vreg985,%vreg986 VReg_128:%vreg454
>	%vreg987<def> = V_ADD_F32_e32 %vreg985<kill>, %vreg983<kill>, %EXEC<imp-use>; VReg_32:%vreg987,%vreg985,%vreg983
>	%vreg990<def> = COPY %vreg491<kill>; VReg_32:%vreg990 SReg_32:%vreg491
>	%vreg989<def> = V_MUL_F32_e32 %vreg475:sub0, %vreg990<kill>, %EXEC<imp-use>; VReg_32:%vreg989,%vreg990 VReg_128:%vreg475
>	%vreg991<def> = V_ADD_F32_e32 %vreg989<kill>, %vreg987<kill>, %EXEC<imp-use>; VReg_32:%vreg991,%vreg989,%vreg987
>	%vreg994<def> = COPY %vreg512<kill>; VReg_32:%vreg994 SReg_32:%vreg512
>	%vreg993<def> = V_MUL_F32_e32 %vreg496:sub0, %vreg994<kill>, %EXEC<imp-use>; VReg_32:%vreg993,%vreg994 VReg_128:%vreg496
>	%vreg995<def> = V_ADD_F32_e32 %vreg993<kill>, %vreg991<kill>, %EXEC<imp-use>; VReg_32:%vreg995,%vreg993,%vreg991
>	%vreg998<def> = COPY %vreg533<kill>; VReg_32:%vreg998 SReg_32:%vreg533
>	%vreg997<def> = V_MUL_F32_e32 %vreg517:sub0, %vreg998<kill>, %EXEC<imp-use>; VReg_32:%vreg997,%vreg998 VReg_128:%vreg517
>	%vreg999<def> = V_ADD_F32_e32 %vreg997<kill>, %vreg995<kill>, %EXEC<imp-use>; VReg_32:%vreg999,%vreg997,%vreg995
>	%vreg1002<def> = COPY %vreg554<kill>; VReg_32:%vreg1002 SReg_32:%vreg554
>	%vreg1001<def> = V_MUL_F32_e32 %vreg538:sub0, %vreg1002<kill>, %EXEC<imp-use>; VReg_32:%vreg1001,%vreg1002 VReg_128:%vreg538
>	%vreg1003<def> = V_ADD_F32_e32 %vreg1001<kill>, %vreg999<kill>, %EXEC<imp-use>; VReg_32:%vreg1003,%vreg1001,%vreg999
>	%vreg1006<def> = COPY %vreg575<kill>; VReg_32:%vreg1006 SReg_32:%vreg575
>	%vreg1005<def> = V_MUL_F32_e32 %vreg559:sub0, %vreg1006<kill>, %EXEC<imp-use>; VReg_32:%vreg1005,%vreg1006 VReg_128:%vreg559
>	%vreg1007<def> = V_ADD_F32_e32 %vreg1005<kill>, %vreg1003<kill>, %EXEC<imp-use>; VReg_32:%vreg1007,%vreg1005,%vreg1003
>	%vreg1010<def> = COPY %vreg596<kill>; VReg_32:%vreg1010 SReg_32:%vreg596
>	%vreg1009<def> = V_MUL_F32_e32 %vreg580:sub0, %vreg1010<kill>, %EXEC<imp-use>; VReg_32:%vreg1009,%vreg1010 VReg_128:%vreg580
>	%vreg1011<def> = V_ADD_F32_e32 %vreg1009<kill>, %vreg1007<kill>, %EXEC<imp-use>; VReg_32:%vreg1011,%vreg1009,%vreg1007
>	%vreg1014<def> = COPY %vreg617<kill>; VReg_32:%vreg1014 SReg_32:%vreg617
>	%vreg1013<def> = V_MUL_F32_e32 %vreg601:sub0, %vreg1014<kill>, %EXEC<imp-use>; VReg_32:%vreg1013,%vreg1014 VReg_128:%vreg601
>	%vreg1015<def> = V_ADD_F32_e32 %vreg1013<kill>, %vreg1011<kill>, %EXEC<imp-use>; VReg_32:%vreg1015,%vreg1013,%vreg1011
>	%vreg1018<def> = COPY %vreg638<kill>; VReg_32:%vreg1018 SReg_32:%vreg638
>	%vreg1017<def> = V_MUL_F32_e32 %vreg622:sub0, %vreg1018<kill>, %EXEC<imp-use>; VReg_32:%vreg1017,%vreg1018 VReg_128:%vreg622
>	%vreg1019<def> = V_ADD_F32_e32 %vreg1017<kill>, %vreg1015<kill>, %EXEC<imp-use>; VReg_32:%vreg1019,%vreg1017,%vreg1015
>	%vreg1021<def> = S_LOAD_DWORD_IMM %vreg0<kill>, 60; mem:LD4[%1337] SReg_32:%vreg1021 SReg_64:%vreg0
>	%vreg1023<def> = COPY %vreg1021<kill>; VReg_32:%vreg1023 SReg_32:%vreg1021
>	%vreg1022<def> = V_MUL_F32_e32 %vreg643:sub0, %vreg1023<kill>, %EXEC<imp-use>; VReg_32:%vreg1022,%vreg1023 VReg_128:%vreg643
>	%vreg1024<def> = V_ADD_F32_e32 %vreg1022<kill>, %vreg1019<kill>, %EXEC<imp-use>; VReg_32:%vreg1024,%vreg1022,%vreg1019
>	%vreg1025<def> = V_ADD_F32_e64 %vreg1024<kill>, 128, 128, 0, 1, 0, 0, %EXEC<imp-use>; VReg_32:%vreg1025,%vreg1024
>	%vreg1026<def> = V_CVT_PKRTZ_F16_F32_e32 %vreg1025<kill>, %vreg900<kill>, %EXEC<imp-use>; VReg_32:%vreg1026,%vreg1025,%vreg900
>	EXP 15, 0, 1, 1, 1, %vreg1026<kill>, %vreg775<kill>, %vreg1026, %vreg775, %EXEC<imp-use>; VReg_32:%vreg1026,%vreg775,%vreg775
>	S_ENDPGM
>
># End machine code for function main.
>
>*** Bad machine code: Using an undefined physical register ***
>- function:    main
>- basic block: BB#0 main_body (0x1dbaeb0)
>- instruction: %EXEC<def> = S_WQM_B64 %EXEC
>- operand 1:   %EXEC
>LLVM ERROR: Found 1 machine code errors.
>QThreadStorage: Thread 0x13e1910 exited after QThreadStorage 32 destroyed
>QThreadStorage: Thread 0x13e1910 exited after QThreadStorage 31 destroyed
>QThreadStorage: Thread 0x13e1910 exited after QThreadStorage 30 destroyed

Actions: View

Attachments on bug 63236: 77558

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.