From 14ccef9a80d9eb795c373ac296d1458f7fd13a3d Mon Sep 17 00:00:00 2001 From: Valiantsin Dzerakh Date: Fri, 20 Nov 2026 14:39:57 +0300 Subject: [PATCH 1/7] AMD FSR 3.1 upscales the 3D scene on the FidelityFX SDK 1.1.4 sources behind scene_upscaler = fsr3, off by default scene_upscaler (off | dlss | fsr3, read at start) replaces the dlaa toggle on the Screen tab; without the key dlaa = 1 still means DLSS, so nobody gets FSR 3.1 without picking it. The DLSS mode row is the upscaling mode of both engines, the DLSS model, characters' mask, fixed exposure and effects-after rows show only with DLSS, and the performance overlay names the upscaler that ran and its mode. resolution.c sizes the scene for the engine picked at start. runtime/vk_fsr3.cpp drives the SDK's upscaler context on its Vulkan backend directly, as Savage Wind's fsr3.cpp does: one context per output size with the output as its largest render size (the modes and the dynamic resolution need no new context), HDR input (the light target before the bloom, where DLSS reads it), render-size motion vectors with the per-object pass, the camera jitter, the camera's planes and field of view from the scene block (vk_fg_camera; a cut starts a new history), FSR's sharpening off. vk_dlaa.c calls it at the DLSS point after the recorder's drain; the NGX path is left as it was. The backend's per-frame rings hold four dispatches: a dispatch waits for the one three back should it still be in flight. Frame generation stays off while FSR 3.1 runs (logged once). The SDK subset gains the upscaler component, its shader headers, FSR 1's (its RCAS) and its GLSL, from Savage Wind's copy unchanged; tools/ffx_shaders.py --effects fu builds its blobs (HDR, 32- and 16-bit floats) into spirv/ffx_fsr3upscaler_vk.h, and vk_fg.cpp's blob lookup hands those out through vk_fsr3_blob. The luma history's storage image is declared rgba16f, its images' format (rgba8 in the SDK; the validation layer reported it). Co-Authored-By: Claude Opus 5.5 Co-Authored-By: Revivedx <82332536+Revivedx@users.noreply.github.com> --- THIRD_PARTY_NOTICES.md | 4 +- docs/settings.md | 4 +- runtime/cfg.c | 17 +- runtime/cfg.h | 12 + runtime/host.h | 1 + runtime/resolution.c | 30 +- runtime/third_party/FidelityFX/README.md | 27 +- .../include/FidelityFX/gpu/fsr1/ffx_fsr1.h | 1252 +++ .../gpu/fsr1/ffx_fsr1_callbacks_glsl.h | 219 + .../gpu/fsr1/ffx_fsr1_callbacks_hlsl.h | 257 + .../FidelityFX/gpu/fsr1/ffx_fsr1_easu.h | 98 + .../FidelityFX/gpu/fsr1/ffx_fsr1_rcas.h | 116 + .../FidelityFX/gpu/fsr1/ffx_fsr1_resources.h | 38 + .../ffx_fsr3upscaler_accumulate.h | 172 + .../ffx_fsr3upscaler_callbacks_glsl.h | 905 ++ .../ffx_fsr3upscaler_callbacks_hlsl.h | 990 ++ .../fsr3upscaler/ffx_fsr3upscaler_common.h | 403 + .../ffx_fsr3upscaler_debug_view.h | 159 + .../ffx_fsr3upscaler_luma_instability.h | 115 + .../ffx_fsr3upscaler_luma_pyramid.h | 192 + .../ffx_fsr3upscaler_prepare_inputs.h | 152 + .../ffx_fsr3upscaler_prepare_reactivity.h | 283 + .../gpu/fsr3upscaler/ffx_fsr3upscaler_rcas.h | 112 + .../fsr3upscaler/ffx_fsr3upscaler_reproject.h | 108 + .../fsr3upscaler/ffx_fsr3upscaler_resources.h | 100 + .../fsr3upscaler/ffx_fsr3upscaler_sample.h | 628 ++ .../ffx_fsr3upscaler_shading_change.h | 68 + .../ffx_fsr3upscaler_shading_change_pyramid.h | 297 + .../fsr3upscaler/ffx_fsr3upscaler_upsample.h | 644 ++ .../ffx_fsr3upscaler_accumulate_pass.glsl | 75 + ...fx_fsr3upscaler_autogen_reactive_pass.glsl | 84 + .../ffx_fsr3upscaler_debug_view_pass.glsl | 59 + ...fx_fsr3upscaler_luma_instability_pass.glsl | 62 + .../ffx_fsr3upscaler_luma_pyramid_pass.glsl | 65 + .../ffx_fsr3upscaler_prepare_inputs_pass.glsl | 61 + ..._fsr3upscaler_prepare_reactivity_pass.glsl | 65 + .../ffx_fsr3upscaler_rcas_pass.glsl | 59 + .../ffx_fsr3upscaler_shading_change_pass.glsl | 55 + ...3upscaler_shading_change_pyramid_pass.glsl | 67 + .../fsr3upscaler/ffx_fsr3upscaler.cpp | 1509 +++ .../fsr3upscaler/ffx_fsr3upscaler_private.h | 122 + .../FidelityFX/spirv/ffx_fsr3upscaler_vk.h | 8158 +++++++++++++++++ runtime/ui/menu.cpp | 95 +- runtime/ui_text.c | 98 +- runtime/ui_text.h | 6 +- runtime/vk_device.c | 2 + runtime/vk_dlaa.c | 120 +- runtime/vk_dlaa.h | 7 +- runtime/vk_exec_draw.c | 2 +- runtime/vk_fg.cpp | 2 + runtime/vk_fsr3.cpp | 265 + runtime/vk_fsr3.h | 40 + runtime/vk_mvprev.c | 13 +- runtime/vk_usnap.c | 9 +- tools/ffx_shaders.py | 59 +- totk.ini.example | 27 +- 56 files changed, 18464 insertions(+), 125 deletions(-) create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_callbacks_glsl.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_callbacks_hlsl.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_easu.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_rcas.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_resources.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_accumulate.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_callbacks_hlsl.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_common.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_debug_view.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_luma_instability.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_luma_pyramid.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_prepare_inputs.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_prepare_reactivity.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_rcas.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_reproject.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_resources.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_sample.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_shading_change.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_shading_change_pyramid.h create mode 100644 runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_upsample.h create mode 100644 runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_accumulate_pass.glsl create mode 100644 runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_autogen_reactive_pass.glsl create mode 100644 runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_debug_view_pass.glsl create mode 100644 runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_luma_instability_pass.glsl create mode 100644 runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_luma_pyramid_pass.glsl create mode 100644 runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_prepare_inputs_pass.glsl create mode 100644 runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_prepare_reactivity_pass.glsl create mode 100644 runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_rcas_pass.glsl create mode 100644 runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_shading_change_pass.glsl create mode 100644 runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_shading_change_pyramid_pass.glsl create mode 100644 runtime/third_party/FidelityFX/sdk/src/components/fsr3upscaler/ffx_fsr3upscaler.cpp create mode 100644 runtime/third_party/FidelityFX/sdk/src/components/fsr3upscaler/ffx_fsr3upscaler_private.h create mode 100644 runtime/third_party/FidelityFX/spirv/ffx_fsr3upscaler_vk.h create mode 100644 runtime/vk_fsr3.cpp create mode 100644 runtime/vk_fsr3.h diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md index 7270fe87..09fce91a 100644 --- a/THIRD_PARTY_NOTICES.md +++ b/THIRD_PARTY_NOTICES.md @@ -30,8 +30,8 @@ Code copied or adapted from another project is listed here with its source, the | SDL 3.4.20, dynamic link, `SDL3.dll` copied next to `totk.exe`. Developer builds use the MSYS2 build (`mingw-w64-ucrt-x86_64-sdl3`, which imports `libiconv-2.dll`, LGPL-2.1, unmodified, copied beside it); the installer release ships the upstream release `SDL3-3.4.20-win32-x64.zip`, which imports no libiconv | https://libsdl.org, Copyright (c) 1997-2026 Sam Lantinga | zlib | `runtime/input_win.c` (gamepad input, rumble, gyro and accelerometer) | | libopus (MSYS2 `mingw-w64-ucrt-x86_64-opus`), dynamic link, `libopus-0.dll` copied next to `totk.exe` | https://opus-codec.org, Copyright (c) 2001-2023 Xiph.Org, Skype Limited, Octasic, Jean-Marc Valin, Timothy B. Terriberry, CSIRO, Gregory Maxwell, Mark Borgerding, Erik de Castro Lopo, Mozilla, Amazon | BSD-3-Clause | `runtime/ov_media.c` (nn::codec hardware Opus decoder) | | Dear ImGui 1.91.9 (core and Vulkan back end, unmodified), as vendored by LAS Recomp | https://github.com/ocornut/imgui, via https://github.com/peiikai/LASRecomp @ `da35b83a9611d046a9a681aae668d7085954d37f` (`third_party/imgui/`), Copyright (c) 2014-2025 Omar Cornut | MIT | `runtime/third_party/imgui/` (compiled into `totk.exe` for the in-game menu, `runtime/ui/`) | -| AMD FidelityFX SDK 1.1.4 subset (public host and shader headers, frame interpolation and optical flow components, the Vulkan backend `ffx_vk.cpp` and its GLSL shaders, shared helpers), with three marked Savage Wind patches (64-byte aligned backend scratch arrays, doubled context size where `wchar_t` is 4 bytes, all six descriptor pool sizes) | https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/tree/v1.1.4, Copyright (C) 2024 Advanced Micro Devices, Inc., via https://github.com/Revivedx/SavageWindRecomp @ `bf6146c14c37fee8781a601e5a544b93dff6d75e` (`third_party/FidelityFX/`) | MIT | `runtime/third_party/FidelityFX/` (compiled into `totk.exe`; licence text in `runtime/third_party/FidelityFX/LICENSE.txt`, shipped as `licenses/FidelityFX-SDK-LICENSE.txt`) | -| SavageWindRecomp FidelityFX build support and frame generation set-up: the SDK-to-clang compat header, the glslang SPIR-V shader generator with its resource reflection, the blob lookup and the backend and context creation of `runtime/nvn/vulkan/framegen.cpp`, the pair's present spacing of `runtime/nvn/vulkan/device.c` `present_wait_turn` | https://github.com/Revivedx/SavageWindRecomp @ `bf6146c14c37fee8781a601e5a544b93dff6d75e` (`third_party/FidelityFX/ffx_compat.h`, `tools/ffx_shaders.py`, `runtime/nvn/vulkan/framegen.cpp`, `runtime/nvn/vulkan/device.c`) | MIT | `runtime/third_party/FidelityFX/ffx_compat.h`, `runtime/third_party/FidelityFX/spirv/ffx_shaders_vk.h` (output of `tools/ffx_shaders.py`), `tools/ffx_shaders.py`, `runtime/vk_fg.cpp`, `runtime/vk_backend.c` (`present_pair`) | +| AMD FidelityFX SDK 1.1.4 subset (public host and shader headers, frame interpolation, optical flow and FSR 3 upscaler components, the Vulkan backend `ffx_vk.cpp` and its GLSL shaders, shared helpers), with four marked Savage Wind patches (64-byte aligned backend scratch arrays, doubled context size where `wchar_t` is 4 bytes, all six descriptor pool sizes, the upscaler's Catmull-Rom history reprojection) and one of ours (the upscaler's luma history declared `rgba16f`) | https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/tree/v1.1.4, Copyright (C) 2024 Advanced Micro Devices, Inc., via https://github.com/Revivedx/SavageWindRecomp @ `bf6146c14c37fee8781a601e5a544b93dff6d75e` (`third_party/FidelityFX/`) | MIT | `runtime/third_party/FidelityFX/` (compiled into `totk.exe`; licence text in `runtime/third_party/FidelityFX/LICENSE.txt`, shipped as `licenses/FidelityFX-SDK-LICENSE.txt`) | +| SavageWindRecomp FidelityFX build support, frame generation and FSR 3 upscaler set-up: the SDK-to-clang compat header, the glslang SPIR-V shader generator with its resource reflection and its FSR 3 upscaler permutations, the blob lookup and the backend and context creation of `runtime/nvn/vulkan/framegen.cpp`, the upscaler context with its shared images and the dispatch parameters of `runtime/nvn/vulkan/fsr3.cpp`, the pair's present spacing of `runtime/nvn/vulkan/device.c` `present_wait_turn` | https://github.com/Revivedx/SavageWindRecomp @ `bf6146c14c37fee8781a601e5a544b93dff6d75e` (`third_party/FidelityFX/ffx_compat.h`, `tools/ffx_shaders.py`, `runtime/nvn/vulkan/framegen.cpp`, `runtime/nvn/vulkan/fsr3.cpp`, `runtime/nvn/vulkan/device.c`) | MIT | `runtime/third_party/FidelityFX/ffx_compat.h`, `runtime/third_party/FidelityFX/spirv/ffx_shaders_vk.h` and `ffx_fsr3upscaler_vk.h` (output of `tools/ffx_shaders.py`), `tools/ffx_shaders.py`, `runtime/vk_fg.cpp`, `runtime/vk_fsr3.cpp`, `runtime/vk_backend.c` (`present_pair`) | | SavageWindRecomp settings menu: two-pane option rows (row look, left / right stepping, hold speed-up, description pane), the menu style and tab bar | https://github.com/Revivedx/SavageWindRecomp @ `575ad88e02f9a89a9a885d90039d48af33c982f4` (`runtime/ui/option_rows.mm`, `runtime/ui/menu.mm`), Copyright (c) 2026 Revivedx and the Savage Wind Recomp contributors, Copyright (c) 2026 Peiikai | MIT | `runtime/ui/option_rows.cpp`, `runtime/ui/option_rows.h`, `runtime/ui/menu.cpp` | | SavageWindRecomp descriptor sets allocated in growing batches per layout | https://github.com/Revivedx/SavageWindRecomp @ `740b18025fe11ba03c117dbb56668db304b5043e` (`runtime/nvn/vulkan/exec.c` vk_alloc_set), Copyright (c) 2026 Revivedx and the Savage Wind Recomp contributors, Copyright (c) 2026 Peiikai | MIT | `runtime/vk_exec_draw.c` (alloc_set_batched) | | SavageWindRecomp performance overlay: the frame ring and its one-second summary, the NVML calls, the sampling loop, the full panel's layout | https://github.com/Revivedx/SavageWindRecomp @ `575ad88e02f9a89a9a885d90039d48af33c982f4` (`runtime/perfmon.c`, `runtime/perfmon.h`, `perf_overlay_draw` in `runtime/ui/menu.mm`), Copyright (c) 2026 Revivedx and the Savage Wind Recomp contributors, Copyright (c) 2026 Peiikai | MIT | `runtime/perfmon.c`, `runtime/perfmon.h`, `runtime/ui/menu.cpp` | diff --git a/docs/settings.md b/docs/settings.md index c9744ed7..712e003e 100644 --- a/docs/settings.md +++ b/docs/settings.md @@ -143,7 +143,7 @@ Many rows below are developer tools that only act together with another setting | `dyn_delta` (default `1`) | Records only the pipeline dynamic states (cull mode, depth and stencil tests, vertex input, blend enables, equations and write masks, ...) whose values changed since the last draw in the command buffer, also across pipeline changes; `0` records the full set at every change of pipeline state, as before; `ab` alternates with the `ab` blocks. | Fewer commands per pipeline change on the render and recorder threads; a driver that loses dynamic state across pipeline binds would draw with stale state. `TOTK_TRACE=perf` prints the calls and commands per submission. | Caution | | `feedback` | `0` samples a target that an earlier draw of the same pass wrote with no barrier; `restart` ends and restarts the pass behind a full barrier; otherwise the feedback-loop layout is used when the GPU supports it. | `0` brings back the old behaviour that the barrier fixed, so the picture can break in passes that read a target they draw into; `restart` costs extra passes. | Risky | | `flush_span` (default `0`) | `1` copies one span from the lowest to the highest flushed address of a pool, as an older version did. | Copies far more data to the GPU in crowded towns: an estimated 30-50 ms of GPU time per large copy over PCIe 3.0 x8. | Caution | -| `frame_gen` (default `off`) | The frame generator: `off`, or `fsr3`, which brings up AMD FSR 3 frame interpolation and optical flow (FidelityFX SDK 1.1.4) at start; with DLSS off the replay follows the scene and records the camera motion vectors, the picture before the HUD and the interpolation of a frame between each two the game draws (`runtime/vk_fg.cpp`). Each frame then goes out as two presents: the generated picture once the GPU has drawn the frame (a timeline wait, not before the pacer's time), the game's half the smoothed interval later (`runtime/vk_backend.c` `present_pair`); `fps_limit` counts the pictures shown and the game draws half, 30 at least (`runtime/frame_rate.c` `frame_step_cap_ns`). Off with DLSS, `replay_workers` above 0, `sync_ahead = 1` or HDR output, and while a menu background or a loading or event fade is open; the game then draws at the whole limit. The swapchain gets one image more. Applies at once: turned on in the menu, the contexts are made at the next frame (a hitch of about 0.1 s once); turned off, they stay until exit. | The controls answer at the drawn rate, about half a frame later. Costs about 1.5 ms of GPU and 0.6 ms of the replay thread per drawn frame at 1080p (RX 9070, 7900X on 4 cores: 94 drawn without it, 86 drawn and 169 shown with it, no limit). For displays of 120 Hz and more. | Caution | +| `frame_gen` (default `off`) | The frame generator: `off`, or `fsr3`, which brings up AMD FSR 3 frame interpolation and optical flow (FidelityFX SDK 1.1.4) at start; with DLSS off the replay follows the scene and records the camera motion vectors, the picture before the HUD and the interpolation of a frame between each two the game draws (`runtime/vk_fg.cpp`). Each frame then goes out as two presents: the generated picture once the GPU has drawn the frame (a timeline wait, not before the pacer's time), the game's half the smoothed interval later (`runtime/vk_backend.c` `present_pair`); `fps_limit` counts the pictures shown and the game draws half, 30 at least (`runtime/frame_rate.c` `frame_step_cap_ns`). Off with DLSS or FSR 3.1 (`scene_upscaler`), `replay_workers` above 0, `sync_ahead = 1` or HDR output, and while a menu background or a loading or event fade is open; the game then draws at the whole limit. The swapchain gets one image more. Applies at once: turned on in the menu, the contexts are made at the next frame (a hitch of about 0.1 s once); turned off, they stay until exit. | The controls answer at the drawn rate, about half a frame later. Costs about 1.5 ms of GPU and 0.6 ms of the replay thread per drawn frame at 1080p (RX 9070, 7900X on 4 cores: 94 drawn without it, 86 drawn and 169 shown with it, no limit). For displays of 120 Hz and more. | Caution | | `fg_test` | Frame generation checks: `1` presents the generated frame in place of the game's, `2` the picture before the HUD. Read at start. | Shows the frames out of their order: for checks only. | Caution | | `fg_debug` | `1`: the generated frames hold the SDK's debug view (motion fields, optical flow, disocclusion). Read at start. | For checks only. | Caution | | `fg_shot` | Frame generation shots: a present number, or `w` of world time; the window texture, the generated frame and the picture before the HUD of three frames from there go to `fg_shot_dir` as `fg__.png`. | Writes PNGs. | Safe | @@ -190,6 +190,8 @@ Many rows below are developer tools that only act together with another setting | `dlaa_survey` (default `0`) | `1` logs what is drawn into the light target that DLSS reads. | Adds log output and per-draw work. | Caution | | `dlaa_times` (default `0`) | `1` times the DLSS passes on the GPU. | Adds GPU timestamps and log lines. | Caution | | `dlss_reactive` (default `0`) | `1` builds a reactive mask for DLSS where it ran. | Changes how DLSS blends moving areas; a test setting. | Caution | +| `fsr3_debug` (default `0`) | With `scene_upscaler = fsr3`: `1` creates the FSR 3.1 context with the SDK's input checks, whose warnings go to the log (the first 32). | Adds checks to every FSR 3.1 dispatch and log lines. | Caution | +| `fsr3_view` (default `0`) | With `scene_upscaler = fsr3`: `1` shows FSR 3.1's own debug view of its inputs and state in place of the picture. | The frame shows a debug image while it is set. | Caution | | `mv_check` | Frame interval; every that many DLSS frames copies the light target and motion images to host memory and logs how well the vectors explain the picture. | Costs a GPU-to-host copy and a comparison on the completion thread at each interval. | Caution | | `mv_survey` (default `0`) | `1` notes the uniform blocks of each scene draw and compares them with those of earlier frames. | Adds per-draw work and log output. | Caution | | `mvobj_all` (default `0`) | `1` also lists draws for object motion that read no object blocks (terrain and grass). | More draws are checked and listed, which costs time. | Caution | diff --git a/runtime/cfg.c b/runtime/cfg.c index 7a4740c0..566acbcc 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -44,7 +44,7 @@ static const char *const known[] = { "DESC_TEMPLATE", "DESWIZZLE", "DEVICE_PROFILE", "DIALOGUE_CLICK", "DISCORD_APP_ID", "DISCORD_IMAGE", "DISCORD_RPC", "DLAA", "DLAA_CAM_JITTER", "DLAA_EFFECTS_AFTER", "DLAA_JITTER", "DLAA_MV", "DLAA_MASKDEBUG", "DLAA_MVDEBUG", "DLAA_OBJMV", "DLAA_SURVEY", "DLAA_TIMES", "DLSS", "DLSS_CHAR_MASK", "DLSS_FIXED_EXPOSURE", "DLSS_PRESET", "DLSS_REACTIVE", "DUMP", "DUMP_BUF", "DUMP_DIR", "DUMP_LOG", "DYNAMIC_RES", "DYN_DELTA", "EXEFS", "FEEDBACK", "FG_DEBUG", "FG_SHOT", "FG_SHOT_DIR", "FG_TEST", "FG_TIMES", "FIXED_RES_PATCH", "FIX_C0", "FIX_ZERO", "FLIGHT", "FLIGHT_AT", "FLIGHT_DIR", "FLIGHT_FRAMES", "FLIGHT_SPIKE_MS", "FLIGHT_THUMBS", "FLUSH_SPAN", "FOV", "FOV_PATCH", "FPS60", "FPS_LIMIT", "FRAME_GEN", "FRAME_QUEUE", "FREECAM_KEY", "FREECAM_PAD", "FREECAM_PATCH", - "FREEZE_IDLE", "FREE_CORES", + "FREEZE_IDLE", "FREE_CORES", "FSR3_DEBUG", "FSR3_VIEW", "FULLSCREEN", "FXAA", "GAMEPLAY_DISTANCE_SENSITIVITY", "GAMEPLAY_ITEM_AD", "GAMEPLAY_ITEM_SENSITIVITY", "GAMEPLAY_ITEM_WHEEL", "GAMEPLAY_MAP_ZOOM", "GAMEPLAY_MAP_ZOOM_SENSITIVITY", "GAMEPLAY_ROTATION_SENSITIVITY", "GAMEPLAY_TWEAKS_ENABLED", @@ -62,7 +62,7 @@ static const char *const known[] = { "PROFILE_MAIN", "PROFILE_RENDER", "PROMPTS", "PUSH_SKIP", "PUSH_STAGE", "QUICKLOAD_KEY", "QUICKSAVE", "QUICKSAVE_KEY", "RDOC", "RDOC_DIR", "RDOC_DLL", "REALTIME", "REC_ASYNC", "REC_END", "REC_SPIN_US", "REEXEC", "REFLEX", "RENDER_SCALE", "REPLAY_ASYNC", "REPLAY_CHUNKS", "REPLAY_CHUNK_DRAWS", "REPLAY_SKEW_US", "REPLAY_STATE_CHECK", "REPLAY_WORKERS", "REPLAY_CHECK", "REPORT_GUARD", "RESOLVE_CHECK", "RESTART_WAIT", "ROMFS", "ROMFS_INDEX", "ROMFS_MMAP", "ROMFS_MODS", "ROMFS_PATCHES", - "ROMFS_PROOF_DIR", "ROMFS_VERIFY", "RSTICK_DEADZONE", "RUMBLE", "RUMBLE_CURVE", "RUMBLE_STRENGTH", "RUMBLE_TRIGGERS", "SHADER_CACHE", + "ROMFS_PROOF_DIR", "ROMFS_VERIFY", "RSTICK_DEADZONE", "RUMBLE", "RUMBLE_CURVE", "RUMBLE_STRENGTH", "RUMBLE_TRIGGERS", "SCENE_UPSCALER", "SHADER_CACHE", "SHADER_MEMO", "SHADOW", "SHADOW_DEFER", "SHADOW_RANGE", "SHADOW_RES", "SHADOW_SCALE", "SHADOW_SNAP", "SHARED_FONTS", "SHARPNESS", "SHOTS", "SHOTS_DIR", "SHUTTER_FIX", "SHOTS_FULL", "SPEED_PROBE", "SPIN", "SPIN_HANDOFF_US", "SPLIT_DRAWS", "SPLIT_US", "STICK_DEADZONE", "STICK_SENS", "SWKBD_ANSWER", "SYNC_AHEAD", @@ -85,7 +85,7 @@ static const struct { const char *key, *section; } sections[] = { {"COLOR_BRIGHTNESS", "display"}, {"COLOR_CONTRAST", "display"}, {"COLOR_SATURATION", "display"}, {"COLOR_GAMMA", "display"}, {"HDR", "display"}, {"HDR_PEAK_NITS", "display"}, {"HDR_GAME_NITS", "display"}, {"HDR_UI_NITS", "display"}, {"HDR_HUE", "display"}, {"SHADOW_RES", "display"}, - {"DLAA", "display"}, {"DLSS", "display"}, {"DLSS_PRESET", "display"}, {"DLSS_CHAR_MASK", "display"}, {"DLSS_FIXED_EXPOSURE", "display"}, {"DLAA_EFFECTS_AFTER", "display"}, {"REFLEX", "display"}, {"FXAA", "display"}, + {"SCENE_UPSCALER", "display"}, {"DLAA", "display"}, {"DLSS", "display"}, {"DLSS_PRESET", "display"}, {"DLSS_CHAR_MASK", "display"}, {"DLSS_FIXED_EXPOSURE", "display"}, {"DLAA_EFFECTS_AFTER", "display"}, {"REFLEX", "display"}, {"FXAA", "display"}, {"DEVICE_PROFILE", "display"}, {"ASSUME_FOCUS", "display"}, {"DISCORD_RPC", "discord"}, {"DISCORD_APP_ID", "discord"}, {"DISCORD_IMAGE", "discord"}, {"SHADOW_SCALE", "display"}, {"SHADOW_RANGE", "display"}, {"GRASS_RANGE", "display"}, {"CONTACT_SHADOWS", "display"}, @@ -141,7 +141,8 @@ static const CfgMeta metas[] = { {"HUD_WIDTH", "full", "full|21:9|16:9", RESTART}, {"DYNAMIC_RES", "1", "0|1", LIVE}, // resolution.c res_dynres_live {"UPSCALER", "fsr", "fsr|bilinear", LIVE}, {"SHARPNESS", "80", "0..100", LIVE}, - {"DLAA", "0", "0|1", RESTART}, {"DLSS", "dlaa", "dlaa|quality|balanced|performance|ultra_performance", LIVE}, + {"SCENE_UPSCALER", "off", "off|dlss|fsr3", RESTART}, {"DLAA", "0", "0|1", RESTART}, + {"DLSS", "dlaa", "dlaa|quality|balanced|performance|ultra_performance", LIVE}, {"DLSS_PRESET", "default", "default|k|j", LIVE}, {"DLSS_FIXED_EXPOSURE", "0", "0|1", LIVE}, {"DLAA_EFFECTS_AFTER", "0", "0|1", LIVE}, {"DLSS_CHAR_MASK", "65", "0|35|65|100", LIVE}, {"REFLEX", "off", "off|on|boost", RESTART}, {"FXAA", "1", "0|1", LIVE}, {"LOD_STEADY", "0", "0|1", RESTART}, // sets steady @@ -858,3 +859,11 @@ void cfg_init(void) { rt_log("cfg: device profile Steam Deck: defaults for the keys totk.ini does not set (TOTK_DEVICE_PROFILE=desktop " "turns it off)"); } + +// scene_upscaler, or for a totk.ini that predates it the dlaa switch it replaced: dlaa = 1 is DLSS, anything else off. +// FSR 3.1 is never the answer for a player who did not pick it. An unknown value is off. +const char *cfg_scene_upscaler(void) { + if (!cfg_is_set("TOTK_SCENE_UPSCALER")) return cfg_bool("TOTK_DLAA") ? "dlss" : "off"; + const char *v = cfg_value("TOTK_SCENE_UPSCALER"); + return !strcmp(v, "dlss") ? "dlss" : !strcmp(v, "fsr3") ? "fsr3" : "off"; +} diff --git a/runtime/cfg.h b/runtime/cfg.h index 53f6a7b3..c2580881 100644 --- a/runtime/cfg.h +++ b/runtime/cfg.h @@ -69,3 +69,15 @@ const char *cfg_value(const char *name); int cfg_int(const char *name); double cfg_double(const char *name); int cfg_bool(const char *name); +// The 3D scene upscaler the settings name now: "off", "dlss" or "fsr3" (scene_upscaler; without it dlaa = 1 is "dlss"). +// The engine in use is the one named at start (vk_dlaa.c vk_upscaler_engine). +const char *cfg_scene_upscaler(void); +// vk_dlaa.c, the 3D scene upscaler (scene_upscaler): the engine picked at start (UPSCALER_*), +// 1 while the settings still name it (the menu switches it off at once), the engine that is running (it +// ran and has not failed; 0 none), and why an engine cannot run here (UPSCALER_MISSING_*, 0 it can). +enum { UPSCALER_OFF, UPSCALER_DLSS, UPSCALER_FSR3 }; +enum { UPSCALER_MISSING_GPU = 1, UPSCALER_MISSING_DLL }; +int vk_upscaler_engine(void); +int vk_upscaler_on(void); +int vk_upscaler_running(void); +int vk_upscaler_missing(int engine); diff --git a/runtime/host.h b/runtime/host.h index 2b9bbc95..066d34f6 100644 --- a/runtime/host.h +++ b/runtime/host.h @@ -312,6 +312,7 @@ void res_heapdef_served(void); // romfs.c serves the void res_init(void); // after rt_patches_init: the patch page and the sets float res_dlss_lod_bias(void); // TOTK_DLSS upscaling: texture LOD bias (<= 0) int res_dlss_mode(const char *mode); // TOTK_DLSS changed while running: new scene size +int res_dlss_dll(void); // the DLSS library is next to the executable void res_fn_hit(uint64_t addr, uint64_t x0); // main.c fnprof_hit: catches the renderer at start void res_present(Cpu *c); // nvnQueuePresentTexture: applies a pending scene size void res_sizes(unsigned out[2], unsigned scene[2]); // the output and scene sizes in effect (the game's own diff --git a/runtime/resolution.c b/runtime/resolution.c index 728f9c11..57de14f9 100644 --- a/runtime/resolution.c +++ b/runtime/resolution.c @@ -96,6 +96,19 @@ static int dlss_dll(void) { #endif } +int res_dlss_dll(void) { + static int dll = -1; + if (dll < 0) dll = dlss_dll(); + return dll; +} + +// The engine picked at start can run, as far as is known before the device exists: DLSS needs its DLL (dlss_dll); FSR +// 3.1 is built in (vk_fsr3.cpp). Off: nothing to run. +static int upscaler_ready(void) { + int e = vk_upscaler_engine(); + return e == UPSCALER_DLSS ? res_dlss_dll() : e == UPSCALER_FSR3; +} + static uint64_t shadow_kib(void); // The scene size for a share k of the output, within SCENE_MAX a side and within what a texture heap of DTA_MAX_KIB @@ -118,15 +131,17 @@ static int scene_for(double k, unsigned *w, unsigned *h) { } // The scene's share of the output for a TOTK_DLSS mode; 0 for dlaa (the scene keeps base_k), while DLSS/DLAA is off -// (the mode the menu still holds would shrink the scene for the plain upscaler) and where DLSS cannot run (dlss_dll). +// (the mode the menu still holds would shrink the scene for the plain upscaler) and where the engine picked at start +// cannot run (upscaler_ready). static double dlss_share(const char *m) { static const struct { const char *name; double k; } dlss[] = { {"quality", 2.0 / 3.0}, {"balanced", 0.58}, {"performance", 0.5}, {"ultra_performance", 1.0 / 3.0}}; - static int dll = -1; - if (!cfg_bool("TOTK_DLAA")) return 0; + static int told; + if (!vk_upscaler_on()) return 0; for (int i = 0; i < (int)(sizeof dlss / sizeof dlss[0]); i++) if (!strcmp(m, dlss[i].name)) { - if (dll < 0 && !(dll = dlss_dll())) { + int ready = upscaler_ready(); + if (!ready && !told++) { #ifdef _WIN32 rt_log("resolution: DLSS %s needs nvngx_dlss.dll next to totk.exe, which is missing: the scene follows " "render_scale", m); @@ -135,7 +150,7 @@ static double dlss_share(const char *m) { "scene follows render_scale", m); #endif } - return dll ? dlss[i].k : 0; + return ready ? dlss[i].k : 0; } return 0; } @@ -192,12 +207,13 @@ static void decide(void) { if (n >= 256 && n <= 4096 && !(n & 7)) R.shadow = n; else rt_log("resolution: TOTK_SHADOW_RES=%s is not game or a size 256..4096 (a multiple of 8); game", sr); } - // A DLSS mode other than dlaa sets the scene size instead. On 1.4.3 with DLSS able to run (DLAA on, the DLL there) + // A DLSS mode other than dlaa sets the scene size instead. On 1.4.3 with the scene upscaler able to run (DLSS with + // its DLL there, or FSR 3.1 in the build) // the mode can change while the game runs (res_dlss_mode): the scene patch is then always on and the heap is sized // for the largest scene the modes ask for. Everyone else keeps the game's own scene size and its dynamic resolution // unless render_scale or a DLSS mode asks for another, and a heap sized for that scene alone. R.base_k = k; - R.live = RT_V143 && cfg_bool("TOTK_DLAA") && dlss_dll(); + R.live = RT_V143 && vk_upscaler_on() && upscaler_ready(); const char *m = cfg_value("TOTK_DLSS"); R.dlss_k = dlss_share(m); if (R.dlss_k) rt_log("resolution: DLSS %s: the scene at %.0f %% of the output (render_scale ignored)", m, R.dlss_k * 100); diff --git a/runtime/third_party/FidelityFX/README.md b/runtime/third_party/FidelityFX/README.md index f3940c99..e784cf55 100644 --- a/runtime/third_party/FidelityFX/README.md +++ b/runtime/third_party/FidelityFX/README.md @@ -3,22 +3,27 @@ From , MIT (`LICENSE.txt`), via Savage Wind (, MIT, `third_party/FidelityFX`). `runtime/vk_fg.cpp` drives the frame interpolation and optical flow of FSR 3 on the SDK's Vulkan backend directly, without the SDK's frame interpolation -swapchain or its ffx-api DLL layer. +swapchain or its ffx-api DLL layer; `runtime/vk_fsr3.cpp` drives the FSR 3.1 upscaler the same way. What is here: - `sdk/include/FidelityFX/host`: the SDK's public headers; `gpu`: the shader headers of frame interpolation, optical - flow and SPD (which optical flow includes). Left out against Savage Wind's copy: the FSR 3 upscaler's and FSR 1's - shader headers (`gpu/fsr3upscaler`, `gpu/fsr1`), its component and its GLSL. The host headers of the upscaler and - the other effects stay, unchanged, because the SDK's own headers include each other. -- `sdk/src/components/frameinterpolation`, `opticalflow`: the two effects. -- `sdk/src/backends/vk/ffx_vk.cpp` and its `shaders/frameinterpolation`, `shaders/opticalflow` (GLSL). + flow, the FSR 3 upscaler, SPD (which optical flow and the upscaler include) and FSR 1 (the upscaler's RCAS). The host + headers of the other effects stay, unchanged, because the SDK's own headers include each other. +- `sdk/src/components/frameinterpolation`, `opticalflow`, `fsr3upscaler`: the three effects. +- `sdk/src/backends/vk/ffx_vk.cpp` and its `shaders/frameinterpolation`, `shaders/opticalflow`, `shaders/fsr3upscaler` + (GLSL). - `sdk/src/shared`: the SDK's assert, message and object-management helpers. -- `sdk/src/backends/shared/ffx_shader_blobs.h`: the declaration of the blob lookup, which `runtime/vk_fg.cpp` implements. +- `sdk/src/backends/shared/ffx_shader_blobs.h`: the declaration of the blob lookup, which `runtime/vk_fg.cpp` implements + (the upscaler's blobs through `runtime/vk_fsr3.cpp` `vk_fsr3_blob`). - `spirv/ffx_shaders_vk.h`: the shaders compiled to SPIR-V with their bindings, by `tools/ffx_shaders.py` (glslangValidator from MSYS2 UCRT64 or the Vulkan SDK) in place of the SDK's Windows-only FidelityFX_SC.exe. Only the permutations used. Committed like `runtime/*_spv.h`: AMD's shaders, no game data. Regenerate after changing the GLSL: `python tools/ffx_shaders.py`. +- `spirv/ffx_fsr3upscaler_vk.h`: the same for the FSR 3 upscaler (`python tools/ffx_shaders.py --effects fu`), one + permutation per pass: HDR input (the scene's linear light before the bloom), render-size motion vectors without + jitter, depth not inverted, the reference Lanczos and Savage Wind's Catmull-Rom history reprojection, in 32-bit and + 16-bit floats (the 16-bit ones where the SDK asks for them and the device has shaderFloat16 and shaderInt16). - `ffx_compat.h`: force-included into the SDK's sources (`tools/build_game.py`, rule `cc_ffx`) so they build with clang. Changes to the SDK's files (marked "Savage Wind" in them): @@ -30,3 +35,11 @@ Changes to the SDK's files (marked "Savage Wind" in them): (their resources' debug names) is 4 bytes instead of 2. - `sdk/src/backends/vk/ffx_vk.cpp`: the global descriptor pool is created with all six of the sizes it lists. It passed five, leaving out the storage buffers (the validation layer reports it). +- `sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_reproject.h`: the history reprojected with a Catmull-Rom + filter from 5 bilinear samples (`FFX_FSR3UPSCALER_OPTION_REPROJECT_CATMULL_ROM_5`), a Savage Wind addition. + +Changes of our own (marked "TotK Recomp"): + +- `sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h`: the luma history's storage image is + declared `rgba16f`, the format of its images (R16G16B16A16_FLOAT in `ffx_fsr3upscaler.cpp`). It was `rgba8`, which + the Vulkan validation layer reports as a format mismatch with undefined loads and stores. diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1.h new file mode 100644 index 00000000..82ebf21f --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1.h @@ -0,0 +1,1252 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +/// @defgroup FfxGPUFsr1 FidelityFX FSR1 +/// FidelityFX Super Resolution 1 GPU documentation +/// +/// @ingroup FfxGPUEffects + +/// Setup required constant values for EASU (works on CPU or GPU). +/// +/// @param [out] con0 +/// @param [out] con1 +/// @param [out] con2 +/// @param [out] con3 +/// @param [in] inputViewportInPixelsX The rendered image resolution being upscaled in X dimension. +/// @param [in] inputViewportInPixelsY The rendered image resolution being upscaled in Y dimension. +/// @param [in] inputSizeInPixelsX The resolution of the resource containing the input image (useful for dynamic resolution) in X dimension. +/// @param [in] inputSizeInPixelsY The resolution of the resource containing the input image (useful for dynamic resolution) in Y dimension. +/// @param [in] outputSizeInPixelsX The display resolution which the input image gets upscaled to in X dimension. +/// @param [in] outputSizeInPixelsY The display resolution which the input image gets upscaled to in Y dimension. +/// +/// @ingroup FfxGPUFsr1 +FFX_STATIC void ffxFsrPopulateEasuConstants( + FFX_PARAMETER_INOUT FfxUInt32x4 con0, + FFX_PARAMETER_INOUT FfxUInt32x4 con1, + FFX_PARAMETER_INOUT FfxUInt32x4 con2, + FFX_PARAMETER_INOUT FfxUInt32x4 con3, + FFX_PARAMETER_IN FfxFloat32 inputViewportInPixelsX, + FFX_PARAMETER_IN FfxFloat32 inputViewportInPixelsY, + FFX_PARAMETER_IN FfxFloat32 inputSizeInPixelsX, + FFX_PARAMETER_IN FfxFloat32 inputSizeInPixelsY, + FFX_PARAMETER_IN FfxFloat32 outputSizeInPixelsX, + FFX_PARAMETER_IN FfxFloat32 outputSizeInPixelsY) +{ + // Output integer position to a pixel position in viewport. + con0[0] = ffxAsUInt32(inputViewportInPixelsX * ffxReciprocal(outputSizeInPixelsX)); + con0[1] = ffxAsUInt32(inputViewportInPixelsY * ffxReciprocal(outputSizeInPixelsY)); + con0[2] = ffxAsUInt32(FfxFloat32(0.5) * inputViewportInPixelsX * ffxReciprocal(outputSizeInPixelsX) - FfxFloat32(0.5)); + con0[3] = ffxAsUInt32(FfxFloat32(0.5) * inputViewportInPixelsY * ffxReciprocal(outputSizeInPixelsY) - FfxFloat32(0.5)); + + // Viewport pixel position to normalized image space. + // This is used to get upper-left of 'F' tap. + con1[0] = ffxAsUInt32(ffxReciprocal(inputSizeInPixelsX)); + con1[1] = ffxAsUInt32(ffxReciprocal(inputSizeInPixelsY)); + + // Centers of gather4, first offset from upper-left of 'F'. + // +---+---+ + // | | | + // +--(0)--+ + // | b | c | + // +---F---+---+---+ + // | e | f | g | h | + // +--(1)--+--(2)--+ + // | i | j | k | l | + // +---+---+---+---+ + // | n | o | + // +--(3)--+ + // | | | + // +---+---+ + con1[2] = ffxAsUInt32(FfxFloat32(1.0) * ffxReciprocal(inputSizeInPixelsX)); + con1[3] = ffxAsUInt32(FfxFloat32(-1.0) * ffxReciprocal(inputSizeInPixelsY)); + + // These are from (0) instead of 'F'. + con2[0] = ffxAsUInt32(FfxFloat32(-1.0) * ffxReciprocal(inputSizeInPixelsX)); + con2[1] = ffxAsUInt32(FfxFloat32(2.0) * ffxReciprocal(inputSizeInPixelsY)); + con2[2] = ffxAsUInt32(FfxFloat32(1.0) * ffxReciprocal(inputSizeInPixelsX)); + con2[3] = ffxAsUInt32(FfxFloat32(2.0) * ffxReciprocal(inputSizeInPixelsY)); + con3[0] = ffxAsUInt32(FfxFloat32(0.0) * ffxReciprocal(inputSizeInPixelsX)); + con3[1] = ffxAsUInt32(FfxFloat32(4.0) * ffxReciprocal(inputSizeInPixelsY)); + con3[2] = con3[3] = 0; +} + +/// Setup required constant values for EASU (works on CPU or GPU). +/// +/// @param [out] con0 +/// @param [out] con1 +/// @param [out] con2 +/// @param [out] con3 +/// @param [in] inputViewportInPixelsX The resolution of the input in the X dimension. +/// @param [in] inputViewportInPixelsY The resolution of the input in the Y dimension. +/// @param [in] inputSizeInPixelsX The input size in pixels in the X dimension. +/// @param [in] inputSizeInPixelsY The input size in pixels in the Y dimension. +/// @param [in] outputSizeInPixelsX The output size in pixels in the X dimension. +/// @param [in] outputSizeInPixelsY The output size in pixels in the Y dimension. +/// @param [in] inputOffsetInPixelsX The input image offset in the X dimension into the resource containing it (useful for dynamic resolution). +/// @param [in] inputOffsetInPixelsY The input image offset in the Y dimension into the resource containing it (useful for dynamic resolution). +/// +/// @ingroup FfxGPUFsr1 +FFX_STATIC void ffxFsrPopulateEasuConstantsOffset( + FFX_PARAMETER_INOUT FfxUInt32x4 con0, + FFX_PARAMETER_INOUT FfxUInt32x4 con1, + FFX_PARAMETER_INOUT FfxUInt32x4 con2, + FFX_PARAMETER_INOUT FfxUInt32x4 con3, + FFX_PARAMETER_IN FfxFloat32 inputViewportInPixelsX, + FFX_PARAMETER_IN FfxFloat32 inputViewportInPixelsY, + FFX_PARAMETER_IN FfxFloat32 inputSizeInPixelsX, + FFX_PARAMETER_IN FfxFloat32 inputSizeInPixelsY, + FFX_PARAMETER_IN FfxFloat32 outputSizeInPixelsX, + FFX_PARAMETER_IN FfxFloat32 outputSizeInPixelsY, + FFX_PARAMETER_IN FfxFloat32 inputOffsetInPixelsX, + FFX_PARAMETER_IN FfxFloat32 inputOffsetInPixelsY) +{ + ffxFsrPopulateEasuConstants( + con0, + con1, + con2, + con3, + inputViewportInPixelsX, + inputViewportInPixelsY, + inputSizeInPixelsX, + inputSizeInPixelsY, + outputSizeInPixelsX, + outputSizeInPixelsY); + + // override + con0[2] = ffxAsUInt32(FfxFloat32(0.5) * inputViewportInPixelsX * ffxReciprocal(outputSizeInPixelsX) - FfxFloat32(0.5) + inputOffsetInPixelsX); + con0[3] = ffxAsUInt32(FfxFloat32(0.5) * inputViewportInPixelsY * ffxReciprocal(outputSizeInPixelsY) - FfxFloat32(0.5) + inputOffsetInPixelsY); +} + +#if defined(FFX_GPU) && defined(FFX_FSR_EASU_FLOAT) +// Input callback prototypes, need to be implemented by calling shader +FfxFloat32x4 FsrEasuRF(FfxFloat32x2 p); +FfxFloat32x4 FsrEasuGF(FfxFloat32x2 p); +FfxFloat32x4 FsrEasuBF(FfxFloat32x2 p); + +// Filtering for a given tap for the scalar. +void fsrEasuTapFloat( + FFX_PARAMETER_INOUT FfxFloat32x3 accumulatedColor, // Accumulated color, with negative lobe. + FFX_PARAMETER_INOUT FfxFloat32 accumulatedWeight, // Accumulated weight. + FFX_PARAMETER_IN FfxFloat32x2 pixelOffset, // Pixel offset from resolve position to tap. + FFX_PARAMETER_IN FfxFloat32x2 gradientDirection, // Gradient direction. + FFX_PARAMETER_IN FfxFloat32x2 length, // Length. + FFX_PARAMETER_IN FfxFloat32 negativeLobeStrength, // Negative lobe strength. + FFX_PARAMETER_IN FfxFloat32 clippingPoint, // Clipping point. + FFX_PARAMETER_IN FfxFloat32x3 color) // Tap color. +{ + // Rotate offset by direction. + FfxFloat32x2 rotatedOffset; + rotatedOffset.x = (pixelOffset.x * (gradientDirection.x)) + (pixelOffset.y * gradientDirection.y); + rotatedOffset.y = (pixelOffset.x * (-gradientDirection.y)) + (pixelOffset.y * gradientDirection.x); + + // Anisotropy. + rotatedOffset *= length; + + // Compute distance^2. + FfxFloat32 distanceSquared = rotatedOffset.x * rotatedOffset.x + rotatedOffset.y * rotatedOffset.y; + + // Limit to the window as at corner, 2 taps can easily be outside. + distanceSquared = ffxMin(distanceSquared, clippingPoint); + + // Approximation of lancos2 without sin() or rcp(), or sqrt() to get x. + // (25/16 * (2/5 * x^2 - 1)^2 - (25/16 - 1)) * (1/4 * x^2 - 1)^2 + // |_______________________________________| |_______________| + // base window + // The general form of the 'base' is, + // (a*(b*x^2-1)^2-(a-1)) + // Where 'a=1/(2*b-b^2)' and 'b' moves around the negative lobe. + FfxFloat32 weightB = FfxFloat32(2.0 / 5.0) * distanceSquared + FfxFloat32(-1.0); + FfxFloat32 weightA = negativeLobeStrength * distanceSquared + FfxFloat32(-1.0); + weightB *= weightB; + weightA *= weightA; + weightB = FfxFloat32(25.0 / 16.0) * weightB + FfxFloat32(-(25.0 / 16.0 - 1.0)); + FfxFloat32 weight = weightB * weightA; + + // Do weighted average. + accumulatedColor += color * weight; + accumulatedWeight += weight; +} + +// Accumulate direction and length. +void fsrEasuSetFloat( + FFX_PARAMETER_INOUT FfxFloat32x2 direction, + FFX_PARAMETER_INOUT FfxFloat32 length, + FFX_PARAMETER_IN FfxFloat32x2 pp, + FFX_PARAMETER_IN FfxBoolean biS, + FFX_PARAMETER_IN FfxBoolean biT, + FFX_PARAMETER_IN FfxBoolean biU, + FFX_PARAMETER_IN FfxBoolean biV, + FFX_PARAMETER_IN FfxFloat32 lA, + FFX_PARAMETER_IN FfxFloat32 lB, + FFX_PARAMETER_IN FfxFloat32 lC, + FFX_PARAMETER_IN FfxFloat32 lD, + FFX_PARAMETER_IN FfxFloat32 lE) +{ + // Compute bilinear weight, branches factor out as predicates are compiler time immediates. + // s t + // u v + FfxFloat32 weight = FfxFloat32(0.0); + if (biS) + weight = (FfxFloat32(1.0) - pp.x) * (FfxFloat32(1.0) - pp.y); + if (biT) + weight = pp.x * (FfxFloat32(1.0) - pp.y); + if (biU) + weight = (FfxFloat32(1.0) - pp.x) * pp.y; + if (biV) + weight = pp.x * pp.y; + + // Direction is the '+' diff. + // a + // b c d + // e + // Then takes magnitude from abs average of both sides of 'c'. + // Length converts gradient reversal to 0, smoothly to non-reversal at 1, shaped, then adding horz and vert terms. + FfxFloat32 dc = lD - lC; + FfxFloat32 cb = lC - lB; + FfxFloat32 lengthX = max(abs(dc), abs(cb)); + lengthX = ffxApproximateReciprocal(lengthX); + FfxFloat32 directionX = lD - lB; + direction.x += directionX * weight; + lengthX = ffxSaturate(abs(directionX) * lengthX); + lengthX *= lengthX; + length += lengthX * weight; + + // Repeat for the y axis. + FfxFloat32 ec = lE - lC; + FfxFloat32 ca = lC - lA; + FfxFloat32 lengthY = max(abs(ec), abs(ca)); + lengthY = ffxApproximateReciprocal(lengthY); + FfxFloat32 directionY = lE - lA; + direction.y += directionY * weight; + lengthY = ffxSaturate(abs(directionY) * lengthY); + lengthY *= lengthY; + length += lengthY * weight; +} + +/// Apply edge-aware spatial upsampling using 32bit floating point precision calculations. +/// +/// @param [out] outPixel The computed color of a pixel. +/// @param [in] integerPosition Integer pixel position within the output. +/// @param [in] con0 The first constant value generated by ffxFsrPopulateEasuConstants. +/// @param [in] con1 The second constant value generated by ffxFsrPopulateEasuConstants. +/// @param [in] con2 The third constant value generated by ffxFsrPopulateEasuConstants. +/// @param [in] con3 The fourth constant value generated by ffxFsrPopulateEasuConstants. +/// +/// @ingroup FSR +void ffxFsrEasuFloat( + FFX_PARAMETER_OUT FfxFloat32x3 pix, + FFX_PARAMETER_IN FfxUInt32x2 ip, + FFX_PARAMETER_IN FfxUInt32x4 con0, + FFX_PARAMETER_IN FfxUInt32x4 con1, + FFX_PARAMETER_IN FfxUInt32x4 con2, + FFX_PARAMETER_IN FfxUInt32x4 con3) +{ + // Get position of 'f'. + FfxFloat32x2 pp = FfxFloat32x2(ip) * ffxAsFloat(con0.xy) + ffxAsFloat(con0.zw); + FfxFloat32x2 fp = floor(pp); + pp -= fp; + + // 12-tap kernel. + // b c + // e f g h + // i j k l + // n o + // Gather 4 ordering. + // a b + // r g + // For packed FP16, need either {rg} or {ab} so using the following setup for gather in all versions, + // a b <- unused (z) + // r g + // a b a b + // r g r g + // a b + // r g <- unused (z) + // Allowing dead-code removal to remove the 'z's. + FfxFloat32x2 p0 = fp * ffxAsFloat(con1.xy) + ffxAsFloat(con1.zw); + + // These are from p0 to avoid pulling two constants on pre-Navi hardware. + FfxFloat32x2 p1 = p0 + ffxAsFloat(con2.xy); + FfxFloat32x2 p2 = p0 + ffxAsFloat(con2.zw); + FfxFloat32x2 p3 = p0 + ffxAsFloat(con3.xy); + FfxFloat32x4 bczzR = FsrEasuRF(p0); + FfxFloat32x4 bczzG = FsrEasuGF(p0); + FfxFloat32x4 bczzB = FsrEasuBF(p0); + FfxFloat32x4 ijfeR = FsrEasuRF(p1); + FfxFloat32x4 ijfeG = FsrEasuGF(p1); + FfxFloat32x4 ijfeB = FsrEasuBF(p1); + FfxFloat32x4 klhgR = FsrEasuRF(p2); + FfxFloat32x4 klhgG = FsrEasuGF(p2); + FfxFloat32x4 klhgB = FsrEasuBF(p2); + FfxFloat32x4 zzonR = FsrEasuRF(p3); + FfxFloat32x4 zzonG = FsrEasuGF(p3); + FfxFloat32x4 zzonB = FsrEasuBF(p3); + + // Simplest multi-channel approximate luma possible (luma times 2, in 2 FMA/MAD). + FfxFloat32x4 bczzL = bczzB * ffxBroadcast4(0.5) + (bczzR * ffxBroadcast4(0.5) + bczzG); + FfxFloat32x4 ijfeL = ijfeB * ffxBroadcast4(0.5) + (ijfeR * ffxBroadcast4(0.5) + ijfeG); + FfxFloat32x4 klhgL = klhgB * ffxBroadcast4(0.5) + (klhgR * ffxBroadcast4(0.5) + klhgG); + FfxFloat32x4 zzonL = zzonB * ffxBroadcast4(0.5) + (zzonR * ffxBroadcast4(0.5) + zzonG); + + // Rename. + FfxFloat32 bL = bczzL.x; + FfxFloat32 cL = bczzL.y; + FfxFloat32 iL = ijfeL.x; + FfxFloat32 jL = ijfeL.y; + FfxFloat32 fL = ijfeL.z; + FfxFloat32 eL = ijfeL.w; + FfxFloat32 kL = klhgL.x; + FfxFloat32 lL = klhgL.y; + FfxFloat32 hL = klhgL.z; + FfxFloat32 gL = klhgL.w; + FfxFloat32 oL = zzonL.z; + FfxFloat32 nL = zzonL.w; + + // Accumulate for bilinear interpolation. + FfxFloat32x2 dir = ffxBroadcast2(0.0); + FfxFloat32 len = FfxFloat32(0.0); + fsrEasuSetFloat(dir, len, pp, FFX_TRUE, FFX_FALSE, FFX_FALSE, FFX_FALSE, bL, eL, fL, gL, jL); + fsrEasuSetFloat(dir, len, pp, FFX_FALSE, FFX_TRUE, FFX_FALSE, FFX_FALSE, cL, fL, gL, hL, kL); + fsrEasuSetFloat(dir, len, pp, FFX_FALSE, FFX_FALSE, FFX_TRUE, FFX_FALSE, fL, iL, jL, kL, nL); + fsrEasuSetFloat(dir, len, pp, FFX_FALSE, FFX_FALSE, FFX_FALSE, FFX_TRUE, gL, jL, kL, lL, oL); + + // Normalize with approximation, and cleanup close to zero. + FfxFloat32x2 dir2 = dir * dir; + FfxFloat32 dirR = dir2.x + dir2.y; + FfxBoolean zro = dirR < FfxFloat32(1.0 / 32768.0); + dirR = ffxApproximateReciprocalSquareRoot(dirR); + dirR = zro ? FfxFloat32(1.0) : dirR; + dir.x = zro ? FfxFloat32(1.0) : dir.x; + dir *= ffxBroadcast2(dirR); + + // Transform from {0 to 2} to {0 to 1} range, and shape with square. + len = len * FfxFloat32(0.5); + len *= len; + + // Stretch kernel {1.0 vert|horz, to sqrt(2.0) on diagonal}. + FfxFloat32 stretch = (dir.x * dir.x + dir.y * dir.y) * ffxApproximateReciprocal(max(abs(dir.x), abs(dir.y))); + + // Anisotropic length after rotation, + // x := 1.0 lerp to 'stretch' on edges + // y := 1.0 lerp to 2x on edges + FfxFloat32x2 len2 = FfxFloat32x2(FfxFloat32(1.0) + (stretch - FfxFloat32(1.0)) * len, FfxFloat32(1.0) + FfxFloat32(-0.5) * len); + + // Based on the amount of 'edge', + // the window shifts from +/-{sqrt(2.0) to slightly beyond 2.0}. + FfxFloat32 lob = FfxFloat32(0.5) + FfxFloat32((1.0 / 4.0 - 0.04) - 0.5) * len; + + // Set distance^2 clipping point to the end of the adjustable window. + FfxFloat32 clp = ffxApproximateReciprocal(lob); + + // Accumulation mixed with min/max of 4 nearest. + // b c + // e f g h + // i j k l + // n o + FfxFloat32x3 min4 = + ffxMin(ffxMin3(FfxFloat32x3(ijfeR.z, ijfeG.z, ijfeB.z), FfxFloat32x3(klhgR.w, klhgG.w, klhgB.w), FfxFloat32x3(ijfeR.y, ijfeG.y, ijfeB.y)), + FfxFloat32x3(klhgR.x, klhgG.x, klhgB.x)); + FfxFloat32x3 max4 = + max(ffxMax3(FfxFloat32x3(ijfeR.z, ijfeG.z, ijfeB.z), FfxFloat32x3(klhgR.w, klhgG.w, klhgB.w), FfxFloat32x3(ijfeR.y, ijfeG.y, ijfeB.y)), FfxFloat32x3(klhgR.x, klhgG.x, klhgB.x)); + + // Accumulation. + FfxFloat32x3 aC = ffxBroadcast3(0.0); + FfxFloat32 aW = FfxFloat32(0.0); + fsrEasuTapFloat(aC, aW, FfxFloat32x2(0.0, -1.0) - pp, dir, len2, lob, clp, FfxFloat32x3(bczzR.x, bczzG.x, bczzB.x)); // b + fsrEasuTapFloat(aC, aW, FfxFloat32x2(1.0, -1.0) - pp, dir, len2, lob, clp, FfxFloat32x3(bczzR.y, bczzG.y, bczzB.y)); // c + fsrEasuTapFloat(aC, aW, FfxFloat32x2(-1.0, 1.0) - pp, dir, len2, lob, clp, FfxFloat32x3(ijfeR.x, ijfeG.x, ijfeB.x)); // i + fsrEasuTapFloat(aC, aW, FfxFloat32x2(0.0, 1.0) - pp, dir, len2, lob, clp, FfxFloat32x3(ijfeR.y, ijfeG.y, ijfeB.y)); // j + fsrEasuTapFloat(aC, aW, FfxFloat32x2(0.0, 0.0) - pp, dir, len2, lob, clp, FfxFloat32x3(ijfeR.z, ijfeG.z, ijfeB.z)); // f + fsrEasuTapFloat(aC, aW, FfxFloat32x2(-1.0, 0.0) - pp, dir, len2, lob, clp, FfxFloat32x3(ijfeR.w, ijfeG.w, ijfeB.w)); // e + fsrEasuTapFloat(aC, aW, FfxFloat32x2(1.0, 1.0) - pp, dir, len2, lob, clp, FfxFloat32x3(klhgR.x, klhgG.x, klhgB.x)); // k + fsrEasuTapFloat(aC, aW, FfxFloat32x2(2.0, 1.0) - pp, dir, len2, lob, clp, FfxFloat32x3(klhgR.y, klhgG.y, klhgB.y)); // l + fsrEasuTapFloat(aC, aW, FfxFloat32x2(2.0, 0.0) - pp, dir, len2, lob, clp, FfxFloat32x3(klhgR.z, klhgG.z, klhgB.z)); // h + fsrEasuTapFloat(aC, aW, FfxFloat32x2(1.0, 0.0) - pp, dir, len2, lob, clp, FfxFloat32x3(klhgR.w, klhgG.w, klhgB.w)); // g + fsrEasuTapFloat(aC, aW, FfxFloat32x2(1.0, 2.0) - pp, dir, len2, lob, clp, FfxFloat32x3(zzonR.z, zzonG.z, zzonB.z)); // o + fsrEasuTapFloat(aC, aW, FfxFloat32x2(0.0, 2.0) - pp, dir, len2, lob, clp, FfxFloat32x3(zzonR.w, zzonG.w, zzonB.w)); // n + + // Normalize and dering. + pix = ffxMin(max4, max(min4, aC * ffxBroadcast3(ffxReciprocal(aW)))); +} +#endif // #if defined(FFX_GPU) && defined(FFX_FSR_EASU_FLOAT) + +#if defined(FFX_GPU) && FFX_HALF == 1 && defined(FFX_FSR_EASU_HALF) +// Input callback prototypes, need to be implemented by calling shader +FfxFloat16x4 FsrEasuRH(FfxFloat32x2 p); +FfxFloat16x4 FsrEasuGH(FfxFloat32x2 p); +FfxFloat16x4 FsrEasuBH(FfxFloat32x2 p); + +// This runs 2 taps in parallel. +void FsrEasuTapH( + FFX_PARAMETER_INOUT FfxFloat16x2 aCR, + FFX_PARAMETER_INOUT FfxFloat16x2 aCG, + FFX_PARAMETER_INOUT FfxFloat16x2 aCB, + FFX_PARAMETER_INOUT FfxFloat16x2 aW, + FFX_PARAMETER_IN FfxFloat16x2 offX, + FFX_PARAMETER_IN FfxFloat16x2 offY, + FFX_PARAMETER_IN FfxFloat16x2 dir, + FFX_PARAMETER_IN FfxFloat16x2 len, + FFX_PARAMETER_IN FfxFloat16 lob, + FFX_PARAMETER_IN FfxFloat16 clp, + FFX_PARAMETER_IN FfxFloat16x2 cR, + FFX_PARAMETER_IN FfxFloat16x2 cG, + FFX_PARAMETER_IN FfxFloat16x2 cB) +{ + FfxFloat16x2 vX, vY; + vX = offX * dir.xx + offY * dir.yy; + vY = offX * (-dir.yy) + offY * dir.xx; + vX *= len.x; + vY *= len.y; + FfxFloat16x2 d2 = vX * vX + vY * vY; + d2 = min(d2, FFX_BROADCAST_FLOAT16X2(clp)); + FfxFloat16x2 wB = FFX_BROADCAST_FLOAT16X2(2.0 / 5.0) * d2 + FFX_BROADCAST_FLOAT16X2(-1.0); + FfxFloat16x2 wA = FFX_BROADCAST_FLOAT16X2(lob) * d2 + FFX_BROADCAST_FLOAT16X2(-1.0); + wB *= wB; + wA *= wA; + wB = FFX_BROADCAST_FLOAT16X2(25.0 / 16.0) * wB + FFX_BROADCAST_FLOAT16X2(-(25.0 / 16.0 - 1.0)); + FfxFloat16x2 w = wB * wA; + aCR += cR * w; + aCG += cG * w; + aCB += cB * w; + aW += w; +} + +// This runs 2 taps in parallel. +void FsrEasuSetH( + FFX_PARAMETER_INOUT FfxFloat16x2 dirPX, + FFX_PARAMETER_INOUT FfxFloat16x2 dirPY, + FFX_PARAMETER_INOUT FfxFloat16x2 lenP, + FFX_PARAMETER_IN FfxFloat16x2 pp, + FFX_PARAMETER_IN FfxBoolean biST, + FFX_PARAMETER_IN FfxBoolean biUV, + FFX_PARAMETER_IN FfxFloat16x2 lA, + FFX_PARAMETER_IN FfxFloat16x2 lB, + FFX_PARAMETER_IN FfxFloat16x2 lC, + FFX_PARAMETER_IN FfxFloat16x2 lD, + FFX_PARAMETER_IN FfxFloat16x2 lE) +{ + FfxFloat16x2 w = FFX_BROADCAST_FLOAT16X2(0.0); + + if (biST) + w = (FfxFloat16x2(1.0, 0.0) + FfxFloat16x2(-pp.x, pp.x)) * FFX_BROADCAST_FLOAT16X2(FFX_BROADCAST_FLOAT16(1.0) - pp.y); + + if (biUV) + w = (FfxFloat16x2(1.0, 0.0) + FfxFloat16x2(-pp.x, pp.x)) * FFX_BROADCAST_FLOAT16X2(pp.y); + + // ABS is not free in the packed FP16 path. + FfxFloat16x2 dc = lD - lC; + FfxFloat16x2 cb = lC - lB; + FfxFloat16x2 lenX = max(abs(dc), abs(cb)); + lenX = ffxReciprocalHalf(lenX); + + FfxFloat16x2 dirX = lD - lB; + dirPX += dirX * w; + lenX = ffxSaturate(abs(dirX) * lenX); + lenX *= lenX; + lenP += lenX * w; + FfxFloat16x2 ec = lE - lC; + FfxFloat16x2 ca = lC - lA; + FfxFloat16x2 lenY = max(abs(ec), abs(ca)); + lenY = ffxReciprocalHalf(lenY); + FfxFloat16x2 dirY = lE - lA; + dirPY += dirY * w; + lenY = ffxSaturate(abs(dirY) * lenY); + lenY *= lenY; + lenP += lenY * w; +} + +void FsrEasuH( + FFX_PARAMETER_OUT FfxFloat16x3 pix, + FFX_PARAMETER_IN FfxUInt32x2 ip, + FFX_PARAMETER_IN FfxUInt32x4 con0, + FFX_PARAMETER_IN FfxUInt32x4 con1, + FFX_PARAMETER_IN FfxUInt32x4 con2, + FFX_PARAMETER_IN FfxUInt32x4 con3) +{ + FfxFloat32x2 pp = FfxFloat32x2(ip) * ffxAsFloat(con0.xy) + ffxAsFloat(con0.zw); + FfxFloat32x2 fp = floor(pp); + pp -= fp; + FfxFloat16x2 ppp = FfxFloat16x2(pp); + + FfxFloat32x2 p0 = fp * ffxAsFloat(con1.xy) + ffxAsFloat(con1.zw); + FfxFloat32x2 p1 = p0 + ffxAsFloat(con2.xy); + FfxFloat32x2 p2 = p0 + ffxAsFloat(con2.zw); + FfxFloat32x2 p3 = p0 + ffxAsFloat(con3.xy); + FfxFloat16x4 bczzR = FsrEasuRH(p0); + FfxFloat16x4 bczzG = FsrEasuGH(p0); + FfxFloat16x4 bczzB = FsrEasuBH(p0); + FfxFloat16x4 ijfeR = FsrEasuRH(p1); + FfxFloat16x4 ijfeG = FsrEasuGH(p1); + FfxFloat16x4 ijfeB = FsrEasuBH(p1); + FfxFloat16x4 klhgR = FsrEasuRH(p2); + FfxFloat16x4 klhgG = FsrEasuGH(p2); + FfxFloat16x4 klhgB = FsrEasuBH(p2); + FfxFloat16x4 zzonR = FsrEasuRH(p3); + FfxFloat16x4 zzonG = FsrEasuGH(p3); + FfxFloat16x4 zzonB = FsrEasuBH(p3); + + FfxFloat16x4 bczzL = bczzB * FFX_BROADCAST_FLOAT16X4(0.5) + (bczzR * FFX_BROADCAST_FLOAT16X4(0.5) + bczzG); + FfxFloat16x4 ijfeL = ijfeB * FFX_BROADCAST_FLOAT16X4(0.5) + (ijfeR * FFX_BROADCAST_FLOAT16X4(0.5) + ijfeG); + FfxFloat16x4 klhgL = klhgB * FFX_BROADCAST_FLOAT16X4(0.5) + (klhgR * FFX_BROADCAST_FLOAT16X4(0.5) + klhgG); + FfxFloat16x4 zzonL = zzonB * FFX_BROADCAST_FLOAT16X4(0.5) + (zzonR * FFX_BROADCAST_FLOAT16X4(0.5) + zzonG); + FfxFloat16 bL = bczzL.x; + FfxFloat16 cL = bczzL.y; + FfxFloat16 iL = ijfeL.x; + FfxFloat16 jL = ijfeL.y; + FfxFloat16 fL = ijfeL.z; + FfxFloat16 eL = ijfeL.w; + FfxFloat16 kL = klhgL.x; + FfxFloat16 lL = klhgL.y; + FfxFloat16 hL = klhgL.z; + FfxFloat16 gL = klhgL.w; + FfxFloat16 oL = zzonL.z; + FfxFloat16 nL = zzonL.w; + + // This part is different, accumulating 2 taps in parallel. + FfxFloat16x2 dirPX = FFX_BROADCAST_FLOAT16X2(0.0); + FfxFloat16x2 dirPY = FFX_BROADCAST_FLOAT16X2(0.0); + FfxFloat16x2 lenP = FFX_BROADCAST_FLOAT16X2(0.0); + FsrEasuSetH(dirPX, + dirPY, + lenP, + ppp, + FfxBoolean(true), + FfxBoolean(false), + FfxFloat16x2(bL, cL), + FfxFloat16x2(eL, fL), + FfxFloat16x2(fL, gL), + FfxFloat16x2(gL, hL), + FfxFloat16x2(jL, kL)); + FsrEasuSetH(dirPX, + dirPY, + lenP, + ppp, + FfxBoolean(false), + FfxBoolean(true), + FfxFloat16x2(fL, gL), + FfxFloat16x2(iL, jL), + FfxFloat16x2(jL, kL), + FfxFloat16x2(kL, lL), + FfxFloat16x2(nL, oL)); + FfxFloat16x2 dir = FfxFloat16x2(dirPX.r + dirPX.g, dirPY.r + dirPY.g); + FfxFloat16 len = lenP.r + lenP.g; + + FfxFloat16x2 dir2 = dir * dir; + FfxFloat16 dirR = dir2.x + dir2.y; + FfxUInt32 zro = FfxUInt32(dirR < FFX_BROADCAST_FLOAT16(1.0 / 32768.0)); + dirR = ffxApproximateReciprocalSquareRootHalf(dirR); + dirR = (zro > 0) ? FFX_BROADCAST_FLOAT16(1.0) : dirR; + dir.x = (zro > 0) ? FFX_BROADCAST_FLOAT16(1.0) : dir.x; + dir *= FFX_BROADCAST_FLOAT16X2(dirR); + len = len * FFX_BROADCAST_FLOAT16(0.5); + len *= len; + FfxFloat16 stretch = (dir.x * dir.x + dir.y * dir.y) * ffxApproximateReciprocalHalf(max(abs(dir.x), abs(dir.y))); + FfxFloat16x2 len2 = + FfxFloat16x2(FFX_BROADCAST_FLOAT16(1.0) + (stretch - FFX_BROADCAST_FLOAT16(1.0)) * len, FFX_BROADCAST_FLOAT16(1.0) + FFX_BROADCAST_FLOAT16(-0.5) * len); + FfxFloat16 lob = FFX_BROADCAST_FLOAT16(0.5) + FFX_BROADCAST_FLOAT16((1.0 / 4.0 - 0.04) - 0.5) * len; + FfxFloat16 clp = ffxApproximateReciprocalHalf(lob); + + // FP16 is different, using packed trick to do min and max in same operation. + FfxFloat16x2 bothR = + max(max(FfxFloat16x2(-ijfeR.z, ijfeR.z), FfxFloat16x2(-klhgR.w, klhgR.w)), max(FfxFloat16x2(-ijfeR.y, ijfeR.y), FfxFloat16x2(-klhgR.x, klhgR.x))); + FfxFloat16x2 bothG = + max(max(FfxFloat16x2(-ijfeG.z, ijfeG.z), FfxFloat16x2(-klhgG.w, klhgG.w)), max(FfxFloat16x2(-ijfeG.y, ijfeG.y), FfxFloat16x2(-klhgG.x, klhgG.x))); + FfxFloat16x2 bothB = + max(max(FfxFloat16x2(-ijfeB.z, ijfeB.z), FfxFloat16x2(-klhgB.w, klhgB.w)), max(FfxFloat16x2(-ijfeB.y, ijfeB.y), FfxFloat16x2(-klhgB.x, klhgB.x))); + + // This part is different for FP16, working pairs of taps at a time. + FfxFloat16x2 pR = FFX_BROADCAST_FLOAT16X2(0.0); + FfxFloat16x2 pG = FFX_BROADCAST_FLOAT16X2(0.0); + FfxFloat16x2 pB = FFX_BROADCAST_FLOAT16X2(0.0); + FfxFloat16x2 pW = FFX_BROADCAST_FLOAT16X2(0.0); + FsrEasuTapH(pR, pG, pB, pW, FfxFloat16x2(0.0, 1.0) - ppp.xx, FfxFloat16x2(-1.0, -1.0) - ppp.yy, dir, len2, lob, clp, bczzR.xy, bczzG.xy, bczzB.xy); + FsrEasuTapH(pR, pG, pB, pW, FfxFloat16x2(-1.0, 0.0) - ppp.xx, FfxFloat16x2(1.0, 1.0) - ppp.yy, dir, len2, lob, clp, ijfeR.xy, ijfeG.xy, ijfeB.xy); + FsrEasuTapH(pR, pG, pB, pW, FfxFloat16x2(0.0, -1.0) - ppp.xx, FfxFloat16x2(0.0, 0.0) - ppp.yy, dir, len2, lob, clp, ijfeR.zw, ijfeG.zw, ijfeB.zw); + FsrEasuTapH(pR, pG, pB, pW, FfxFloat16x2(1.0, 2.0) - ppp.xx, FfxFloat16x2(1.0, 1.0) - ppp.yy, dir, len2, lob, clp, klhgR.xy, klhgG.xy, klhgB.xy); + FsrEasuTapH(pR, pG, pB, pW, FfxFloat16x2(2.0, 1.0) - ppp.xx, FfxFloat16x2(0.0, 0.0) - ppp.yy, dir, len2, lob, clp, klhgR.zw, klhgG.zw, klhgB.zw); + FsrEasuTapH(pR, pG, pB, pW, FfxFloat16x2(1.0, 0.0) - ppp.xx, FfxFloat16x2(2.0, 2.0) - ppp.yy, dir, len2, lob, clp, zzonR.zw, zzonG.zw, zzonB.zw); + FfxFloat16x3 aC = FfxFloat16x3(pR.x + pR.y, pG.x + pG.y, pB.x + pB.y); + FfxFloat16 aW = pW.x + pW.y; + + // Slightly different for FP16 version due to combined min and max. + pix = min(FfxFloat16x3(bothR.y, bothG.y, bothB.y), max(-FfxFloat16x3(bothR.x, bothG.x, bothB.x), aC * FFX_BROADCAST_FLOAT16X3(ffxReciprocalHalf(aW)))); +} +#endif // #if defined(FFX_GPU) && defined(FFX_HALF) && defined(FFX_FSR_EASU_HALF) + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//_____________________________________________________________/\_______________________________________________________________ +//============================================================================================================================== +// +// FSR - [RCAS] ROBUST CONTRAST ADAPTIVE SHARPENING +// +//------------------------------------------------------------------------------------------------------------------------------ +// CAS uses a simplified mechanism to convert local contrast into a variable amount of sharpness. +// RCAS uses a more exact mechanism, solving for the maximum local sharpness possible before clipping. +// RCAS also has a built in process to limit sharpening of what it detects as possible noise. +// RCAS sharper does not support scaling, as it should be applied after EASU scaling. +// Pass EASU output straight into RCAS, no color conversions necessary. +//------------------------------------------------------------------------------------------------------------------------------ +// RCAS is based on the following logic. +// RCAS uses a 5 tap filter in a cross pattern (same as CAS), +// w n +// w 1 w for taps w m e +// w s +// Where 'w' is the negative lobe weight. +// output = (w*(n+e+w+s)+m)/(4*w+1) +// RCAS solves for 'w' by seeing where the signal might clip out of the {0 to 1} input range, +// 0 == (w*(n+e+w+s)+m)/(4*w+1) -> w = -m/(n+e+w+s) +// 1 == (w*(n+e+w+s)+m)/(4*w+1) -> w = (1-m)/(n+e+w+s-4*1) +// Then chooses the 'w' which results in no clipping, limits 'w', and multiplies by the 'sharp' amount. +// This solution above has issues with MSAA input as the steps along the gradient cause edge detection issues. +// So RCAS uses 4x the maximum and 4x the minimum (depending on equation)in place of the individual taps. +// As well as switching from 'm' to either the minimum or maximum (depending on side), to help in energy conservation. +// This stabilizes RCAS. +// RCAS does a simple highpass which is normalized against the local contrast then shaped, +// 0.25 +// 0.25 -1 0.25 +// 0.25 +// This is used as a noise detection filter, to reduce the effect of RCAS on grain, and focus on real edges. +// +// GLSL example for the required callbacks : +// +// FfxFloat16x4 FsrRcasLoadH(FfxInt16x2 p){return FfxFloat16x4(imageLoad(imgSrc,FfxInt32x2(p)));} +// void FsrRcasInputH(inout FfxFloat16 r,inout FfxFloat16 g,inout FfxFloat16 b) +// { +// //do any simple input color conversions here or leave empty if none needed +// } +// +// FsrRcasCon need to be called from the CPU or GPU to set up constants. +// Including a GPU example here, the 'con' value would be stored out to a constant buffer. +// +// FfxUInt32x4 con; +// FsrRcasCon(con, +// 0.0); // The scale is {0.0 := maximum sharpness, to N>0, where N is the number of stops (halving) of the reduction of sharpness}. +// --------------- +// RCAS sharpening supports a CAS-like pass-through alpha via, +// #define FSR_RCAS_PASSTHROUGH_ALPHA 1 +// RCAS also supports a define to enable a more expensive path to avoid some sharpening of noise. +// Would suggest it is better to apply film grain after RCAS sharpening (and after scaling) instead of using this define, +// #define FSR_RCAS_DENOISE 1 +//============================================================================================================================== +// This is set at the limit of providing unnatural results for sharpening. +#define FSR_RCAS_LIMIT (0.25-(1.0/16.0)) +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//_____________________________________________________________/\_______________________________________________________________ +//============================================================================================================================== +// CONSTANT SETUP +//============================================================================================================================== +// Call to setup required constant values (works on CPU or GPU). + FFX_STATIC void FsrRcasCon(FfxUInt32x4 con, + // The scale is {0.0 := maximum, to N>0, where N is the number of stops (halving) of the reduction of sharpness}. + FfxFloat32 sharpness) + { + // Transform from stops to linear value. + sharpness = exp2(-sharpness); + FfxFloat32x2 hSharp = {sharpness, sharpness}; + con[0] = ffxAsUInt32(sharpness); + con[1] = ffxPackHalf2x16(hSharp); + con[2] = 0; + con[3] = 0; + } + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//_____________________________________________________________/\_______________________________________________________________ +//============================================================================================================================== +// NON-PACKED 32-BIT VERSION +//============================================================================================================================== +#if defined(FFX_GPU)&&defined(FSR_RCAS_F) + // Input callback prototypes that need to be implemented by calling shader + FfxFloat32x4 FsrRcasLoadF(FfxInt32x2 p); + void FsrRcasInputF(inout FfxFloat32 r,inout FfxFloat32 g,inout FfxFloat32 b); +//------------------------------------------------------------------------------------------------------------------------------ + void FsrRcasF(out FfxFloat32 pixR, // Output values, non-vector so port between RcasFilter() and RcasFilterH() is easy. + out FfxFloat32 pixG, + out FfxFloat32 pixB, +#ifdef FSR_RCAS_PASSTHROUGH_ALPHA + out FfxFloat32 pixA, +#endif + FfxUInt32x2 ip, // Integer pixel position in output. + FfxUInt32x4 con) + { // Constant generated by RcasSetup(). + // Algorithm uses minimal 3x3 pixel neighborhood. + // b + // d e f + // h + FfxInt32x2 sp = FfxInt32x2(ip); + FfxFloat32x3 b = FsrRcasLoadF(sp + FfxInt32x2(0, -1)).rgb; + FfxFloat32x3 d = FsrRcasLoadF(sp + FfxInt32x2(-1, 0)).rgb; +#ifdef FSR_RCAS_PASSTHROUGH_ALPHA + FfxFloat32x4 ee = FsrRcasLoadF(sp); + FfxFloat32x3 e = ee.rgb; + pixA = ee.a; +#else + FfxFloat32x3 e = FsrRcasLoadF(sp).rgb; +#endif + FfxFloat32x3 f = FsrRcasLoadF(sp + FfxInt32x2(1, 0)).rgb; + FfxFloat32x3 h = FsrRcasLoadF(sp + FfxInt32x2(0, 1)).rgb; + // Rename (32-bit) or regroup (16-bit). + FfxFloat32 bR = b.r; + FfxFloat32 bG = b.g; + FfxFloat32 bB = b.b; + FfxFloat32 dR = d.r; + FfxFloat32 dG = d.g; + FfxFloat32 dB = d.b; + FfxFloat32 eR = e.r; + FfxFloat32 eG = e.g; + FfxFloat32 eB = e.b; + FfxFloat32 fR = f.r; + FfxFloat32 fG = f.g; + FfxFloat32 fB = f.b; + FfxFloat32 hR = h.r; + FfxFloat32 hG = h.g; + FfxFloat32 hB = h.b; + // Run optional input transform. + FsrRcasInputF(bR, bG, bB); + FsrRcasInputF(dR, dG, dB); + FsrRcasInputF(eR, eG, eB); + FsrRcasInputF(fR, fG, fB); + FsrRcasInputF(hR, hG, hB); + // Luma times 2. + FfxFloat32 bL = bB * FfxFloat32(0.5) + (bR * FfxFloat32(0.5) + bG); + FfxFloat32 dL = dB * FfxFloat32(0.5) + (dR * FfxFloat32(0.5) + dG); + FfxFloat32 eL = eB * FfxFloat32(0.5) + (eR * FfxFloat32(0.5) + eG); + FfxFloat32 fL = fB * FfxFloat32(0.5) + (fR * FfxFloat32(0.5) + fG); + FfxFloat32 hL = hB * FfxFloat32(0.5) + (hR * FfxFloat32(0.5) + hG); + // Noise detection. + FfxFloat32 nz = FfxFloat32(0.25) * bL + FfxFloat32(0.25) * dL + FfxFloat32(0.25) * fL + FfxFloat32(0.25) * hL - eL; + nz = ffxSaturate(abs(nz) * ffxApproximateReciprocalMedium(ffxMax3(ffxMax3(bL, dL, eL), fL, hL) - ffxMin3(ffxMin3(bL, dL, eL), fL, hL))); + nz = FfxFloat32(-0.5) * nz + FfxFloat32(1.0); + // Min and max of ring. + FfxFloat32 mn4R = ffxMin(ffxMin3(bR, dR, fR), hR); + FfxFloat32 mn4G = ffxMin(ffxMin3(bG, dG, fG), hG); + FfxFloat32 mn4B = ffxMin(ffxMin3(bB, dB, fB), hB); + FfxFloat32 mx4R = max(ffxMax3(bR, dR, fR), hR); + FfxFloat32 mx4G = max(ffxMax3(bG, dG, fG), hG); + FfxFloat32 mx4B = max(ffxMax3(bB, dB, fB), hB); + // Immediate constants for peak range. + FfxFloat32x2 peakC = FfxFloat32x2(1.0, -1.0 * 4.0); + // Limiters, these need to be high precision RCPs. + FfxFloat32 hitMinR = mn4R * ffxReciprocal(FfxFloat32(4.0) * mx4R); + FfxFloat32 hitMinG = mn4G * ffxReciprocal(FfxFloat32(4.0) * mx4G); + FfxFloat32 hitMinB = mn4B * ffxReciprocal(FfxFloat32(4.0) * mx4B); + FfxFloat32 hitMaxR = (peakC.x - mx4R) * ffxReciprocal(FfxFloat32(4.0) * mn4R + peakC.y); + FfxFloat32 hitMaxG = (peakC.x - mx4G) * ffxReciprocal(FfxFloat32(4.0) * mn4G + peakC.y); + FfxFloat32 hitMaxB = (peakC.x - mx4B) * ffxReciprocal(FfxFloat32(4.0) * mn4B + peakC.y); + FfxFloat32 lobeR = max(-hitMinR, hitMaxR); + FfxFloat32 lobeG = max(-hitMinG, hitMaxG); + FfxFloat32 lobeB = max(-hitMinB, hitMaxB); + FfxFloat32 lobe = max(FfxFloat32(-FSR_RCAS_LIMIT), ffxMin(ffxMax3(lobeR, lobeG, lobeB), FfxFloat32(0.0))) * ffxAsFloat + (con.x); + // Apply noise removal. +#ifdef FSR_RCAS_DENOISE + lobe *= nz; +#endif + // Resolve, which needs the medium precision rcp approximation to avoid visible tonality changes. + FfxFloat32 rcpL = ffxApproximateReciprocalMedium(FfxFloat32(4.0) * lobe + FfxFloat32(1.0)); + pixR = (lobe * bR + lobe * dR + lobe * hR + lobe * fR + eR) * rcpL; + pixG = (lobe * bG + lobe * dG + lobe * hG + lobe * fG + eG) * rcpL; + pixB = (lobe * bB + lobe * dB + lobe * hB + lobe * fB + eB) * rcpL; + return; + } +#endif +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//_____________________________________________________________/\_______________________________________________________________ +//============================================================================================================================== +// NON-PACKED 16-BIT VERSION +//============================================================================================================================== +#if defined(FFX_GPU) && FFX_HALF == 1 && defined(FSR_RCAS_H) + // Input callback prototypes that need to be implemented by calling shader + FfxFloat16x4 FsrRcasLoadH(FfxInt16x2 p); + void FsrRcasInputH(inout FfxFloat16 r,inout FfxFloat16 g,inout FfxFloat16 b); +//------------------------------------------------------------------------------------------------------------------------------ + void FsrRcasH( + out FfxFloat16 pixR, // Output values, non-vector so port between RcasFilter() and RcasFilterH() is easy. + out FfxFloat16 pixG, + out FfxFloat16 pixB, + #ifdef FSR_RCAS_PASSTHROUGH_ALPHA + out FfxFloat16 pixA, + #endif + FfxUInt32x2 ip, // Integer pixel position in output. + FfxUInt32x4 con){ // Constant generated by RcasSetup(). + // Sharpening algorithm uses minimal 3x3 pixel neighborhood. + // b + // d e f + // h + FfxInt16x2 sp=FfxInt16x2(ip); + FfxFloat16x3 b=FsrRcasLoadH(sp+FfxInt16x2( 0,-1)).rgb; + FfxFloat16x3 d=FsrRcasLoadH(sp+FfxInt16x2(-1, 0)).rgb; + #ifdef FSR_RCAS_PASSTHROUGH_ALPHA + FfxFloat16x4 ee=FsrRcasLoadH(sp); + FfxFloat16x3 e=ee.rgb;pixA=ee.a; + #else + FfxFloat16x3 e=FsrRcasLoadH(sp).rgb; + #endif + FfxFloat16x3 f=FsrRcasLoadH(sp+FfxInt16x2( 1, 0)).rgb; + FfxFloat16x3 h=FsrRcasLoadH(sp+FfxInt16x2( 0, 1)).rgb; + // Rename (32-bit) or regroup (16-bit). + FfxFloat16 bR=b.r; + FfxFloat16 bG=b.g; + FfxFloat16 bB=b.b; + FfxFloat16 dR=d.r; + FfxFloat16 dG=d.g; + FfxFloat16 dB=d.b; + FfxFloat16 eR=e.r; + FfxFloat16 eG=e.g; + FfxFloat16 eB=e.b; + FfxFloat16 fR=f.r; + FfxFloat16 fG=f.g; + FfxFloat16 fB=f.b; + FfxFloat16 hR=h.r; + FfxFloat16 hG=h.g; + FfxFloat16 hB=h.b; + // Run optional input transform. + FsrRcasInputH(bR,bG,bB); + FsrRcasInputH(dR,dG,dB); + FsrRcasInputH(eR,eG,eB); + FsrRcasInputH(fR,fG,fB); + FsrRcasInputH(hR,hG,hB); + // Luma times 2. + FfxFloat16 bL=bB*FFX_BROADCAST_FLOAT16(0.5)+(bR*FFX_BROADCAST_FLOAT16(0.5)+bG); + FfxFloat16 dL=dB*FFX_BROADCAST_FLOAT16(0.5)+(dR*FFX_BROADCAST_FLOAT16(0.5)+dG); + FfxFloat16 eL=eB*FFX_BROADCAST_FLOAT16(0.5)+(eR*FFX_BROADCAST_FLOAT16(0.5)+eG); + FfxFloat16 fL=fB*FFX_BROADCAST_FLOAT16(0.5)+(fR*FFX_BROADCAST_FLOAT16(0.5)+fG); + FfxFloat16 hL=hB*FFX_BROADCAST_FLOAT16(0.5)+(hR*FFX_BROADCAST_FLOAT16(0.5)+hG); + // Noise detection. + FfxFloat16 nz=FFX_BROADCAST_FLOAT16(0.25)*bL+FFX_BROADCAST_FLOAT16(0.25)*dL+FFX_BROADCAST_FLOAT16(0.25)*fL+FFX_BROADCAST_FLOAT16(0.25)*hL-eL; + nz=ffxSaturate(abs(nz)*ffxApproximateReciprocalMediumHalf(ffxMax3Half(ffxMax3Half(bL,dL,eL),fL,hL)-ffxMin3Half(ffxMin3Half(bL,dL,eL),fL,hL))); + nz=FFX_BROADCAST_FLOAT16(-0.5)*nz+FFX_BROADCAST_FLOAT16(1.0); + // Min and max of ring. + FfxFloat16 mn4R=min(ffxMin3Half(bR,dR,fR),hR); + FfxFloat16 mn4G=min(ffxMin3Half(bG,dG,fG),hG); + FfxFloat16 mn4B=min(ffxMin3Half(bB,dB,fB),hB); + FfxFloat16 mx4R=max(ffxMax3Half(bR,dR,fR),hR); + FfxFloat16 mx4G=max(ffxMax3Half(bG,dG,fG),hG); + FfxFloat16 mx4B=max(ffxMax3Half(bB,dB,fB),hB); + // Immediate constants for peak range. + FfxFloat16x2 peakC=FfxFloat16x2(1.0,-1.0*4.0); + // Limiters, these need to be high precision RCPs. + FfxFloat16 hitMinR=mn4R*ffxReciprocalHalf(FFX_BROADCAST_FLOAT16(4.0)*mx4R); + FfxFloat16 hitMinG=mn4G*ffxReciprocalHalf(FFX_BROADCAST_FLOAT16(4.0)*mx4G); + FfxFloat16 hitMinB=mn4B*ffxReciprocalHalf(FFX_BROADCAST_FLOAT16(4.0)*mx4B); + FfxFloat16 hitMaxR=(peakC.x-mx4R)*ffxReciprocalHalf(FFX_BROADCAST_FLOAT16(4.0)*mn4R+peakC.y); + FfxFloat16 hitMaxG=(peakC.x-mx4G)*ffxReciprocalHalf(FFX_BROADCAST_FLOAT16(4.0)*mn4G+peakC.y); + FfxFloat16 hitMaxB=(peakC.x-mx4B)*ffxReciprocalHalf(FFX_BROADCAST_FLOAT16(4.0)*mn4B+peakC.y); + FfxFloat16 lobeR=max(-hitMinR,hitMaxR); + FfxFloat16 lobeG=max(-hitMinG,hitMaxG); + FfxFloat16 lobeB=max(-hitMinB,hitMaxB); + FfxFloat16 lobe=max(FFX_BROADCAST_FLOAT16(-FSR_RCAS_LIMIT),min(ffxMax3Half(lobeR,lobeG,lobeB),FFX_BROADCAST_FLOAT16(0.0)))*FFX_UINT32_TO_FLOAT16X2(con.y).x; + // Apply noise removal. + #ifdef FSR_RCAS_DENOISE + lobe*=nz; + #endif + // Resolve, which needs the medium precision rcp approximation to avoid visible tonality changes. + FfxFloat16 rcpL=ffxApproximateReciprocalMediumHalf(FFX_BROADCAST_FLOAT16(4.0)*lobe+FFX_BROADCAST_FLOAT16(1.0)); + pixR=(lobe*bR+lobe*dR+lobe*hR+lobe*fR+eR)*rcpL; + pixG=(lobe*bG+lobe*dG+lobe*hG+lobe*fG+eG)*rcpL; + pixB=(lobe*bB+lobe*dB+lobe*hB+lobe*fB+eB)*rcpL; +} +#endif +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//_____________________________________________________________/\_______________________________________________________________ +//============================================================================================================================== +// PACKED 16-BIT VERSION +//============================================================================================================================== +#if defined(FFX_GPU)&& FFX_HALF == 1 && defined(FSR_RCAS_HX2) + // Input callback prototypes that need to be implemented by the calling shader + FfxFloat16x4 FsrRcasLoadHx2(FfxInt16x2 p); + void FsrRcasInputHx2(inout FfxFloat16x2 r,inout FfxFloat16x2 g,inout FfxFloat16x2 b); +//------------------------------------------------------------------------------------------------------------------------------ + // Can be used to convert from packed Structures of Arrays to Arrays of Structures for store. + void FsrRcasDepackHx2(out FfxFloat16x4 pix0,out FfxFloat16x4 pix1,FfxFloat16x2 pixR,FfxFloat16x2 pixG,FfxFloat16x2 pixB){ + #ifdef FFX_HLSL + // Invoke a slower path for DX only, since it won't allow uninitialized values. + pix0.a=pix1.a=0.0; + #endif + pix0.rgb=FfxFloat16x3(pixR.x,pixG.x,pixB.x); + pix1.rgb=FfxFloat16x3(pixR.y,pixG.y,pixB.y);} +//------------------------------------------------------------------------------------------------------------------------------ + void FsrRcasHx2( + // Output values are for 2 8x8 tiles in a 16x8 region. + // pix.x = left 8x8 tile + // pix.y = right 8x8 tile + // This enables later processing to easily be packed as well. + out FfxFloat16x2 pixR, + out FfxFloat16x2 pixG, + out FfxFloat16x2 pixB, + #ifdef FSR_RCAS_PASSTHROUGH_ALPHA + out FfxFloat16x2 pixA, + #endif + FfxUInt32x2 ip, // Integer pixel position in output. + FfxUInt32x4 con){ // Constant generated by RcasSetup(). + // No scaling algorithm uses minimal 3x3 pixel neighborhood. + FfxInt16x2 sp0=FfxInt16x2(ip); + FfxFloat16x3 b0=FsrRcasLoadHx2(sp0+FfxInt16x2( 0,-1)).rgb; + FfxFloat16x3 d0=FsrRcasLoadHx2(sp0+FfxInt16x2(-1, 0)).rgb; + #ifdef FSR_RCAS_PASSTHROUGH_ALPHA + FfxFloat16x4 ee0=FsrRcasLoadHx2(sp0); + FfxFloat16x3 e0=ee0.rgb;pixA.r=ee0.a; + #else + FfxFloat16x3 e0=FsrRcasLoadHx2(sp0).rgb; + #endif + FfxFloat16x3 f0=FsrRcasLoadHx2(sp0+FfxInt16x2( 1, 0)).rgb; + FfxFloat16x3 h0=FsrRcasLoadHx2(sp0+FfxInt16x2( 0, 1)).rgb; + FfxInt16x2 sp1=sp0+FfxInt16x2(8,0); + FfxFloat16x3 b1=FsrRcasLoadHx2(sp1+FfxInt16x2( 0,-1)).rgb; + FfxFloat16x3 d1=FsrRcasLoadHx2(sp1+FfxInt16x2(-1, 0)).rgb; + #ifdef FSR_RCAS_PASSTHROUGH_ALPHA + FfxFloat16x4 ee1=FsrRcasLoadHx2(sp1); + FfxFloat16x3 e1=ee1.rgb;pixA.g=ee1.a; + #else + FfxFloat16x3 e1=FsrRcasLoadHx2(sp1).rgb; + #endif + FfxFloat16x3 f1=FsrRcasLoadHx2(sp1+FfxInt16x2( 1, 0)).rgb; + FfxFloat16x3 h1=FsrRcasLoadHx2(sp1+FfxInt16x2( 0, 1)).rgb; + // Arrays of Structures to Structures of Arrays conversion. + FfxFloat16x2 bR=FfxFloat16x2(b0.r,b1.r); + FfxFloat16x2 bG=FfxFloat16x2(b0.g,b1.g); + FfxFloat16x2 bB=FfxFloat16x2(b0.b,b1.b); + FfxFloat16x2 dR=FfxFloat16x2(d0.r,d1.r); + FfxFloat16x2 dG=FfxFloat16x2(d0.g,d1.g); + FfxFloat16x2 dB=FfxFloat16x2(d0.b,d1.b); + FfxFloat16x2 eR=FfxFloat16x2(e0.r,e1.r); + FfxFloat16x2 eG=FfxFloat16x2(e0.g,e1.g); + FfxFloat16x2 eB=FfxFloat16x2(e0.b,e1.b); + FfxFloat16x2 fR=FfxFloat16x2(f0.r,f1.r); + FfxFloat16x2 fG=FfxFloat16x2(f0.g,f1.g); + FfxFloat16x2 fB=FfxFloat16x2(f0.b,f1.b); + FfxFloat16x2 hR=FfxFloat16x2(h0.r,h1.r); + FfxFloat16x2 hG=FfxFloat16x2(h0.g,h1.g); + FfxFloat16x2 hB=FfxFloat16x2(h0.b,h1.b); + // Run optional input transform. + FsrRcasInputHx2(bR,bG,bB); + FsrRcasInputHx2(dR,dG,dB); + FsrRcasInputHx2(eR,eG,eB); + FsrRcasInputHx2(fR,fG,fB); + FsrRcasInputHx2(hR,hG,hB); + // Luma times 2. + FfxFloat16x2 bL=bB*FFX_BROADCAST_FLOAT16X2(0.5)+(bR*FFX_BROADCAST_FLOAT16X2(0.5)+bG); + FfxFloat16x2 dL=dB*FFX_BROADCAST_FLOAT16X2(0.5)+(dR*FFX_BROADCAST_FLOAT16X2(0.5)+dG); + FfxFloat16x2 eL=eB*FFX_BROADCAST_FLOAT16X2(0.5)+(eR*FFX_BROADCAST_FLOAT16X2(0.5)+eG); + FfxFloat16x2 fL=fB*FFX_BROADCAST_FLOAT16X2(0.5)+(fR*FFX_BROADCAST_FLOAT16X2(0.5)+fG); + FfxFloat16x2 hL=hB*FFX_BROADCAST_FLOAT16X2(0.5)+(hR*FFX_BROADCAST_FLOAT16X2(0.5)+hG); + // Noise detection. + FfxFloat16x2 nz=FFX_BROADCAST_FLOAT16X2(0.25)*bL+FFX_BROADCAST_FLOAT16X2(0.25)*dL+FFX_BROADCAST_FLOAT16X2(0.25)*fL+FFX_BROADCAST_FLOAT16X2(0.25)*hL-eL; + nz=ffxSaturate(abs(nz)*ffxApproximateReciprocalMediumHalf(ffxMax3Half(ffxMax3Half(bL,dL,eL),fL,hL)-ffxMin3Half(ffxMin3Half(bL,dL,eL),fL,hL))); + nz=FFX_BROADCAST_FLOAT16X2(-0.5)*nz+FFX_BROADCAST_FLOAT16X2(1.0); + // Min and max of ring. + FfxFloat16x2 mn4R=min(ffxMin3Half(bR,dR,fR),hR); + FfxFloat16x2 mn4G=min(ffxMin3Half(bG,dG,fG),hG); + FfxFloat16x2 mn4B=min(ffxMin3Half(bB,dB,fB),hB); + FfxFloat16x2 mx4R=max(ffxMax3Half(bR,dR,fR),hR); + FfxFloat16x2 mx4G=max(ffxMax3Half(bG,dG,fG),hG); + FfxFloat16x2 mx4B=max(ffxMax3Half(bB,dB,fB),hB); + // Immediate constants for peak range. + FfxFloat16x2 peakC=FfxFloat16x2(1.0,-1.0*4.0); + // Limiters, these need to be high precision RCPs. + FfxFloat16x2 hitMinR=mn4R*ffxReciprocalHalf(FFX_BROADCAST_FLOAT16X2(4.0)*mx4R); + FfxFloat16x2 hitMinG=mn4G*ffxReciprocalHalf(FFX_BROADCAST_FLOAT16X2(4.0)*mx4G); + FfxFloat16x2 hitMinB=mn4B*ffxReciprocalHalf(FFX_BROADCAST_FLOAT16X2(4.0)*mx4B); + FfxFloat16x2 hitMaxR=(peakC.x-mx4R)*ffxReciprocalHalf(FFX_BROADCAST_FLOAT16X2(4.0)*mn4R+peakC.y); + FfxFloat16x2 hitMaxG=(peakC.x-mx4G)*ffxReciprocalHalf(FFX_BROADCAST_FLOAT16X2(4.0)*mn4G+peakC.y); + FfxFloat16x2 hitMaxB=(peakC.x-mx4B)*ffxReciprocalHalf(FFX_BROADCAST_FLOAT16X2(4.0)*mn4B+peakC.y); + FfxFloat16x2 lobeR=max(-hitMinR,hitMaxR); + FfxFloat16x2 lobeG=max(-hitMinG,hitMaxG); + FfxFloat16x2 lobeB=max(-hitMinB,hitMaxB); + FfxFloat16x2 lobe=max(FFX_BROADCAST_FLOAT16X2(-FSR_RCAS_LIMIT),min(ffxMax3Half(lobeR,lobeG,lobeB),FFX_BROADCAST_FLOAT16X2(0.0)))*FFX_BROADCAST_FLOAT16X2(FFX_UINT32_TO_FLOAT16X2(con.y).x); + // Apply noise removal. + #ifdef FSR_RCAS_DENOISE + lobe*=nz; + #endif + // Resolve, which needs the medium precision rcp approximation to avoid visible tonality changes. + FfxFloat16x2 rcpL=ffxApproximateReciprocalMediumHalf(FFX_BROADCAST_FLOAT16X2(4.0)*lobe+FFX_BROADCAST_FLOAT16X2(1.0)); + pixR=(lobe*bR+lobe*dR+lobe*hR+lobe*fR+eR)*rcpL; + pixG=(lobe*bG+lobe*dG+lobe*hG+lobe*fG+eG)*rcpL; + pixB=(lobe*bB+lobe*dB+lobe*hB+lobe*fB+eB)*rcpL;} +#endif +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//_____________________________________________________________/\_______________________________________________________________ +//============================================================================================================================== +// +// FSR - [LFGA] LINEAR FILM GRAIN APPLICATOR +// +//------------------------------------------------------------------------------------------------------------------------------ +// Adding output-resolution film grain after scaling is a good way to mask both rendering and scaling artifacts. +// Suggest using tiled blue noise as film grain input, with peak noise frequency set for a specific look and feel. +// The 'Lfga*()' functions provide a convenient way to introduce grain. +// These functions limit grain based on distance to signal limits. +// This is done so that the grain is temporally energy preserving, and thus won't modify image tonality. +// Grain application should be done in a linear colorspace. +// The grain should be temporally changing, but have a temporal sum per pixel that adds to zero (non-biased). +//------------------------------------------------------------------------------------------------------------------------------ +// Usage, +// FsrLfga*( +// color, // In/out linear colorspace color {0 to 1} ranged. +// grain, // Per pixel grain texture value {-0.5 to 0.5} ranged, input is 3-channel to support colored grain. +// amount); // Amount of grain (0 to 1} ranged. +//------------------------------------------------------------------------------------------------------------------------------ +// Example if grain texture is monochrome: 'FsrLfgaF(color,ffxBroadcast3(grain),amount)' +//============================================================================================================================== +#if defined(FFX_GPU) + // Maximum grain is the minimum distance to the signal limit. + void FsrLfgaF(inout FfxFloat32x3 c, FfxFloat32x3 t, FfxFloat32 a) + { + c += (t * ffxBroadcast3(a)) * ffxMin(ffxBroadcast3(1.0) - c, c); + } +#endif +//============================================================================================================================== +#if defined(FFX_GPU)&& FFX_HALF == 1 + // Half precision version (slower). + void FsrLfgaH(inout FfxFloat16x3 c, FfxFloat16x3 t, FfxFloat16 a) + { + c += (t * FFX_BROADCAST_FLOAT16X3(a)) * min(FFX_BROADCAST_FLOAT16X3(1.0) - c, c); + } + //------------------------------------------------------------------------------------------------------------------------------ + // Packed half precision version (faster). + void FsrLfgaHx2(inout FfxFloat16x2 cR,inout FfxFloat16x2 cG,inout FfxFloat16x2 cB,FfxFloat16x2 tR,FfxFloat16x2 tG,FfxFloat16x2 tB,FfxFloat16 a){ + cR+=(tR*FFX_BROADCAST_FLOAT16X2(a))*min(FFX_BROADCAST_FLOAT16X2(1.0)-cR,cR);cG+=(tG*FFX_BROADCAST_FLOAT16X2(a))*min(FFX_BROADCAST_FLOAT16X2(1.0)-cG,cG);cB+=(tB*FFX_BROADCAST_FLOAT16X2(a))*min(FFX_BROADCAST_FLOAT16X2(1.0)-cB,cB);} +#endif +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//_____________________________________________________________/\_______________________________________________________________ +//============================================================================================================================== +// +// FSR - [SRTM] SIMPLE REVERSIBLE TONE-MAPPER +// +//------------------------------------------------------------------------------------------------------------------------------ +// This provides a way to take linear HDR color {0 to FP16_MAX} and convert it into a temporary {0 to 1} ranged post-tonemapped linear. +// The tonemapper preserves RGB ratio, which helps maintain HDR color bleed during filtering. +//------------------------------------------------------------------------------------------------------------------------------ +// Reversible tonemapper usage, +// FsrSrtm*(color); // {0 to FP16_MAX} converted to {0 to 1}. +// FsrSrtmInv*(color); // {0 to 1} converted into {0 to 32768, output peak safe for FP16}. +//============================================================================================================================== +#if defined(FFX_GPU) + void FsrSrtmF(inout FfxFloat32x3 c) + { + c *= ffxBroadcast3(ffxReciprocal(ffxMax3(c.r, c.g, c.b) + FfxFloat32(1.0))); + } + // The extra max solves the c=1.0 case (which is a /0). + void FsrSrtmInvF(inout FfxFloat32x3 c){c*=ffxBroadcast3(ffxReciprocal(max(FfxFloat32(1.0/32768.0),FfxFloat32(1.0)-ffxMax3(c.r,c.g,c.b))));} +#endif +//============================================================================================================================== +#if defined(FFX_GPU )&& FFX_HALF == 1 + void FsrSrtmH(inout FfxFloat16x3 c) + { + c *= FFX_BROADCAST_FLOAT16X3(ffxReciprocalHalf(ffxMax3Half(c.r, c.g, c.b) + FFX_BROADCAST_FLOAT16(1.0))); + } + void FsrSrtmInvH(inout FfxFloat16x3 c) + { + c *= FFX_BROADCAST_FLOAT16X3(ffxReciprocalHalf(max(FFX_BROADCAST_FLOAT16(1.0 / 32768.0), FFX_BROADCAST_FLOAT16(1.0) - ffxMax3Half(c.r, c.g, c.b)))); + } + //------------------------------------------------------------------------------------------------------------------------------ + void FsrSrtmHx2(inout FfxFloat16x2 cR, inout FfxFloat16x2 cG, inout FfxFloat16x2 cB) + { + FfxFloat16x2 rcp = ffxReciprocalHalf(ffxMax3Half(cR, cG, cB) + FFX_BROADCAST_FLOAT16X2(1.0)); + cR *= rcp; + cG *= rcp; + cB *= rcp; + } + void FsrSrtmInvHx2(inout FfxFloat16x2 cR,inout FfxFloat16x2 cG,inout FfxFloat16x2 cB) + { + FfxFloat16x2 rcp=ffxReciprocalHalf(max(FFX_BROADCAST_FLOAT16X2(1.0/32768.0),FFX_BROADCAST_FLOAT16X2(1.0)-ffxMax3Half(cR,cG,cB))); + cR*=rcp; + cG*=rcp; + cB*=rcp; + } +#endif +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//_____________________________________________________________/\_______________________________________________________________ +//============================================================================================================================== +// +// FSR - [TEPD] TEMPORAL ENERGY PRESERVING DITHER +// +//------------------------------------------------------------------------------------------------------------------------------ +// Temporally energy preserving dithered {0 to 1} linear to gamma 2.0 conversion. +// Gamma 2.0 is used so that the conversion back to linear is just to square the color. +// The conversion comes in 8-bit and 10-bit modes, designed for output to 8-bit UNORM or 10:10:10:2 respectively. +// Given good non-biased temporal blue noise as dither input, +// the output dither will temporally conserve energy. +// This is done by choosing the linear nearest step point instead of perceptual nearest. +// See code below for details. +//------------------------------------------------------------------------------------------------------------------------------ +// DX SPEC RULES FOR FLOAT->UNORM 8-BIT CONVERSION +// =============================================== +// - Output is 'FfxUInt32(floor(saturate(n)*255.0+0.5))'. +// - Thus rounding is to nearest. +// - NaN gets converted to zero. +// - INF is clamped to {0.0 to 1.0}. +//============================================================================================================================== +#if defined(FFX_GPU) + // Hand tuned integer position to dither value, with more values than simple checkerboard. + // Only 32-bit has enough precision for this compddation. + // Output is {0 to <1}. + FfxFloat32 FsrTepdDitF(FfxUInt32x2 p, FfxUInt32 f) + { + FfxFloat32 x = FfxFloat32(p.x + f); + FfxFloat32 y = FfxFloat32(p.y); + // The 1.61803 golden ratio. + FfxFloat32 a = FfxFloat32((1.0 + ffxSqrt(5.0f)) / 2.0); + // Number designed to provide a good visual pattern. + FfxFloat32 b = FfxFloat32(1.0 / 3.69); + x = x * a + (y * b); + return ffxFract(x); + } + //------------------------------------------------------------------------------------------------------------------------------ + // This version is 8-bit gamma 2.0. + // The 'c' input is {0 to 1}. + // Output is {0 to 1} ready for image store. + void FsrTepdC8F(inout FfxFloat32x3 c, FfxFloat32 dit) + { + FfxFloat32x3 n = ffxSqrt(c); + n = floor(n * ffxBroadcast3(255.0)) * ffxBroadcast3(1.0 / 255.0); + FfxFloat32x3 a = n * n; + FfxFloat32x3 b = n + ffxBroadcast3(1.0 / 255.0); + b = b * b; + // Ratio of 'a' to 'b' required to produce 'c'. + // ffxApproximateReciprocal() won't work here (at least for very high dynamic ranges). + // ffxApproximateReciprocalMedium() is an IADD,FMA,MUL. + FfxFloat32x3 r = (c - b) * ffxApproximateReciprocalMedium(a - b); + // Use the ratio as a cutoff to choose 'a' or 'b'. + // ffxIsGreaterThanZero() is a MUL. + c = ffxSaturate(n + ffxIsGreaterThanZero(ffxBroadcast3(dit) - r) * ffxBroadcast3(1.0 / 255.0)); + } + //------------------------------------------------------------------------------------------------------------------------------ + // This version is 10-bit gamma 2.0. + // The 'c' input is {0 to 1}. + // Output is {0 to 1} ready for image store. + void FsrTepdC10F(inout FfxFloat32x3 c, FfxFloat32 dit) + { + FfxFloat32x3 n = ffxSqrt(c); + n = floor(n * ffxBroadcast3(1023.0)) * ffxBroadcast3(1.0 / 1023.0); + FfxFloat32x3 a = n * n; + FfxFloat32x3 b = n + ffxBroadcast3(1.0 / 1023.0); + b = b * b; + FfxFloat32x3 r = (c - b) * ffxApproximateReciprocalMedium(a - b); + c = ffxSaturate(n + ffxIsGreaterThanZero(ffxBroadcast3(dit) - r) * ffxBroadcast3(1.0 / 1023.0)); + } +#endif +//============================================================================================================================== +#if defined(FFX_GPU)&& FFX_HALF == 1 + FfxFloat16 FsrTepdDitH(FfxUInt32x2 p, FfxUInt32 f) + { + FfxFloat32 x = FfxFloat32(p.x + f); + FfxFloat32 y = FfxFloat32(p.y); + FfxFloat32 a = FfxFloat32((1.0 + ffxSqrt(5.0f)) / 2.0); + FfxFloat32 b = FfxFloat32(1.0 / 3.69); + x = x * a + (y * b); + return FfxFloat16(ffxFract(x)); + } + //------------------------------------------------------------------------------------------------------------------------------ + void FsrTepdC8H(inout FfxFloat16x3 c, FfxFloat16 dit) + { + FfxFloat16x3 n = sqrt(c); + n = floor(n * FFX_BROADCAST_FLOAT16X3(255.0)) * FFX_BROADCAST_FLOAT16X3(1.0 / 255.0); + FfxFloat16x3 a = n * n; + FfxFloat16x3 b = n + FFX_BROADCAST_FLOAT16X3(1.0 / 255.0); + b = b * b; + FfxFloat16x3 r = (c - b) * ffxApproximateReciprocalMediumHalf(a - b); + c = ffxSaturate(n + ffxIsGreaterThanZeroHalf(FFX_BROADCAST_FLOAT16X3(dit) - r) * FFX_BROADCAST_FLOAT16X3(1.0 / 255.0)); + } + //------------------------------------------------------------------------------------------------------------------------------ + void FsrTepdC10H(inout FfxFloat16x3 c, FfxFloat16 dit) + { + FfxFloat16x3 n = sqrt(c); + n = floor(n * FFX_BROADCAST_FLOAT16X3(1023.0)) * FFX_BROADCAST_FLOAT16X3(1.0 / 1023.0); + FfxFloat16x3 a = n * n; + FfxFloat16x3 b = n + FFX_BROADCAST_FLOAT16X3(1.0 / 1023.0); + b = b * b; + FfxFloat16x3 r = (c - b) * ffxApproximateReciprocalMediumHalf(a - b); + c = ffxSaturate(n + ffxIsGreaterThanZeroHalf(FFX_BROADCAST_FLOAT16X3(dit) - r) * FFX_BROADCAST_FLOAT16X3(1.0 / 1023.0)); + } + //============================================================================================================================== + // This computes dither for positions 'p' and 'p+{8,0}'. + FfxFloat16x2 FsrTepdDitHx2(FfxUInt32x2 p, FfxUInt32 f) + { + FfxFloat32x2 x; + x.x = FfxFloat32(p.x + f); + x.y = x.x + FfxFloat32(8.0); + FfxFloat32 y = FfxFloat32(p.y); + FfxFloat32 a = FfxFloat32((1.0 + ffxSqrt(5.0f)) / 2.0); + FfxFloat32 b = FfxFloat32(1.0 / 3.69); + x = x * ffxBroadcast2(a) + ffxBroadcast2(y * b); + return FfxFloat16x2(ffxFract(x)); + } + //------------------------------------------------------------------------------------------------------------------------------ + void FsrTepdC8Hx2(inout FfxFloat16x2 cR, inout FfxFloat16x2 cG, inout FfxFloat16x2 cB, FfxFloat16x2 dit) + { + FfxFloat16x2 nR = sqrt(cR); + FfxFloat16x2 nG = sqrt(cG); + FfxFloat16x2 nB = sqrt(cB); + nR = floor(nR * FFX_BROADCAST_FLOAT16X2(255.0)) * FFX_BROADCAST_FLOAT16X2(1.0 / 255.0); + nG = floor(nG * FFX_BROADCAST_FLOAT16X2(255.0)) * FFX_BROADCAST_FLOAT16X2(1.0 / 255.0); + nB = floor(nB * FFX_BROADCAST_FLOAT16X2(255.0)) * FFX_BROADCAST_FLOAT16X2(1.0 / 255.0); + FfxFloat16x2 aR = nR * nR; + FfxFloat16x2 aG = nG * nG; + FfxFloat16x2 aB = nB * nB; + FfxFloat16x2 bR = nR + FFX_BROADCAST_FLOAT16X2(1.0 / 255.0); + bR = bR * bR; + FfxFloat16x2 bG = nG + FFX_BROADCAST_FLOAT16X2(1.0 / 255.0); + bG = bG * bG; + FfxFloat16x2 bB = nB + FFX_BROADCAST_FLOAT16X2(1.0 / 255.0); + bB = bB * bB; + FfxFloat16x2 rR = (cR - bR) * ffxApproximateReciprocalMediumHalf(aR - bR); + FfxFloat16x2 rG = (cG - bG) * ffxApproximateReciprocalMediumHalf(aG - bG); + FfxFloat16x2 rB = (cB - bB) * ffxApproximateReciprocalMediumHalf(aB - bB); + cR = ffxSaturate(nR + ffxIsGreaterThanZeroHalf(dit - rR) * FFX_BROADCAST_FLOAT16X2(1.0 / 255.0)); + cG = ffxSaturate(nG + ffxIsGreaterThanZeroHalf(dit - rG) * FFX_BROADCAST_FLOAT16X2(1.0 / 255.0)); + cB = ffxSaturate(nB + ffxIsGreaterThanZeroHalf(dit - rB) * FFX_BROADCAST_FLOAT16X2(1.0 / 255.0)); + } + //------------------------------------------------------------------------------------------------------------------------------ + void FsrTepdC10Hx2(inout FfxFloat16x2 cR,inout FfxFloat16x2 cG,inout FfxFloat16x2 cB,FfxFloat16x2 dit){ + FfxFloat16x2 nR=sqrt(cR); + FfxFloat16x2 nG=sqrt(cG); + FfxFloat16x2 nB=sqrt(cB); + nR=floor(nR*FFX_BROADCAST_FLOAT16X2(1023.0))*FFX_BROADCAST_FLOAT16X2(1.0/1023.0); + nG=floor(nG*FFX_BROADCAST_FLOAT16X2(1023.0))*FFX_BROADCAST_FLOAT16X2(1.0/1023.0); + nB=floor(nB*FFX_BROADCAST_FLOAT16X2(1023.0))*FFX_BROADCAST_FLOAT16X2(1.0/1023.0); + FfxFloat16x2 aR=nR*nR; + FfxFloat16x2 aG=nG*nG; + FfxFloat16x2 aB=nB*nB; + FfxFloat16x2 bR=nR+FFX_BROADCAST_FLOAT16X2(1.0/1023.0);bR=bR*bR; + FfxFloat16x2 bG=nG+FFX_BROADCAST_FLOAT16X2(1.0/1023.0);bG=bG*bG; + FfxFloat16x2 bB=nB+FFX_BROADCAST_FLOAT16X2(1.0/1023.0);bB=bB*bB; + FfxFloat16x2 rR=(cR-bR)*ffxApproximateReciprocalMediumHalf(aR-bR); + FfxFloat16x2 rG=(cG-bG)*ffxApproximateReciprocalMediumHalf(aG-bG); + FfxFloat16x2 rB=(cB-bB)*ffxApproximateReciprocalMediumHalf(aB-bB); + cR=ffxSaturate(nR+ffxIsGreaterThanZeroHalf(dit-rR)*FFX_BROADCAST_FLOAT16X2(1.0/1023.0)); + cG=ffxSaturate(nG+ffxIsGreaterThanZeroHalf(dit-rG)*FFX_BROADCAST_FLOAT16X2(1.0/1023.0)); + cB = ffxSaturate(nB + ffxIsGreaterThanZeroHalf(dit - rB) * FFX_BROADCAST_FLOAT16X2(1.0 / 1023.0)); +} +#endif diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_callbacks_glsl.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_callbacks_glsl.h new file mode 100644 index 00000000..c1909e63 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_callbacks_glsl.h @@ -0,0 +1,219 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#include "ffx_fsr1_resources.h" + +#if defined(FFX_GPU) +#include "ffx_core.h" + +#ifndef FFX_PREFER_WAVE64 +#define FFX_PREFER_WAVE64 +#endif // #ifndef FFX_PREFER_WAVE64 + +#if defined(FSR1_BIND_CB_FSR1) + layout (set = 0, binding = FSR1_BIND_CB_FSR1, std140) uniform cbFSR1_t + { + FfxUInt32x4 const0; + FfxUInt32x4 const1; + FfxUInt32x4 const2; + FfxUInt32x4 const3; + FfxUInt32x4 sample0; + } cbFSR1; +#endif + +FfxUInt32x4 Const0() +{ + return cbFSR1.const0; +} + +FfxUInt32x4 Const1() +{ + return cbFSR1.const1; +} + +FfxUInt32x4 Const2() +{ + return cbFSR1.const2; +} + +FfxUInt32x4 Const3() +{ + return cbFSR1.const3; +} + +FfxUInt32x4 EASUSample() +{ + return cbFSR1.sample0; +} + +FfxUInt32x4 RCasSample() +{ + return cbFSR1.sample0; +} + +FfxUInt32x4 RCasConfig() +{ + return cbFSR1.const0; +} + +layout (set = 0, binding = 1000) uniform sampler s_LinearClamp; + + +// SRVs +#if defined FSR1_BIND_SRV_INPUT_COLOR + layout (set = 0, binding = FSR1_BIND_SRV_INPUT_COLOR) uniform texture2D r_input_color; +#endif +#if defined FSR1_BIND_SRV_INTERNAL_UPSCALED_COLOR + layout (set = 0, binding = FSR1_BIND_SRV_INTERNAL_UPSCALED_COLOR) uniform texture2D r_internal_upscaled_color; +#endif +#if defined FSR1_BIND_SRV_UPSCALED_OUTPUT + layout (set = 0, binding = FSR1_BIND_SRV_UPSCALED_OUTPUT) uniform texture2D r_upscaled_output; +#endif + +// UAV declarations +#if defined FSR1_BIND_UAV_INPUT_COLOR + layout (set = 0, binding = FSR1_BIND_UAV_INPUT_COLOR, rgba32f) uniform image2D rw_input_color; +#endif +#if defined FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR + layout (set = 0, binding = FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR, rgba32f) uniform image2D rw_internal_upscaled_color; +#endif +#if defined FSR1_BIND_UAV_UPSCALED_OUTPUT + layout (set = 0, binding = FSR1_BIND_UAV_UPSCALED_OUTPUT, rgba32f) uniform image2D rw_upscaled_output; +#endif + +#if FFX_HALF + +#if defined(FSR1_BIND_SRV_INPUT_COLOR) + FfxFloat16x4 GatherEasuRed(FfxFloat32x2 fPxPos) + { + return FfxFloat16x4(textureGather(sampler2D(r_input_color, s_LinearClamp), fPxPos, 0)); + } +#endif // defined(FSR1_BIND_SRV_INPUT_COLOR) + +#if defined(FSR1_BIND_SRV_INPUT_COLOR) + FfxFloat16x4 GatherEasuGreen(FfxFloat32x2 fPxPos) + { + return FfxFloat16x4(textureGather(sampler2D(r_input_color, s_LinearClamp), fPxPos, 1)); + } +#endif // defined(FSR1_BIND_SRV_INPUT_COLOR) + +#if defined(FSR1_BIND_SRV_INPUT_COLOR) + FfxFloat16x4 GatherEasuBlue(FfxFloat32x2 fPxPos) + { + return FfxFloat16x4(textureGather(sampler2D(r_input_color, s_LinearClamp), fPxPos, 2)); + } +#endif // defined(FSR1_BIND_SRV_INPUT_COLOR) + +#if FFX_FSR1_OPTION_APPLY_RCAS + #if defined(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR) + void StoreEASUOutput(FfxUInt32x2 iPxPos, FfxFloat16x3 fColor) + { + imageStore(rw_internal_upscaled_color, FfxInt32x2(iPxPos), FfxFloat32x4(fColor, 1.f)); + } + #endif // #if defined(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR) +#else + #if defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) + void StoreEASUOutput(FfxUInt32x2 iPxPos, FfxFloat16x3 fColor) + { + imageStore(rw_upscaled_output, FfxInt32x2(iPxPos), FfxFloat32x4(fColor, 1.f)); + } + #endif // #if defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) +#endif // #if FFX_FSR1_OPTION_APPLY_RCAS + +#if defined(FSR1_BIND_SRV_INTERNAL_UPSCALED_COLOR) + FfxFloat16x4 LoadRCas_Input(FfxInt16x2 iPxPos) + { + return FfxFloat16x4(texelFetch(r_internal_upscaled_color, FfxInt32x2(iPxPos), 0)); + } +#endif // defined(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR) + +#if defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) + void StoreRCasOutputHx2(FfxInt16x2 iPxPos, FfxFloat16x2 fColorR, FfxFloat16x2 fColorG, FfxFloat16x2 fColorB, FfxFloat16x2 fColorA) + { + imageStore(rw_upscaled_output, FfxInt32x2(iPxPos), FfxFloat32x4(fColorR.x, fColorG.x, fColorB.x, fColorA.x)); + iPxPos.x += FfxInt16(8); + imageStore(rw_upscaled_output, FfxInt32x2(iPxPos), FfxFloat32x4(fColorR.y, fColorG.y, fColorB.y, fColorA.y)); + } + +#endif // defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) + +#else // FFX_HALF + +#if defined(FSR1_BIND_SRV_INPUT_COLOR) + FfxFloat32x4 GatherEasuRed(FfxFloat32x2 fPxPos) + { + return textureGather(sampler2D(r_input_color, s_LinearClamp), fPxPos, 0); + } +#endif // defined(FSR1_BIND_SRV_INPUT_COLOR) + +#if defined(FSR1_BIND_SRV_INPUT_COLOR) + FfxFloat32x4 GatherEasuGreen(FfxFloat32x2 fPxPos) + { + return textureGather(sampler2D(r_input_color, s_LinearClamp), fPxPos, 1); + } +#endif // defined(FSR1_BIND_SRV_INPUT_COLOR) + +#if defined(FSR1_BIND_SRV_INPUT_COLOR) + FfxFloat32x4 GatherEasuBlue(FfxFloat32x2 fPxPos) + { + return textureGather(sampler2D(r_input_color, s_LinearClamp), fPxPos, 2); + } +#endif // defined(FSR1_BIND_SRV_INPUT_COLOR) + +#if FFX_FSR1_OPTION_APPLY_RCAS + #if defined(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR) + void StoreEASUOutput(FfxUInt32x2 iPxPos, FfxFloat32x3 fColor) + { + imageStore(rw_internal_upscaled_color, FfxInt32x2(iPxPos), FfxFloat32x4(fColor, 1.f)); + } + #endif // #if defined(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR) +#else + #if defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) + void StoreEASUOutput(FfxUInt32x2 iPxPos, FfxFloat32x3 fColor) + { + imageStore(rw_upscaled_output, FfxInt32x2(iPxPos), FfxFloat32x4(fColor, 1.f)); + } + #endif // #if defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) +#endif // #if FFX_FSR1_OPTION_APPLY_RCAS + +#if defined(FSR1_BIND_SRV_INTERNAL_UPSCALED_COLOR) + FfxFloat32x4 LoadRCas_Input(FfxInt32x2 iPxPos) + { + return texelFetch(r_internal_upscaled_color, iPxPos, 0); + } +#endif // defined(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR) + +#if defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) + void StoreRCasOutput(FfxInt32x2 iPxPos, FfxFloat32x4 fColor) + { + imageStore(rw_upscaled_output, iPxPos, fColor); + } + + void StoreRCasOutput(FfxInt32x2 iPxPos, FfxFloat32x3 fColor) + { + StoreRCasOutput(iPxPos, FfxFloat32x4(fColor, 1.f)); + } +#endif // defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) + +#endif // FFX_HALF + +#endif // #if defined(FFX_GPU) diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_callbacks_hlsl.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_callbacks_hlsl.h new file mode 100644 index 00000000..03e60933 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_callbacks_hlsl.h @@ -0,0 +1,257 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#include "ffx_fsr1_resources.h" + +#if defined(FFX_GPU) +#ifdef __hlsl_dx_compiler +#pragma dxc diagnostic push +#pragma dxc diagnostic ignored "-Wambig-lit-shift" +#endif //__hlsl_dx_compiler +#include "ffx_core.h" +#ifdef __hlsl_dx_compiler +#pragma dxc diagnostic pop +#endif //__hlsl_dx_compiler + +#ifndef FFX_PREFER_WAVE64 +#define FFX_PREFER_WAVE64 +#endif // #ifndef FFX_PREFER_WAVE64 + +#pragma warning(disable: 3205) // conversion from larger type to smaller + +#define DECLARE_SRV_REGISTER(regIndex) t##regIndex +#define DECLARE_UAV_REGISTER(regIndex) u##regIndex +#define DECLARE_CB_REGISTER(regIndex) b##regIndex +#define FFX_FSR1_DECLARE_SRV(regIndex) register(DECLARE_SRV_REGISTER(regIndex)) +#define FFX_FSR1_DECLARE_UAV(regIndex) register(DECLARE_UAV_REGISTER(regIndex)) +#define FFX_FSR1_DECLARE_CB(regIndex) register(DECLARE_CB_REGISTER(regIndex)) + +#if defined(FSR1_BIND_CB_FSR1) + cbuffer cbFSR1 : FFX_FSR1_DECLARE_CB(FSR1_BIND_CB_FSR1) + { + FfxUInt32x4 const0; + FfxUInt32x4 const1; + FfxUInt32x4 const2; + FfxUInt32x4 const3; + FfxUInt32x4 sample; + #define FFX_FSR1_CONSTANT_BUFFER_1_SIZE 20 // Number of 32-bit values. This must be kept in sync with the cbFSR1 size. + }; +#else + #define const0 0 + #define const1 0 + #define const2 0 + #define const3 0 + #define sample 0 +#endif + +#if defined(FFX_GPU) +#define FFX_FSR1_ROOTSIG_STRINGIFY(p) FFX_FSR1_ROOTSIG_STR(p) +#define FFX_FSR1_ROOTSIG_STR(p) #p +#define FFX_FSR1_ROOTSIG [RootSignature( "DescriptorTable(UAV(u0, numDescriptors = " FFX_FSR1_ROOTSIG_STRINGIFY(FFX_FSR1_RESOURCE_IDENTIFIER_COUNT) ")), " \ + "DescriptorTable(SRV(t0, numDescriptors = " FFX_FSR1_ROOTSIG_STRINGIFY(FFX_FSR1_RESOURCE_IDENTIFIER_COUNT) ")), " \ + "CBV(b0), " \ + "StaticSampler(s0, filter = FILTER_MIN_MAG_MIP_LINEAR, " \ + "addressU = TEXTURE_ADDRESS_CLAMP, " \ + "addressV = TEXTURE_ADDRESS_CLAMP, " \ + "addressW = TEXTURE_ADDRESS_CLAMP, " \ + "comparisonFunc = COMPARISON_NEVER, " \ + "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK)" )] + +#if defined(FFX_FSR1_EMBED_ROOTSIG) +#define FFX_FSR1_EMBED_ROOTSIG_CONTENT FFX_FSR1_ROOTSIG +#else +#define FFX_FSR1_EMBED_ROOTSIG_CONTENT +#endif // #if FFX_FSR1_EMBED_ROOTSIG +#endif // #if defined(FFX_GPU) + + +FfxUInt32x4 Const0() +{ + return const0; +} + +FfxUInt32x4 Const1() +{ + return const1; +} + +FfxUInt32x4 Const2() +{ + return const2; +} + +FfxUInt32x4 Const3() +{ + return const3; +} + +FfxUInt32x4 EASUSample() +{ + return sample; +} + +FfxUInt32x4 RCasSample() +{ + return sample; +} + +FfxUInt32x4 RCasConfig() +{ + return const0; +} + +SamplerState s_LinearClamp : register(s0); + + // SRVs + #if defined FSR1_BIND_SRV_INPUT_COLOR + Texture2D r_input_color : FFX_FSR1_DECLARE_SRV(FSR1_BIND_SRV_INPUT_COLOR); + #endif + #if defined FSR1_BIND_SRV_INTERNAL_UPSCALED_COLOR + Texture2D r_internal_upscaled_color : FFX_FSR1_DECLARE_SRV(FSR1_BIND_SRV_INTERNAL_UPSCALED_COLOR); + #endif + #if defined FSR1_BIND_SRV_UPSCALED_OUTPUT + Texture2D r_upscaled_output : FFX_FSR1_DECLARE_SRV(FSR1_BIND_SRV_UPSCALED_OUTPUT); + #endif + + // UAV declarations + #if defined FSR1_BIND_UAV_INPUT_COLOR + RWTexture2D rw_input_color : FFX_FSR1_DECLARE_UAV(FSR1_BIND_UAV_INPUT_COLOR); + #endif + #if defined FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR + RWTexture2D rw_internal_upscaled_color : FFX_FSR1_DECLARE_UAV(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR); + #endif + #if defined FSR1_BIND_UAV_UPSCALED_OUTPUT + RWTexture2D rw_upscaled_output : FFX_FSR1_DECLARE_UAV(FSR1_BIND_UAV_UPSCALED_OUTPUT); + #endif + +#if FFX_HALF + +#if defined(FSR1_BIND_SRV_INPUT_COLOR) + FfxFloat16x4 GatherEasuRed(FfxFloat32x2 fPxPos) + { + return (FfxFloat16x4)r_input_color.GatherRed(s_LinearClamp, fPxPos, FfxInt32x2(0,0)); + } +#endif // defined(FSR1_BIND_SRV_INPUT_COLOR) + +#if defined(FSR1_BIND_SRV_INPUT_COLOR) + FfxFloat16x4 GatherEasuGreen(FfxFloat32x2 fPxPos) + { + return (FfxFloat16x4)r_input_color.GatherGreen(s_LinearClamp, fPxPos, FfxInt32x2(0, 0)); + } +#endif // defined(FSR1_BIND_SRV_INPUT_COLOR) + +#if defined(FSR1_BIND_SRV_INPUT_COLOR) + FfxFloat16x4 GatherEasuBlue(FfxFloat32x2 fPxPos) + { + return (FfxFloat16x4)r_input_color.GatherBlue(s_LinearClamp, fPxPos, FfxInt32x2(0, 0)); + } +#endif // defined(FSR1_BIND_SRV_INPUT_COLOR) + +#if FFX_FSR1_OPTION_APPLY_RCAS + #if defined(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR) + void StoreEASUOutput(FfxUInt32x2 iPxPos, FfxFloat16x3 fColor) + { + rw_internal_upscaled_color[iPxPos] = FfxFloat32x4(fColor, 1.f); + } + #endif // #if defined(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR) +#else + #if defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) + void StoreEASUOutput(FfxUInt32x2 iPxPos, FfxFloat16x3 fColor) + { + rw_upscaled_output[iPxPos] = FfxFloat32x4(fColor, 1.f); + } + #endif // #if defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) +#endif // #if FFX_FSR1_OPTION_APPLY_RCAS + +#if defined(FSR1_BIND_SRV_INTERNAL_UPSCALED_COLOR) + FfxFloat16x4 LoadRCas_Input(FfxInt16x2 iPxPos) + { + return (FfxFloat16x4)r_internal_upscaled_color[iPxPos]; + } +#endif // defined(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR) + +#if defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) + void StoreRCasOutputHx2(FfxInt16x2 iPxPos, FfxFloat16x2 fColorR, FfxFloat16x2 fColorG, FfxFloat16x2 fColorB, FfxFloat16x2 fColorA) + { + rw_upscaled_output[iPxPos] = FfxFloat32x4(fColorR.x, fColorG.x, fColorB.x, fColorA.x); + iPxPos.x += 8; + rw_upscaled_output[iPxPos] = FfxFloat32x4(fColorR.y, fColorG.y, fColorB.y, fColorA.y); + } +#endif // defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) + +#else // FFX_HALF + +#if defined(FSR1_BIND_SRV_INPUT_COLOR) + FfxFloat32x4 GatherEasuRed(FfxFloat32x2 fPxPos) + { + return r_input_color.GatherRed(s_LinearClamp, fPxPos, FfxInt32x2(0, 0)); + } +#endif // defined(FSR1_BIND_SRV_INPUT_COLOR) + +#if defined(FSR1_BIND_SRV_INPUT_COLOR) + FfxFloat32x4 GatherEasuGreen(FfxFloat32x2 fPxPos) + { + return r_input_color.GatherGreen(s_LinearClamp, fPxPos, FfxInt32x2(0, 0)); + } +#endif // defined(FSR1_BIND_SRV_INPUT_COLOR) + +#if defined(FSR1_BIND_SRV_INPUT_COLOR) + FfxFloat32x4 GatherEasuBlue(FfxFloat32x2 fPxPos) + { + return r_input_color.GatherBlue(s_LinearClamp, fPxPos, FfxInt32x2(0, 0)); + } +#endif // defined(FSR1_BIND_SRV_INPUT_COLOR) + + +#if FFX_FSR1_OPTION_APPLY_RCAS + #if defined(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR) + void StoreEASUOutput(FfxUInt32x2 iPxPos, FfxFloat32x3 fColor) + { + rw_internal_upscaled_color[iPxPos] = FfxFloat32x4(fColor, 1.f); + } + #endif // #if defined(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR) +#else + #if defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) + void StoreEASUOutput(FfxUInt32x2 iPxPos, FfxFloat32x3 fColor) + { + rw_upscaled_output[iPxPos] = FfxFloat32x4(fColor, 1.f); + } + #endif // #if defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) +#endif // #if FFX_FSR1_OPTION_APPLY_RCAS + +#if defined(FSR1_BIND_SRV_INTERNAL_UPSCALED_COLOR) + FfxFloat32x4 LoadRCas_Input(FfxInt32x2 iPxPos) + { + return r_internal_upscaled_color[iPxPos]; + } +#endif // defined(FSR1_BIND_UAV_INTERNAL_UPSCALED_COLOR) + +#if defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) + void StoreRCasOutput(FfxInt32x2 iPxPos, FfxFloat32x4 fColor) + { + rw_upscaled_output[iPxPos] = fColor; + } +#endif // defined(FSR1_BIND_UAV_UPSCALED_OUTPUT) + +#endif // FFX_HALF + +#endif // #if defined(FFX_GPU) diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_easu.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_easu.h new file mode 100644 index 00000000..255833f3 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_easu.h @@ -0,0 +1,98 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define GROUP_SIZE 8 +#define FSR_RCAS_DENOISE 1 + +#include "ffx_core.h" + +#if FFX_HALF + + #define FFX_FSR_EASU_HALF 1 + FfxFloat16x4 FsrEasuRH(FfxFloat32x2 p) { return GatherEasuRed(p); } + FfxFloat16x4 FsrEasuGH(FfxFloat32x2 p) { return GatherEasuGreen(p); } + FfxFloat16x4 FsrEasuBH(FfxFloat32x2 p) { return GatherEasuBlue(p); } + +#else + + #define FFX_FSR_EASU_FLOAT 1 + FfxFloat32x4 FsrEasuRF(FfxFloat32x2 p) { return GatherEasuRed(p); } + FfxFloat32x4 FsrEasuGF(FfxFloat32x2 p) { return GatherEasuGreen(p); } + FfxFloat32x4 FsrEasuBF(FfxFloat32x2 p) { return GatherEasuBlue(p); } + +#endif // FFX_HALF + +#if FFX_FSR1_OPTION_RCAS_PASSTHROUGH_ALPHA + #define FSR_RCAS_PASSTHROUGH_ALPHA +#endif // FFX_FSR1_OPTION_RCAS_PASSTHROUGH_ALPHA + +#include "fsr1/ffx_fsr1.h" + +void CurrFilter(FfxUInt32x2 pos) +{ +#if FFX_HALF + + FfxFloat16x3 c; + FsrEasuH(c, pos, Const0(), Const1(), Const2(), Const3()); + if (EASUSample().x == 1) + { + c *= c; + } + +#if FFX_FSR1_OPTION_SRGB_CONVERSIONS + // Apply gamma if this is an sRGB format (auto-degamma'd on sampler read) + c = pow(c, FfxFloat16x3(1.0 / 2.2, 1.0 / 2.2, 1.0 / 2.2)); +#endif // FFX_FSR1_OPTION_SRGB_CONVERSIONS + + StoreEASUOutput(pos, c); + +#else + + FfxFloat32x3 c; + ffxFsrEasuFloat(c, pos, Const0(), Const1(), Const2(), Const3()); + if (EASUSample().x == 1) + { + c *= c; + } + +#if FFX_FSR1_OPTION_SRGB_CONVERSIONS + // Apply gamma if this is an sRGB format (auto-degamma'd on sampler read) + c = pow(c, FfxFloat32x3(1.f / 2.2f, 1.f / 2.2f, 1.f / 2.2f)); +#endif // FFX_FSR1_OPTION_SRGB_CONVERSIONS + + StoreEASUOutput(pos, c); + +#endif // FFX_HALF +} + +void EASU(FfxUInt32x3 LocalThreadId, FfxUInt32x3 WorkGroupId, FfxUInt32x3 Dtid) +{ + // Do remapping of local xy in workgroup for a more PS-like swizzle pattern. + FfxUInt32x2 gxy = ffxRemapForQuad(LocalThreadId.x) + FfxUInt32x2(WorkGroupId.x << 4u, WorkGroupId.y << 4u); + CurrFilter(gxy); + gxy.x += 8u; + CurrFilter(gxy); + gxy.y += 8u; + CurrFilter(gxy); + gxy.x -= 8u; + CurrFilter(gxy); +} diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_rcas.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_rcas.h new file mode 100644 index 00000000..2c26606b --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_rcas.h @@ -0,0 +1,116 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define GROUP_SIZE 8 +#define FSR_RCAS_DENOISE 1 + +#include "ffx_core.h" + +#if FFX_HALF + #define FSR_RCAS_HX2 1 + FfxFloat16x4 FsrRcasLoadHx2(FfxInt16x2 p) + { + return LoadRCas_Input(p); + } + void FsrRcasInputHx2(inout FfxFloat16x2 r,inout FfxFloat16x2 g,inout FfxFloat16x2 b) {} +#else + #define FSR_RCAS_F 1 + FfxFloat32x4 FsrRcasLoadF(FfxInt32x2 p) + { + return LoadRCas_Input(p); + } + void FsrRcasInputF(inout FfxFloat32 r, inout FfxFloat32 g, inout FfxFloat32 b) {} +#endif // FFX_HALF + +#if FFX_FSR1_OPTION_RCAS_PASSTHROUGH_ALPHA + #define FSR_RCAS_PASSTHROUGH_ALPHA +#endif // FFX_FSR1_OPTION_RCAS_PASSTHROUGH_ALPHA + +#include "fsr1/ffx_fsr1.h" + +void CurrFilter(FFX_MIN16_U2 pos) +{ +#if FFX_HALF + +#if FFX_FSR1_OPTION_RCAS_PASSTHROUGH_ALPHA + FfxFloat16x2 cr, cg, cb, ca; + FsrRcasHx2(cr, cg, cb, ca, pos, RCasConfig()); +#else + FfxFloat16x2 cr, cg, cb; + FsrRcasHx2(cr, cg, cb, pos, RCasConfig()); +#endif // FFX_FSR1_OPTION_RCAS_PASSTHROUGH_ALPHA + + if (RCasSample().x == 1) + { + cr *= cr; + cg *= cg; + cb *= cb; + } + +#if FFX_FSR1_OPTION_RCAS_PASSTHROUGH_ALPHA + StoreRCasOutputHx2(FfxInt16x2(pos), cr, cg, cb, ca); +#else + StoreRCasOutputHx2(FfxInt16x2(pos), cr, cg, cb, FfxFloat16x2(1.0, 1.0)); +#endif + +#else + +#if FFX_FSR1_OPTION_RCAS_PASSTHROUGH_ALPHA + FfxFloat32x4 c; + FsrRcasF(c.r, c.g, c.b, c.a, pos, RCasConfig()); +#else + FfxFloat32x3 c; + FsrRcasF(c.r, c.g, c.b, pos, RCasConfig()); +#endif // FFX_FSR1_OPTION_RCAS_PASSTHROUGH_ALPHA + if (RCasSample().x == 1) + { + c *= c; + } + +#if FFX_FSR1_OPTION_RCAS_PASSTHROUGH_ALPHA + StoreRCasOutput(FfxInt32x2(pos), c); +#else + StoreRCasOutput(FfxInt32x2(pos), FfxFloat32x4(c, 1.0)); +#endif + +#endif +} + +void RCAS(FfxUInt32x3 LocalThreadId, FfxUInt32x3 WorkGroupId, FfxUInt32x3 Dtid) +{ + // Do remapping of local xy in workgroup for a more PS-like swizzle pattern. + FfxUInt32x2 gxy = ffxRemapForQuad(LocalThreadId.x) + FfxUInt32x2(WorkGroupId.x << 4u, WorkGroupId.y << 4u); +#if FFX_HALF + // packed version process left and right 8x8 tile, in total 16x8 region + CurrFilter(FFX_MIN16_U2(gxy)); + gxy.y += 8u; + CurrFilter(FFX_MIN16_U2(gxy)); +#else + CurrFilter(FFX_MIN16_U2(gxy)); + gxy.x += 8u; + CurrFilter(FFX_MIN16_U2(gxy)); + gxy.y += 8u; + CurrFilter(FFX_MIN16_U2(gxy)); + gxy.x -= 8u; + CurrFilter(FFX_MIN16_U2(gxy)); +#endif +} diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_resources.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_resources.h new file mode 100644 index 00000000..eb74d743 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1_resources.h @@ -0,0 +1,38 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FSR1_RESOURCES_H +#define FFX_FSR1_RESOURCES_H + +#if defined(FFX_CPU) || defined(FFX_GPU) +#define FFX_FSR1_RESOURCE_IDENTIFIER_NULL 0 +#define FFX_FSR1_RESOURCE_IDENTIFIER_INPUT_COLOR 1 +#define FFX_FSR1_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR 2 +#define FFX_FSR1_RESOURCE_IDENTIFIER_UPSCALED_OUTPUT 3 + +#define FFX_FSR1_RESOURCE_IDENTIFIER_COUNT 4 + +#define FFX_FSR1_CONSTANTBUFFER_IDENTIFIER_FSR1 0 + +#endif // #if defined(FFX_CPU) || defined(FFX_GPU) + +#endif //!defined( FFX_FSR1_RESOURCES_H ) diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_accumulate.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_accumulate.h new file mode 100644 index 00000000..a8c6daa0 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_accumulate.h @@ -0,0 +1,172 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +void Accumulate(const AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data) +{ + // Avoid invalid values when accumulation and upsampled weight is 0 + data.fHistoryWeight *= FfxFloat32(data.fHistoryWeight > FSR3UPSCALER_FP16_MIN); + data.fHistoryWeight = ffxMax(FSR3UPSCALER_EPSILON, data.fHistoryWeight + data.fUpsampledWeight); + +#if FFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT + //YCoCg -> RGB -> Tonemap -> YCoCg (Use RGB tonemapper to avoid color desaturation) + data.fUpsampledColor = RGBToYCoCg(Tonemap(YCoCgToRGB(data.fUpsampledColor))); + data.fHistoryColor = RGBToYCoCg(Tonemap(YCoCgToRGB(data.fHistoryColor))); +#endif + + const FfxFloat32 fAlpha = ffxSaturate(data.fUpsampledWeight / data.fHistoryWeight); + data.fHistoryColor = ffxLerp(data.fHistoryColor, data.fUpsampledColor, fAlpha); + data.fHistoryColor = YCoCgToRGB(data.fHistoryColor); + +#if FFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT + data.fHistoryColor = InverseTonemap(data.fHistoryColor); +#endif +} + +void RectifyHistory( + const AccumulationPassCommonParams params, + FFX_PARAMETER_INOUT AccumulationPassData data +) +{ + const FfxFloat32 f4kVelocityFactor = ffxSaturate(params.f4KVelocity / 20.0f); + const FfxFloat32 fDistanceFactor = ffxSaturate(0.75f - params.fFarthestDepthInMeters / 20.0f); + const FfxFloat32 fAccumulationFactor = 1.0f - params.fAccumulation; + const FfxFloat32 fReactiveFactor = ffxPow(params.fReactiveMask, 1.0f / 2.0f); + const FfxFloat32 fShadingChangeFactor = params.fShadingChange; + const FfxFloat32 fBoxScaleT = ffxMax(f4kVelocityFactor, ffxMax(fDistanceFactor, ffxMax(fAccumulationFactor, ffxMax(fReactiveFactor, fShadingChangeFactor)))); + + const FfxFloat32 fBoxScale = ffxLerp(3.0f, 1.0f, fBoxScaleT); + const FfxFloat32x3 fScaledBoxVec = data.clippingBox.boxVec * FfxFloat32x3(1.7f, 1.0f, 1.0f) * fBoxScale; + + const FfxFloat32x3 fClampedScaledBoxVec = ffxMax(fScaledBoxVec, FfxFloat32x3(1.193e-7f, 1.193e-7f, 1.193e-7f)); + const FfxFloat32x3 fTransformedHistoryColor = (data.fHistoryColor - data.clippingBox.boxCenter) / fClampedScaledBoxVec; + + if (length(fTransformedHistoryColor)>1.f) { + const FfxFloat32x3 fClampedHistoryColor = normalize(fTransformedHistoryColor); + const FfxFloat32x3 fFinalClampedHistoryColor = (fClampedHistoryColor * fScaledBoxVec) + data.clippingBox.boxCenter; + + // Scale history color using rectification info, also using accumulation mask to avoid potential invalid color protection + const FfxFloat32 fHistoryContribution = ffxMax(params.fLumaInstabilityFactor, data.fLockContributionThisFrame) * params.fAccumulation * (1 - params.fDisocclusion); + data.fHistoryColor = ffxLerp(fFinalClampedHistoryColor, data.fHistoryColor, ffxSaturate(fHistoryContribution)); + } +} + +void UpdateLockStatus(AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data) +{ + data.fLock *= FfxFloat32(params.bIsNewSample == false); + + const FfxFloat32 fLifetimeDecreaseFactor = ffxMax(ffxSaturate(params.fShadingChange), ffxMax(params.fReactiveMask, params.fDisocclusion)); + data.fLock = ffxMax(0.0f, data.fLock - fLifetimeDecreaseFactor * fLockMax); + + // Compute this frame lock contribution + data.fLockContributionThisFrame = ffxSaturate(ffxSaturate(data.fLock - fLockThreshold) * (fLockMax - fLockThreshold)); + + const FfxFloat32 fNewLockIntensity = LoadRwNewLocks(params.iPxHrPos) * (1.0f - ffxMax(params.fShadingChange * 0, params.fReactiveMask)); + data.fLock = ffxMax(0.0f, ffxMin(data.fLock + fNewLockIntensity, fLockMax)); + + // Preparing for next frame + const FfxFloat32 fLifetimeDecrease = (0.1f / JitterSequenceLength()) * (1.0f - fLifetimeDecreaseFactor); + data.fLock = ffxMax(0.0f, data.fLock - fLifetimeDecrease); + + // we expect similar motion for next frame + // kill lock if that location is outside screen, avoid locks to be clamped to screen borders + const FfxFloat32x2 fEstimatedUvNextFrame = params.fHrUv - params.fMotionVector; + data.fLock *= FfxFloat32(IsUvInside(fEstimatedUvNextFrame) == true); +} + +void ComputeBaseAccumulationWeight(const AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data) +{ + FfxFloat32 fBaseAccumulation = params.fAccumulation; + + fBaseAccumulation = ffxMin(fBaseAccumulation, ffxLerp(fBaseAccumulation, 0.15f, ffxSaturate(ffxMax(0.0f, (params.f4KVelocity * VelocityFactor()) / 0.5f)))); + + data.fHistoryWeight = fBaseAccumulation; +} + +void InitPassData(FfxInt32x2 iPxHrPos, FFX_PARAMETER_INOUT AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data) +{ + // Init constant params + params.iPxHrPos = iPxHrPos; + const FfxFloat32x2 fHrUv = (iPxHrPos + 0.5f) / UpscaleSize(); + params.fHrUv = fHrUv; + params.fLrUvJittered = fHrUv + Jitter() / RenderSize(); + params.fLrUv_HwSampler = ClampUv(params.fLrUvJittered, RenderSize(), MaxRenderSize()); + + params.fMotionVector = GetMotionVector(iPxHrPos, fHrUv); + params.f4KVelocity = Get4KVelocity(params.fMotionVector); + + ComputeReprojectedUVs(params); + + const FfxFloat32x2 fLumaInstabilityUv_HW = ClampUv(fHrUv, RenderSize(), MaxRenderSize()); + params.fLumaInstabilityFactor = SampleLumaInstability(fLumaInstabilityUv_HW); + + const FfxFloat32x2 fFarthestDepthUv = ClampUv(params.fLrUvJittered, RenderSize() / 2, GetFarthestDepthMip1ResourceDimensions()); + params.fFarthestDepthInMeters = SampleFarthestDepthMip1(fFarthestDepthUv); + params.bIsNewSample = (params.bIsExistingSample == false || 0 == FrameIndex()); + + const FfxFloat32x4 fDilatedReactiveMasks = SampleDilatedReactiveMasks(params.fLrUv_HwSampler); + params.fReactiveMask = ffxSaturate(fDilatedReactiveMasks[REACTIVE]); + params.fDisocclusion = ffxSaturate(fDilatedReactiveMasks[DISOCCLUSION]); + params.fShadingChange = ffxSaturate(fDilatedReactiveMasks[SHADING_CHANGE]); + params.fAccumulation = ffxSaturate(fDilatedReactiveMasks[ACCUMULAION]); + params.fAccumulation *= FfxFloat32(round(params.fAccumulation * 100.0f) > 1.0f); + + // Init variable data + data.fUpsampledColor = FfxFloat32x3(0.0f, 0.0f, 0.0f); + data.fHistoryColor = FfxFloat32x3(0.0f, 0.0f, 0.0f); + data.fHistoryWeight = 1.0f; + data.fUpsampledWeight = 0.0f; + data.fLock = 0.0f; + data.fLockContributionThisFrame = 0.0f; +} + +void Accumulate(FfxInt32x2 iPxHrPos) +{ + AccumulationPassCommonParams params; + AccumulationPassData data; + InitPassData(iPxHrPos, params, data); + + if (params.bIsExistingSample && !params.bIsNewSample) { + ReprojectHistoryColor(params, data); + } + + UpdateLockStatus(params, data); + + ComputeBaseAccumulationWeight(params, data); + + ComputeUpsampledColorAndWeight(params, data); + + RectifyHistory(params, data); + + Accumulate(params, data); + + data.fHistoryColor /= Exposure(); + + data.fHistoryColor = ffxMax(data.fHistoryColor, FfxFloat32x3(0.0f, 0.0f, 0.0f)); + + StoreInternalColorAndWeight(iPxHrPos, FfxFloat32x4(data.fHistoryColor, data.fLock)); + + // Output final color when RCAS is disabled +#if FFX_FSR3UPSCALER_OPTION_APPLY_SHARPENING == 0 + StoreUpscaledOutput(iPxHrPos, data.fHistoryColor); +#endif + StoreNewLocks(iPxHrPos, 0); +} diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h new file mode 100644 index 00000000..95fe105a --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h @@ -0,0 +1,905 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#include "ffx_fsr3upscaler_resources.h" + +#if defined(FFX_GPU) +#include "ffx_core.h" +#endif // #if defined(FFX_GPU) + +#if defined(FFX_GPU) +#ifndef FFX_PREFER_WAVE64 +#define FFX_PREFER_WAVE64 +#endif // FFX_PREFER_WAVE64 + +#if defined(FSR3UPSCALER_BIND_CB_FSR3UPSCALER) + layout (set = 0, binding = FSR3UPSCALER_BIND_CB_FSR3UPSCALER, std140) uniform cbFSR3UPSCALER_t + { + FfxInt32x2 iRenderSize; + FfxInt32x2 iPreviousFrameRenderSize; + + FfxInt32x2 iUpscaleSize; + FfxInt32x2 iPreviousFrameUpscaleSize; + + FfxInt32x2 iMaxRenderSize; + FfxInt32x2 iMaxUpscaleSize; + + FfxFloat32x4 fDeviceToViewDepth; + + FfxFloat32x2 fJitter; + FfxFloat32x2 fPreviousFrameJitter; + + FfxFloat32x2 fMotionVectorScale; + FfxFloat32x2 fDownscaleFactor; + + FfxFloat32x2 fMotionVectorJitterCancellation; + FfxFloat32 fTanHalfFOV; + FfxFloat32 fJitterSequenceLength; + + FfxFloat32 fDeltaTime; + FfxFloat32 fDeltaPreExposure; + FfxFloat32 fViewSpaceToMetersFactor; + FfxFloat32 fFrameIndex; + + FfxFloat32 fVelocityFactor; + FfxFloat32 fReactivenessScale; + FfxFloat32 fShadingChangeScale; + FfxFloat32 fAccumulationAddedPerFrame; + FfxFloat32 fMinDisocclusionAccumulation; + } cbFSR3Upscaler; + + +FfxInt32x2 RenderSize() +{ + return cbFSR3Upscaler.iRenderSize; +} + +FfxInt32x2 PreviousFrameRenderSize() +{ + return cbFSR3Upscaler.iPreviousFrameRenderSize; +} + +FfxInt32x2 MaxRenderSize() +{ + return cbFSR3Upscaler.iMaxRenderSize; +} + +FfxInt32x2 UpscaleSize() +{ + return cbFSR3Upscaler.iUpscaleSize; +} + +FfxInt32x2 PreviousFrameUpscaleSize() +{ + return cbFSR3Upscaler.iPreviousFrameUpscaleSize; +} + +FfxInt32x2 MaxUpscaleSize() +{ + return cbFSR3Upscaler.iMaxUpscaleSize; +} + +FfxFloat32x2 Jitter() +{ + return cbFSR3Upscaler.fJitter; +} + +FfxFloat32x2 PreviousFrameJitter() +{ + return cbFSR3Upscaler.fPreviousFrameJitter; +} + +FfxFloat32x4 DeviceToViewSpaceTransformFactors() +{ + return cbFSR3Upscaler.fDeviceToViewDepth; +} + +FfxFloat32x2 MotionVectorScale() +{ + return cbFSR3Upscaler.fMotionVectorScale; +} + +FfxFloat32x2 DownscaleFactor() +{ + return cbFSR3Upscaler.fDownscaleFactor; +} + +FfxFloat32x2 MotionVectorJitterCancellation() +{ + return cbFSR3Upscaler.fMotionVectorJitterCancellation; +} + +FfxFloat32 TanHalfFoV() +{ + return cbFSR3Upscaler.fTanHalfFOV; +} + +FfxFloat32 JitterSequenceLength() +{ + return cbFSR3Upscaler.fJitterSequenceLength; +} + +FfxFloat32 DeltaTime() +{ + return cbFSR3Upscaler.fDeltaTime; +} + +FfxFloat32 DeltaPreExposure() +{ + return cbFSR3Upscaler.fDeltaPreExposure; +} + +FfxFloat32 ViewSpaceToMetersFactor() +{ + return cbFSR3Upscaler.fViewSpaceToMetersFactor; +} + +FfxFloat32 FrameIndex() +{ + return cbFSR3Upscaler.fFrameIndex; +} + +FfxFloat32 VelocityFactor() +{ + return cbFSR3Upscaler.fVelocityFactor; +} + +FfxFloat32 AccumulationAddedPerFrame() +{ + return cbFSR3Upscaler.fAccumulationAddedPerFrame; +} + +FfxFloat32 MinDisocclusionAccumulation() +{ + return cbFSR3Upscaler.fMinDisocclusionAccumulation; +} + +#endif // #if defined(FSR3UPSCALER_BIND_CB_FSR3UPSCALER) + + +#if defined(FSR3UPSCALER_BIND_CB_AUTOREACTIVE) +layout(set = 0, binding = FSR3UPSCALER_BIND_CB_AUTOREACTIVE, std140) uniform cbGenerateReactive_t +{ + FfxFloat32 fTcThreshold; // 0.1 is a good starting value, lower will result in more TC pixels + FfxFloat32 fTcScale; + FfxFloat32 fReactiveScale; + FfxFloat32 fReactiveMax; +} cbGenerateReactive; + +FfxFloat32 TcThreshold() +{ + return cbGenerateReactive.fTcThreshold; +} + +FfxFloat32 TcScale() +{ + return cbGenerateReactive.fTcScale; +} + +FfxFloat32 ReactiveScale() +{ + return cbGenerateReactive.fReactiveScale; +} + +FfxFloat32 ReactiveMax() +{ + return cbGenerateReactive.fReactiveMax; +} +#endif // #if defined(FSR3UPSCALER_BIND_CB_AUTOREACTIVE) + +#if defined(FSR3UPSCALER_BIND_CB_RCAS) +layout(set = 0, binding = FSR3UPSCALER_BIND_CB_RCAS, std140) uniform cbRCAS_t +{ + FfxUInt32x4 rcasConfig; +} cbRCAS; + +FfxUInt32x4 RCASConfig() +{ + return cbRCAS.rcasConfig; +} +#endif // #if defined(FSR3UPSCALER_BIND_CB_RCAS) + + +#if defined(FSR3UPSCALER_BIND_CB_REACTIVE) +layout(set = 0, binding = FSR3UPSCALER_BIND_CB_REACTIVE, std140) uniform cbGenerateReactive_t +{ + FfxFloat32 gen_reactive_scale; + FfxFloat32 gen_reactive_threshold; + FfxFloat32 gen_reactive_binaryValue; + FfxUInt32 gen_reactive_flags; +} cbGenerateReactive; + +FfxFloat32 GenReactiveScale() +{ + return cbGenerateReactive.gen_reactive_scale; +} + +FfxFloat32 GenReactiveThreshold() +{ + return cbGenerateReactive.gen_reactive_threshold; +} + +FfxFloat32 GenReactiveBinaryValue() +{ + return cbGenerateReactive.gen_reactive_binaryValue; +} + +FfxUInt32 GenReactiveFlags() +{ + return cbGenerateReactive.gen_reactive_flags; +} +#endif // #if defined(FSR3UPSCALER_BIND_CB_REACTIVE) + + +#if defined(FSR3UPSCALER_BIND_CB_SPD) +layout(set = 0, binding = FSR3UPSCALER_BIND_CB_SPD, std140) uniform cbSPD_t +{ + FfxUInt32 mips; + FfxUInt32 numWorkGroups; + FfxUInt32x2 workGroupOffset; + FfxUInt32x2 renderSize; +} cbSPD; + +FfxUInt32 MipCount() +{ + return cbSPD.mips; +} + +FfxUInt32 NumWorkGroups() +{ + return cbSPD.numWorkGroups; +} + +FfxUInt32x2 WorkGroupOffset() +{ + return cbSPD.workGroupOffset; +} + +FfxUInt32x2 SPD_RenderSize() +{ + return cbSPD.renderSize; +} +#endif // #if defined(FSR3UPSCALER_BIND_CB_SPD) + +layout (set = 0, binding = 1000) uniform sampler s_PointClamp; +layout (set = 0, binding = 1001) uniform sampler s_LinearClamp; + +#if defined(FSR3UPSCALER_BIND_SRV_SPD_MIPS) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_SPD_MIPS) uniform texture2D r_spd_mips; + +FfxInt32x2 GetSPDMipDimensions(FfxUInt32 uMipLevel) +{ + return textureSize(r_spd_mips, int(uMipLevel)).xy; +} + +FfxFloat32x2 SampleSPDMipLevel(FfxFloat32x2 fUV, FfxUInt32 mipLevel) +{ + return textureLod(sampler2D(r_spd_mips, s_LinearClamp), fUV, float(mipLevel)).rg; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_INPUT_DEPTH) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_INPUT_DEPTH) uniform texture2D r_input_depth; + +FfxFloat32 LoadInputDepth(FfxInt32x2 iPxPos) +{ + return texelFetch(r_input_depth, iPxPos, 0).r; +} + +FfxFloat32 SampleInputDepth(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_input_depth, s_LinearClamp), fUV, 0.0).x; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_REACTIVE_MASK) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_REACTIVE_MASK) uniform texture2D r_reactive_mask; + +FfxFloat32 LoadReactiveMask(FfxInt32x2 iPxPos) +{ + return texelFetch(r_reactive_mask, FfxInt32x2(iPxPos), 0).r * cbFSR3Upscaler.fReactivenessScale; +} + +FfxInt32x2 GetReactiveMaskResourceDimensions() +{ + return textureSize(r_reactive_mask, 0).xy; +} + +FfxFloat32 SampleReactiveMask(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_reactive_mask, s_LinearClamp), fUV, 0.0).x * cbFSR3Upscaler.fReactivenessScale; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_TRANSPARENCY_AND_COMPOSITION_MASK) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_TRANSPARENCY_AND_COMPOSITION_MASK) uniform texture2D r_transparency_and_composition_mask; + +FfxFloat32 LoadTransparencyAndCompositionMask(FfxUInt32x2 iPxPos) +{ + return texelFetch(r_transparency_and_composition_mask, FfxInt32x2(iPxPos), 0).r; +} + +FfxInt32x2 GetTransparencyAndCompositionMaskResourceDimensions() +{ + return textureSize(r_transparency_and_composition_mask, 0).xy; +} + +FfxFloat32 SampleTransparencyAndCompositionMask(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_transparency_and_composition_mask, s_LinearClamp), fUV, 0.0).x; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_INPUT_COLOR) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_INPUT_COLOR) uniform texture2D r_input_color_jittered; + +FfxFloat32x3 LoadInputColor(FfxInt32x2 iPxPos) +{ + return texelFetch(r_input_color_jittered, iPxPos, 0).rgb; +} + +FfxFloat32x3 SampleInputColor(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_input_color_jittered, s_LinearClamp), fUV, 0.0).rgb; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_INPUT_MOTION_VECTORS) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_INPUT_MOTION_VECTORS) uniform texture2D r_input_motion_vectors; + +FfxFloat32x2 LoadInputMotionVector(FfxInt32x2 iPxDilatedMotionVectorPos) +{ + FfxFloat32x2 fSrcMotionVector = texelFetch(r_input_motion_vectors, iPxDilatedMotionVectorPos, 0).xy; + + FfxFloat32x2 fUvMotionVector = fSrcMotionVector * MotionVectorScale(); + +#if FFX_FSR3UPSCALER_OPTION_JITTERED_MOTION_VECTORS + fUvMotionVector -= MotionVectorJitterCancellation(); +#endif + + return fUvMotionVector; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_INTERNAL_UPSCALED) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_INTERNAL_UPSCALED) uniform texture2D r_internal_upscaled_color; + +FfxFloat32x4 LoadHistory(FfxInt32x2 iPxHistory) +{ + return texelFetch(r_internal_upscaled_color, iPxHistory, 0); +} + +FfxFloat32x4 SampleHistory(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_internal_upscaled_color, s_LinearClamp), fUV, 0.0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_LUMA_HISTORY) +// TotK Recomp: rgba16f, the format of the luma history images (ffx_fsr3upscaler.cpp, R16G16B16A16_FLOAT). With rgba8 +// the stores and loads do not match the image (the Vulkan validation layer reports it; undefined values). +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_LUMA_HISTORY, rgba16f) uniform image2D rw_luma_history; + +void StoreLumaHistory(FfxInt32x2 iPxPos, FfxFloat32x4 fLumaHistory) +{ + imageStore(rw_luma_history, iPxPos, fLumaHistory); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_LUMA_HISTORY) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_LUMA_HISTORY) uniform texture2D r_luma_history; + +FfxFloat32x4 LoadLumaHistory(FfxInt32x2 iPxPos) +{ + return texelFetch(r_luma_history, iPxPos, 0); +} + +FfxFloat32x4 SampleLumaHistory(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_luma_history, s_LinearClamp), fUV, 0.0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_RCAS_INPUT) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_RCAS_INPUT) uniform texture2D r_rcas_input; + +FfxFloat32x4 LoadRCAS_Input(FfxInt32x2 iPxPos) +{ + return texelFetch(r_rcas_input, iPxPos, 0); +} + +FfxFloat32x3 SampleRCAS_Input(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_rcas_input, s_LinearClamp), fUV, 0.0).rgb; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_INTERNAL_UPSCALED) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_INTERNAL_UPSCALED, rgba16f) writeonly uniform image2D rw_internal_upscaled_color; + +void StoreReprojectedHistory(FfxInt32x2 iPxHistory, FfxFloat32x4 fHistory) +{ + imageStore(rw_internal_upscaled_color, iPxHistory, fHistory); +} + +void StoreInternalColorAndWeight(FfxInt32x2 iPxPos, FfxFloat32x4 fColorAndWeight) +{ + imageStore(rw_internal_upscaled_color, iPxPos, fColorAndWeight); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_UPSCALED_OUTPUT) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_UPSCALED_OUTPUT /* app controlled format */) writeonly uniform image2D rw_upscaled_output; + +void StoreUpscaledOutput(FfxInt32x2 iPxPos, FfxFloat32x3 fColor) +{ + imageStore(rw_upscaled_output, iPxPos, FfxFloat32x4(fColor, 1.0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_ACCUMULATION) +layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_ACCUMULATION) uniform texture2D r_accumulation; + +FfxFloat32 SampleAccumulation(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_accumulation, s_LinearClamp), fUV, 0.0).x; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_ACCUMULATION) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_ACCUMULATION, r8) uniform image2D rw_accumulation; + +void StoreAccumulation(FfxInt32x2 iPxPos, FfxFloat32 fAccumulation) +{ + imageStore(rw_accumulation, iPxPos, vec4(fAccumulation, 0.0, 0.0, 0.0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_SHADING_CHANGE) +layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_SHADING_CHANGE) uniform texture2D r_shading_change; + +FfxFloat32 LoadShadingChange(FfxInt32x2 iPxPos) +{ + return texelFetch(r_shading_change, iPxPos, 0).x * cbFSR3Upscaler.fShadingChangeScale; +} + +FfxFloat32 SampleShadingChange(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_shading_change, s_LinearClamp), fUV, 0.0).x * cbFSR3Upscaler.fShadingChangeScale; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_SHADING_CHANGE) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SHADING_CHANGE, r8) uniform image2D rw_shading_change; + +void StoreShadingChange(FfxInt32x2 iPxPos, FfxFloat32 fShadingChange) +{ + imageStore(rw_shading_change, iPxPos, vec4(fShadingChange, 0.0, 0.0, 0.0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH) +layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH) uniform texture2D r_farthest_depth; + +FfxInt32x2 GetFarthestDepthResourceDimensions() +{ + return textureSize(r_farthest_depth, 0).xy; +} + +FfxFloat32 LoadFarthestDepth(FfxInt32x2 iPxPos) +{ + return texelFetch(r_farthest_depth, iPxPos, 0).x; +} + +FfxFloat32 SampleFarthestDepth(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_farthest_depth, s_LinearClamp), fUV, 0.0).x; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH, r16f) uniform image2D rw_farthest_depth; + +void StoreFarthestDepth(FfxInt32x2 iPxPos, FfxFloat32 fDepth) +{ + imageStore(rw_farthest_depth, iPxPos, vec4(fDepth, 0.0, 0.0, 0.0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH_MIP1) +layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH_MIP1) uniform texture2D r_farthest_depth_mip1; + +FfxInt32x2 GetFarthestDepthMip1ResourceDimensions() +{ + return textureSize(r_farthest_depth_mip1, 0).xy; +} + +FfxFloat32 LoadFarthestDepthMip1(FfxInt32x2 iPxPos) +{ + return texelFetch(r_farthest_depth_mip1, iPxPos, 0).x; +} + +FfxFloat32 SampleFarthestDepthMip1(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_farthest_depth_mip1, s_LinearClamp), fUV, 0.0).x; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH_MIP1) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH_MIP1, r16f) uniform image2D rw_farthest_depth_mip1; + +void StoreFarthestDepthMip1(FfxInt32x2 iPxPos, FfxFloat32 fDepth) +{ + imageStore(rw_farthest_depth_mip1, iPxPos, vec4(fDepth, 0.0, 0.0, 0.0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_CURRENT_LUMA) +layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_CURRENT_LUMA) uniform texture2D r_current_luma; + +FfxFloat32 LoadCurrentLuma(FfxInt32x2 iPxPos) +{ + return texelFetch(r_current_luma, iPxPos, 0).r; +} + +FfxFloat32 SampleCurrentLuma(FfxFloat32x2 uv) +{ + return textureLod(sampler2D(r_current_luma, s_LinearClamp), uv, 0.0).r; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_CURRENT_LUMA) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_CURRENT_LUMA, r16f) uniform image2D rw_current_luma; + +void StoreCurrentLuma(FfxInt32x2 iPxPos, FfxFloat32 fLuma) +{ + imageStore(rw_current_luma, iPxPos, vec4(fLuma, 0.0, 0.0, 0.0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_LUMA_INSTABILITY) +layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_LUMA_INSTABILITY) uniform texture2D r_luma_instability; + +FfxFloat32 SampleLumaInstability(FfxFloat32x2 uv) +{ + return textureLod(sampler2D(r_luma_instability, s_LinearClamp), uv, 0.0).x; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_LUMA_INSTABILITY) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_LUMA_INSTABILITY, r16f) uniform image2D rw_luma_instability; + +void StoreLumaInstability(FfxInt32x2 iPxPos, FfxFloat32 fLumaInstability) +{ + imageStore(rw_luma_instability, iPxPos, vec4(fLumaInstability, 0.0, 0.0, 0.0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_PREVIOUS_LUMA) +layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_PREVIOUS_LUMA) uniform texture2D r_previous_luma; + +FfxFloat32 LoadPreviousLuma(FfxInt32x2 iPxPos) +{ + return texelFetch(r_previous_luma, iPxPos, 0).r; +} + +FfxFloat32 SamplePreviousLuma(FfxFloat32x2 uv) +{ + return textureLod(sampler2D(r_previous_luma, s_LinearClamp), uv, 0.0).r; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_NEW_LOCKS) +layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_NEW_LOCKS) uniform texture2D r_new_locks; + +FfxFloat32 LoadNewLocks(FfxInt32x2 iPxPos) +{ + return texelFetch(r_new_locks, iPxPos, 0).r; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_NEW_LOCKS) +layout(set = 0, binding = FSR3UPSCALER_BIND_UAV_NEW_LOCKS, r8) uniform image2D rw_new_locks; + +FfxFloat32 LoadRwNewLocks(FfxInt32x2 iPxPos) +{ + return imageLoad(rw_new_locks, iPxPos).r; +} + +void StoreNewLocks(FfxInt32x2 iPxPos, FfxFloat32 newLock) +{ + imageStore(rw_new_locks, iPxPos, vec4(newLock, 0, 0, 0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_RECONSTRUCTED_PREV_NEAREST_DEPTH) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_RECONSTRUCTED_PREV_NEAREST_DEPTH) uniform utexture2D r_reconstructed_previous_nearest_depth; + +FfxFloat32 LoadReconstructedPrevDepth(FfxInt32x2 iPxPos) +{ + return uintBitsToFloat(texelFetch(r_reconstructed_previous_nearest_depth, iPxPos, 0).r); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH, r32ui) uniform uimage2D rw_reconstructed_previous_nearest_depth; + +void StoreReconstructedDepth(FfxInt32x2 iPxSample, FfxFloat32 fDepth) +{ + FfxUInt32 uDepth = floatBitsToUint(fDepth); + + #if FFX_FSR3UPSCALER_OPTION_INVERTED_DEPTH + imageAtomicMax(rw_reconstructed_previous_nearest_depth, iPxSample, uDepth); + #else + imageAtomicMin(rw_reconstructed_previous_nearest_depth, iPxSample, uDepth); // min for standard, max for inverted depth + #endif +} + +void SetReconstructedDepth(FfxInt32x2 iPxSample, FfxUInt32 uValue) +{ + imageStore(rw_reconstructed_previous_nearest_depth, iPxSample, uvec4(uValue, 0, 0, 0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_DILATED_DEPTH) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_DILATED_DEPTH, r32f) writeonly uniform image2D rw_dilated_depth; + +void StoreDilatedDepth(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32 fDepth) +{ + imageStore(rw_dilated_depth, iPxPos, vec4(fDepth, 0.0, 0.0, 0.0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_DILATED_MOTION_VECTORS) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_DILATED_MOTION_VECTORS, rg16f) writeonly uniform image2D rw_dilated_motion_vectors; + +void StoreDilatedMotionVector(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x2 fMotionVector) +{ + imageStore(rw_dilated_motion_vectors, iPxPos, vec4(fMotionVector, 0.0, 0.0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_DILATED_MOTION_VECTORS) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_DILATED_MOTION_VECTORS) uniform texture2D r_dilated_motion_vectors; + +FfxFloat32x2 LoadDilatedMotionVector(FfxInt32x2 iPxInput) +{ + return texelFetch(r_dilated_motion_vectors, iPxInput, 0).xy; +} + +FfxFloat32x2 SampleDilatedMotionVector(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_dilated_motion_vectors, s_LinearClamp), fUV, 0.0).xy; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_DILATED_DEPTH) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_DILATED_DEPTH) uniform texture2D r_dilated_depth; + +FfxFloat32 LoadDilatedDepth(FfxInt32x2 iPxInput) +{ + return texelFetch(r_dilated_depth, iPxInput, 0).r; +} + +FfxFloat32 SampleDilatedDepth(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_dilated_depth, s_LinearClamp), fUV, 0.0).r; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_INPUT_EXPOSURE) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_INPUT_EXPOSURE) uniform texture2D r_input_exposure; + +FfxFloat32 Exposure() +{ + FfxFloat32 exposure = texelFetch(r_input_exposure, FfxInt32x2(0, 0), 0).x; + + if (exposure == 0.0) { + exposure = 1.0; + } + + return exposure; +} +#endif + +// BEGIN: FSR3UPSCALER_BIND_SRV_LANCZOS_LUT +#if defined(FSR3UPSCALER_BIND_SRV_LANCZOS_LUT) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_LANCZOS_LUT) uniform texture2D r_lanczos_lut; +#endif + +FfxFloat32 SampleLanczos2Weight(FfxFloat32 x) +{ +#if defined(FSR3UPSCALER_BIND_SRV_LANCZOS_LUT) + return textureLod(sampler2D(r_lanczos_lut, s_LinearClamp), FfxFloat32x2(x / 2.0, 0.5), 0.0).x; +#else + return 0.f; +#endif +} +// END: FSR3UPSCALER_BIND_SRV_LANCZOS_LUT + +#if defined(FSR3UPSCALER_BIND_SRV_DILATED_REACTIVE_MASKS) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_DILATED_REACTIVE_MASKS) uniform texture2D r_dilated_reactive_masks; + +FfxFloat32x4 SampleDilatedReactiveMasks(FfxFloat32x2 fUV) +{ + return textureLod(sampler2D(r_dilated_reactive_masks, s_LinearClamp), fUV, 0.0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_DILATED_REACTIVE_MASKS) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_DILATED_REACTIVE_MASKS, rgba8) writeonly uniform image2D rw_dilated_reactive_masks; + +void StoreDilatedReactiveMasks(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x4 fDilatedReactiveMasks) +{ + imageStore(rw_dilated_reactive_masks, iPxPos, fDilatedReactiveMasks); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_INPUT_OPAQUE_ONLY) +layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_INPUT_OPAQUE_ONLY) uniform texture2D r_input_opaque_only; + +FfxFloat32x3 LoadOpaqueOnly(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos) +{ + return texelFetch(r_input_opaque_only, iPxPos, 0).xyz; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_PREV_PRE_ALPHA_COLOR) +layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_PREV_PRE_ALPHA_COLOR) uniform texture2D r_input_prev_color_pre_alpha; + +FfxFloat32x3 LoadPrevPreAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos) +{ + return texelFetch(r_input_prev_color_pre_alpha, iPxPos, 0).xyz; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_PREV_POST_ALPHA_COLOR) +layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_PREV_POST_ALPHA_COLOR) uniform texture2D r_input_prev_color_post_alpha; + +FfxFloat32x3 LoadPrevPostAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos) +{ + return texelFetch(r_input_prev_color_post_alpha, iPxPos, 0).xyz; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_AUTOREACTIVE) && \ + defined(FSR3UPSCALER_BIND_UAV_AUTOCOMPOSITION) + +layout(set = 0, binding = FSR3UPSCALER_BIND_UAV_AUTOREACTIVE, r32f) uniform image2D rw_output_autoreactive; +layout(set = 0, binding = FSR3UPSCALER_BIND_UAV_AUTOCOMPOSITION, r32f) uniform image2D rw_output_autocomposition; + +void StoreAutoReactive(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos, FFX_PARAMETER_IN FFX_MIN16_F2 fReactive) +{ + imageStore(rw_output_autoreactive, iPxPos, FfxFloat32x4(FfxFloat32(fReactive.x), 0.0, 0.0, 0.0)); + + imageStore(rw_output_autocomposition, iPxPos, FfxFloat32x4(FfxFloat32(fReactive.y), 0.0, 0.0, 0.0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_PREV_PRE_ALPHA_COLOR) +layout(set = 0, binding = FSR3UPSCALER_BIND_UAV_PREV_PRE_ALPHA_COLOR, r11f_g11f_b10f) uniform image2D rw_output_prev_color_pre_alpha; + +void StorePrevPreAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos, FFX_PARAMETER_IN FFX_MIN16_F3 color) +{ + imageStore(rw_output_prev_color_pre_alpha, iPxPos, FfxFloat32x4(color, 0.0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_PREV_POST_ALPHA_COLOR) +layout(set = 0, binding = FSR3UPSCALER_BIND_UAV_PREV_POST_ALPHA_COLOR, r11f_g11f_b10f) uniform image2D rw_output_prev_color_post_alpha; + +void StorePrevPostAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos, FFX_PARAMETER_IN FFX_MIN16_F3 color) +{ + imageStore(rw_output_prev_color_post_alpha, iPxPos, FfxFloat32x4(color, 0.0)); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_FRAME_INFO) +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_FRAME_INFO, rgba32f) uniform image2D rw_frame_info; + +FfxFloat32x4 LoadFrameInfo() +{ + return imageLoad(rw_frame_info, ivec2(0, 0)); +} + +void StoreFrameInfo(FfxFloat32x4 fInfo) +{ + imageStore(rw_frame_info, ivec2(0, 0), fInfo); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_FRAME_INFO) +layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_FRAME_INFO) uniform texture2D r_frame_info; + +FfxFloat32x4 FrameInfo() +{ + return texelFetch(r_frame_info, ivec2(0, 0), 0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_0) && \ + defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_1) && \ + defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_2) && \ + defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_3) && \ + defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_4) && \ + defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_5) + +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_0, rg16f) uniform image2D rw_spd_mip0; +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_1, rg16f) uniform image2D rw_spd_mip1; +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_2, rg16f) uniform image2D rw_spd_mip2; +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_3, rg16f) uniform image2D rw_spd_mip3; +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_4, rg16f) uniform image2D rw_spd_mip4; +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_5, rg16f) coherent uniform image2D rw_spd_mip5; + +FfxFloat32x2 RWLoadPyramid(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 index) +{ +#define LOAD(idx) \ + if (index == idx) \ + { \ + return imageLoad(rw_spd_mip##idx, iPxPos).xy; \ + } + LOAD(0); + LOAD(1); + LOAD(2); + LOAD(3); + LOAD(4); + LOAD(5); + + return FfxFloat32x2(0.0, 0.0); + +#undef LOAD +} + +void StorePyramid(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x2 outValue, FFX_PARAMETER_IN FfxUInt32 index) +{ +#define STORE(idx) \ + if (index == idx) \ + { \ + imageStore(rw_spd_mip##idx, iPxPos, vec4(outValue, 0.0, 0.0)); \ + } + + STORE(0); + STORE(1); + STORE(2); + STORE(3); + STORE(4); + STORE(5); + +#undef STORE +} +#endif + +#if defined FSR3UPSCALER_BIND_UAV_SPD_GLOBAL_ATOMIC +layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_GLOBAL_ATOMIC, r32ui) coherent uniform uimage2D rw_spd_global_atomic; + +void SPD_IncreaseAtomicCounter(inout FfxUInt32 spdCounter) +{ + spdCounter = imageAtomicAdd(rw_spd_global_atomic, ivec2(0, 0), 1); +} + +void SPD_ResetAtomicCounter() +{ + imageStore(rw_spd_global_atomic, ivec2(0, 0), uvec4(0)); +} +#endif + +#endif // #if defined(FFX_GPU) diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_callbacks_hlsl.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_callbacks_hlsl.h new file mode 100644 index 00000000..60d2b8a6 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_callbacks_hlsl.h @@ -0,0 +1,990 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#include "ffx_fsr3upscaler_resources.h" + +#if defined(FFX_GPU) +#ifdef __hlsl_dx_compiler +#pragma dxc diagnostic push +#pragma dxc diagnostic ignored "-Wambig-lit-shift" +#endif //__hlsl_dx_compiler +#include "ffx_core.h" +#ifdef __hlsl_dx_compiler +#pragma dxc diagnostic pop +#endif //__hlsl_dx_compiler +#endif // #if defined(FFX_GPU) + +#if defined(FFX_GPU) +#ifndef FFX_PREFER_WAVE64 +#define FFX_PREFER_WAVE64 +#endif // FFX_PREFER_WAVE64 + +#pragma warning(disable: 3205) // conversion from larger type to smaller + +#define DECLARE_SRV_REGISTER(regIndex) t##regIndex +#define DECLARE_UAV_REGISTER(regIndex) u##regIndex +#define DECLARE_CB_REGISTER(regIndex) b##regIndex +#define FFX_FSR3UPSCALER_DECLARE_SRV(regIndex) register(DECLARE_SRV_REGISTER(regIndex)) +#define FFX_FSR3UPSCALER_DECLARE_UAV(regIndex) register(DECLARE_UAV_REGISTER(regIndex)) +#define FFX_FSR3UPSCALER_DECLARE_CB(regIndex) register(DECLARE_CB_REGISTER(regIndex)) + +#if defined(FSR3UPSCALER_BIND_CB_FSR3UPSCALER) +cbuffer cbFSR3Upscaler : FFX_FSR3UPSCALER_DECLARE_CB(FSR3UPSCALER_BIND_CB_FSR3UPSCALER) +{ + FfxInt32x2 iRenderSize; + FfxInt32x2 iPreviousFrameRenderSize; + + FfxInt32x2 iUpscaleSize; + FfxInt32x2 iPreviousFrameUpscaleSize; + + FfxInt32x2 iMaxRenderSize; + FfxInt32x2 iMaxUpscaleSize; + + FfxFloat32x4 fDeviceToViewDepth; + + FfxFloat32x2 fJitter; + FfxFloat32x2 fPreviousFrameJitter; + + FfxFloat32x2 fMotionVectorScale; + FfxFloat32x2 fDownscaleFactor; + + FfxFloat32x2 fMotionVectorJitterCancellation; + FfxFloat32 fTanHalfFOV; + FfxFloat32 fJitterSequenceLength; + + FfxFloat32 fDeltaTime; + FfxFloat32 fDeltaPreExposure; + FfxFloat32 fViewSpaceToMetersFactor; + FfxFloat32 fFrameIndex; + + FfxFloat32 fVelocityFactor; + FfxFloat32 fReactivenessScale; + FfxFloat32 fShadingChangeScale; + FfxFloat32 fAccumulationAddedPerFrame; + FfxFloat32 fMinDisocclusionAccumulation; +}; + +#define FFX_FSR3UPSCALER_CONSTANT_BUFFER_1_SIZE (sizeof(cbFSR3Upscaler) / 4) // Number of 32-bit values. This must be kept in sync with the cbFSR3Upscaler size. + +/* Define getter functions in the order they are defined in the CB! */ +FfxInt32x2 RenderSize() +{ + return iRenderSize; +} + +FfxInt32x2 PreviousFrameRenderSize() +{ + return iPreviousFrameRenderSize; +} + +FfxInt32x2 MaxRenderSize() +{ + return iMaxRenderSize; +} + +FfxInt32x2 UpscaleSize() +{ + return iUpscaleSize; +} + +FfxInt32x2 PreviousFrameUpscaleSize() +{ + return iPreviousFrameUpscaleSize; +} + +FfxInt32x2 MaxUpscaleSize() +{ + return iMaxUpscaleSize; +} + +FfxFloat32x2 Jitter() +{ + return fJitter; +} + +FfxFloat32x2 PreviousFrameJitter() +{ + return fPreviousFrameJitter; +} + +FfxFloat32x4 DeviceToViewSpaceTransformFactors() +{ + return fDeviceToViewDepth; +} + +FfxFloat32x2 MotionVectorScale() +{ + return fMotionVectorScale; +} + +FfxFloat32x2 DownscaleFactor() +{ + return fDownscaleFactor; +} + +FfxFloat32x2 MotionVectorJitterCancellation() +{ + return fMotionVectorJitterCancellation; +} + +FfxFloat32 TanHalfFoV() +{ + return fTanHalfFOV; +} + +FfxFloat32 JitterSequenceLength() +{ + return fJitterSequenceLength; +} + +FfxFloat32 DeltaTime() +{ + return fDeltaTime; +} + +FfxFloat32 DeltaPreExposure() +{ + return fDeltaPreExposure; +} + +FfxFloat32 ViewSpaceToMetersFactor() +{ + return fViewSpaceToMetersFactor; +} + +FfxFloat32 FrameIndex() +{ + return fFrameIndex; +} + +FfxFloat32 VelocityFactor() +{ + return fVelocityFactor; +} + +FfxFloat32 AccumulationAddedPerFrame() +{ + return fAccumulationAddedPerFrame; +} + +FfxFloat32 MinDisocclusionAccumulation() +{ + return fMinDisocclusionAccumulation; +} + +#endif // #if defined(FSR3UPSCALER_BIND_CB_FSR3UPSCALER) + +#define FFX_FSR3UPSCALER_ROOTSIG_STRINGIFY(p) FFX_FSR3UPSCALER_ROOTSIG_STR(p) +#define FFX_FSR3UPSCALER_ROOTSIG_STR(p) #p +#define FFX_FSR3UPSCALER_ROOTSIG [RootSignature( "DescriptorTable(UAV(u0, numDescriptors = " FFX_FSR3UPSCALER_ROOTSIG_STRINGIFY(FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_COUNT) ")), " \ + "DescriptorTable(SRV(t0, numDescriptors = " FFX_FSR3UPSCALER_ROOTSIG_STRINGIFY(FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_COUNT) ")), " \ + "CBV(b0), " \ + "StaticSampler(s0, filter = FILTER_MIN_MAG_MIP_POINT, " \ + "addressU = TEXTURE_ADDRESS_CLAMP, " \ + "addressV = TEXTURE_ADDRESS_CLAMP, " \ + "addressW = TEXTURE_ADDRESS_CLAMP, " \ + "comparisonFunc = COMPARISON_NEVER, " \ + "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK), " \ + "StaticSampler(s1, filter = FILTER_MIN_MAG_MIP_LINEAR, " \ + "addressU = TEXTURE_ADDRESS_CLAMP, " \ + "addressV = TEXTURE_ADDRESS_CLAMP, " \ + "addressW = TEXTURE_ADDRESS_CLAMP, " \ + "comparisonFunc = COMPARISON_NEVER, " \ + "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK)" )] + +#define FFX_FSR3UPSCALER_CONSTANT_BUFFER_2_SIZE 6 // Number of 32-bit values. This must be kept in sync with max( cbRCAS , cbSPD) size. + +#define FFX_FSR3UPSCALER_CB2_ROOTSIG [RootSignature( "DescriptorTable(UAV(u0, numDescriptors = " FFX_FSR3UPSCALER_ROOTSIG_STRINGIFY(FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_COUNT) ")), " \ + "DescriptorTable(SRV(t0, numDescriptors = " FFX_FSR3UPSCALER_ROOTSIG_STRINGIFY(FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_COUNT) ")), " \ + "CBV(b0), " \ + "CBV(b1), " \ + "StaticSampler(s0, filter = FILTER_MIN_MAG_MIP_POINT, " \ + "addressU = TEXTURE_ADDRESS_CLAMP, " \ + "addressV = TEXTURE_ADDRESS_CLAMP, " \ + "addressW = TEXTURE_ADDRESS_CLAMP, " \ + "comparisonFunc = COMPARISON_NEVER, " \ + "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK), " \ + "StaticSampler(s1, filter = FILTER_MIN_MAG_MIP_LINEAR, " \ + "addressU = TEXTURE_ADDRESS_CLAMP, " \ + "addressV = TEXTURE_ADDRESS_CLAMP, " \ + "addressW = TEXTURE_ADDRESS_CLAMP, " \ + "comparisonFunc = COMPARISON_NEVER, " \ + "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK)" )] +#if defined(FFX_FSR3UPSCALER_EMBED_ROOTSIG) +#define FFX_FSR3UPSCALER_EMBED_ROOTSIG_CONTENT FFX_FSR3UPSCALER_ROOTSIG +#define FFX_FSR3UPSCALER_EMBED_CB2_ROOTSIG_CONTENT FFX_FSR3UPSCALER_CB2_ROOTSIG +#else +#define FFX_FSR3UPSCALER_EMBED_ROOTSIG_CONTENT +#define FFX_FSR3UPSCALER_EMBED_CB2_ROOTSIG_CONTENT +#endif // #if FFX_FSR3UPSCALER_EMBED_ROOTSIG + +#if defined(FSR3UPSCALER_BIND_CB_AUTOREACTIVE) +cbuffer cbGenerateReactive : FFX_FSR3UPSCALER_DECLARE_CB(FSR3UPSCALER_BIND_CB_AUTOREACTIVE) +{ + FfxFloat32 fTcThreshold; // 0.1 is a good starting value, lower will result in more TC pixels + FfxFloat32 fTcScale; + FfxFloat32 fReactiveScale; + FfxFloat32 fReactiveMax; +}; + +FfxFloat32 TcThreshold() +{ + return fTcThreshold; +} + +FfxFloat32 TcScale() +{ + return fTcScale; +} + +FfxFloat32 ReactiveScale() +{ + return fReactiveScale; +} + +FfxFloat32 ReactiveMax() +{ + return fReactiveMax; +} +#endif // #if defined(FSR3UPSCALER_BIND_CB_AUTOREACTIVE) + +#if defined(FSR3UPSCALER_BIND_CB_RCAS) +cbuffer cbRCAS : FFX_FSR3UPSCALER_DECLARE_CB(FSR3UPSCALER_BIND_CB_RCAS) +{ + FfxUInt32x4 rcasConfig; +}; + +FfxUInt32x4 RCASConfig() +{ + return rcasConfig; +} +#endif // #if defined(FSR3UPSCALER_BIND_CB_RCAS) + + +#if defined(FSR3UPSCALER_BIND_CB_REACTIVE) +cbuffer cbGenerateReactive : FFX_FSR3UPSCALER_DECLARE_CB(FSR3UPSCALER_BIND_CB_REACTIVE) +{ + FfxFloat32 gen_reactive_scale; + FfxFloat32 gen_reactive_threshold; + FfxFloat32 gen_reactive_binaryValue; + FfxUInt32 gen_reactive_flags; +}; + +FfxFloat32 GenReactiveScale() +{ + return gen_reactive_scale; +} + +FfxFloat32 GenReactiveThreshold() +{ + return gen_reactive_threshold; +} + +FfxFloat32 GenReactiveBinaryValue() +{ + return gen_reactive_binaryValue; +} + +FfxUInt32 GenReactiveFlags() +{ + return gen_reactive_flags; +} +#endif // #if defined(FSR3UPSCALER_BIND_CB_REACTIVE) + +#if defined(FSR3UPSCALER_BIND_CB_SPD) +cbuffer cbSPD : FFX_FSR3UPSCALER_DECLARE_CB(FSR3UPSCALER_BIND_CB_SPD) { + + FfxUInt32 mips; + FfxUInt32 numWorkGroups; + FfxUInt32x2 workGroupOffset; + FfxUInt32x2 renderSize; +}; + +FfxUInt32 MipCount() +{ + return mips; +} + +FfxUInt32 NumWorkGroups() +{ + return numWorkGroups; +} + +FfxUInt32x2 WorkGroupOffset() +{ + return workGroupOffset; +} + +FfxUInt32x2 SPD_RenderSize() +{ + return renderSize; +} +#endif // #if defined(FSR3UPSCALER_BIND_CB_SPD) + +SamplerState s_PointClamp : register(s0); +SamplerState s_LinearClamp : register(s1); + +#if defined(FSR3UPSCALER_BIND_SRV_SPD_MIPS) +Texture2D r_spd_mips : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_SPD_MIPS); + +FfxInt32x2 GetSPDMipDimensions(FfxUInt32 uMipLevel) +{ + FfxUInt32 uWidth; + FfxUInt32 uHeight; + FfxUInt32 uLevels; + r_spd_mips.GetDimensions(uMipLevel, uWidth, uHeight, uLevels); + + return FfxInt32x2(uWidth, uHeight); +} + +FfxFloat32x2 SampleSPDMipLevel(FfxFloat32x2 fUV, FfxUInt32 mipLevel) +{ + return r_spd_mips.SampleLevel(s_LinearClamp, fUV, mipLevel); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_INPUT_DEPTH) +Texture2D r_input_depth : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_INPUT_DEPTH); + +FfxFloat32 LoadInputDepth(FfxUInt32x2 iPxPos) +{ + return r_input_depth[iPxPos]; +} + +FfxFloat32 SampleInputDepth(FfxFloat32x2 fUV) +{ + return r_input_depth.SampleLevel(s_LinearClamp, fUV, 0).x; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_REACTIVE_MASK) +Texture2D r_reactive_mask : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_REACTIVE_MASK); + +FfxFloat32 LoadReactiveMask(FfxUInt32x2 iPxPos) +{ + return r_reactive_mask[iPxPos] * fReactivenessScale; +} + +FfxInt32x2 GetReactiveMaskResourceDimensions() +{ + FfxUInt32 uWidth; + FfxUInt32 uHeight; + r_reactive_mask.GetDimensions(uWidth, uHeight); + + return FfxInt32x2(uWidth, uHeight); +} + +FfxFloat32 SampleReactiveMask(FfxFloat32x2 fUV) +{ + return r_reactive_mask.SampleLevel(s_LinearClamp, fUV, 0).x * fReactivenessScale; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_TRANSPARENCY_AND_COMPOSITION_MASK) +Texture2D r_transparency_and_composition_mask : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_TRANSPARENCY_AND_COMPOSITION_MASK); + +FfxFloat32 LoadTransparencyAndCompositionMask(FfxUInt32x2 iPxPos) +{ + return r_transparency_and_composition_mask[iPxPos]; +} + +FfxInt32x2 GetTransparencyAndCompositionMaskResourceDimensions() +{ + FfxUInt32 uWidth; + FfxUInt32 uHeight; + r_transparency_and_composition_mask.GetDimensions(uWidth, uHeight); + + return FfxInt32x2(uWidth, uHeight); +} + +FfxFloat32 SampleTransparencyAndCompositionMask(FfxFloat32x2 fUV) +{ + return r_transparency_and_composition_mask.SampleLevel(s_LinearClamp, fUV, 0).x; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_INPUT_COLOR) +Texture2D r_input_color_jittered : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_INPUT_COLOR); + +FfxFloat32x3 LoadInputColor(FfxUInt32x2 iPxPos) +{ + return r_input_color_jittered[iPxPos].rgb; +} + +FfxFloat32x3 SampleInputColor(FfxFloat32x2 fUV) +{ + return r_input_color_jittered.SampleLevel(s_LinearClamp, fUV, 0).rgb; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_INPUT_MOTION_VECTORS) +Texture2D r_input_motion_vectors : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_INPUT_MOTION_VECTORS); + +FfxFloat32x2 LoadInputMotionVector(FfxUInt32x2 iPxDilatedMotionVectorPos) +{ + FfxFloat32x2 fSrcMotionVector = r_input_motion_vectors[iPxDilatedMotionVectorPos].xy; + + FfxFloat32x2 fUvMotionVector = fSrcMotionVector * MotionVectorScale(); + +#if FFX_FSR3UPSCALER_OPTION_JITTERED_MOTION_VECTORS + fUvMotionVector -= MotionVectorJitterCancellation(); +#endif + + return fUvMotionVector; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_INTERNAL_UPSCALED) +Texture2D r_internal_upscaled_color : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_INTERNAL_UPSCALED); + +FfxFloat32x4 LoadHistory(FfxUInt32x2 iPxHistory) +{ + return r_internal_upscaled_color[iPxHistory]; +} + +FfxFloat32x4 SampleHistory(FfxFloat32x2 fUV) +{ + return r_internal_upscaled_color.SampleLevel(s_LinearClamp, fUV, 0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_LUMA_HISTORY) +RWTexture2D rw_luma_history : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_LUMA_HISTORY); + +void StoreLumaHistory(FfxUInt32x2 iPxPos, FfxFloat32x4 fLumaHistory) +{ + rw_luma_history[iPxPos] = fLumaHistory; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_LUMA_HISTORY) +Texture2D r_luma_history : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_LUMA_HISTORY); + +FfxFloat32x4 LoadLumaHistory(FfxInt32x2 iPxPos) +{ + return r_luma_history[iPxPos]; +} + +FfxFloat32x4 SampleLumaHistory(FfxFloat32x2 fUV) +{ + return r_luma_history.SampleLevel(s_LinearClamp, fUV, 0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_RCAS_INPUT) +Texture2D r_rcas_input : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_RCAS_INPUT); + +FfxFloat32x4 LoadRCAS_Input(FfxInt32x2 iPxPos) +{ + return r_rcas_input[iPxPos]; +} + +FfxFloat32x3 SampleRCAS_Input(FfxFloat32x2 fUV) +{ + return r_rcas_input.SampleLevel(s_LinearClamp, fUV, 0).rgb; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_INTERNAL_UPSCALED) +RWTexture2D rw_internal_upscaled_color : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_INTERNAL_UPSCALED); + +void StoreReprojectedHistory(FfxUInt32x2 iPxHistory, FfxFloat32x4 fHistory) +{ + rw_internal_upscaled_color[iPxHistory] = fHistory; +} + +void StoreInternalColorAndWeight(FfxUInt32x2 iPxPos, FfxFloat32x4 fColorAndWeight) +{ + rw_internal_upscaled_color[iPxPos] = fColorAndWeight; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_UPSCALED_OUTPUT) +RWTexture2D rw_upscaled_output : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_UPSCALED_OUTPUT); + +void StoreUpscaledOutput(FfxUInt32x2 iPxPos, FfxFloat32x3 fColor) +{ + rw_upscaled_output[iPxPos] = FfxFloat32x4(fColor, 1.f); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_ACCUMULATION) +Texture2D r_accumulation : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_ACCUMULATION); + +FfxFloat32 SampleAccumulation(FfxFloat32x2 fUV) +{ + return r_accumulation.SampleLevel(s_LinearClamp, fUV, 0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_ACCUMULATION) +RWTexture2D rw_accumulation : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_ACCUMULATION); + +void StoreAccumulation(FfxUInt32x2 iPxPos, FfxFloat32 fAccumulation) +{ + rw_accumulation[iPxPos] = fAccumulation; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_SHADING_CHANGE) +Texture2D r_shading_change : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_SHADING_CHANGE); + +FfxFloat32 LoadShadingChange(FfxUInt32x2 iPxPos) +{ + return r_shading_change[iPxPos] * fShadingChangeScale; +} + +FfxFloat32 SampleShadingChange(FfxFloat32x2 fUV) +{ + return r_shading_change.SampleLevel(s_LinearClamp, fUV, 0) * fShadingChangeScale; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_SHADING_CHANGE) +RWTexture2D rw_shading_change : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_SHADING_CHANGE); + +void StoreShadingChange(FfxUInt32x2 iPxPos, FfxFloat32 fShadingChange) +{ + rw_shading_change[iPxPos] = fShadingChange; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH) +Texture2D r_farthest_depth : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH); + +FfxInt32x2 GetFarthestDepthResourceDimensions() +{ + FfxUInt32 uWidth; + FfxUInt32 uHeight; + r_farthest_depth.GetDimensions(uWidth, uHeight); + + return FfxInt32x2(uWidth, uHeight); +} + +FfxFloat32 LoadFarthestDepth(FfxUInt32x2 iPxPos) +{ + return r_farthest_depth[iPxPos]; +} + +FfxFloat32 SampleFarthestDepth(FfxFloat32x2 fUV) +{ + return r_farthest_depth.SampleLevel(s_LinearClamp, fUV, 0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH) +RWTexture2D rw_farthest_depth : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH); + +void StoreFarthestDepth(FfxUInt32x2 iPxPos, FfxFloat32 fDepth) +{ + rw_farthest_depth[iPxPos] = fDepth; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH_MIP1) +Texture2D r_farthest_depth_mip1 : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH_MIP1); + +FfxInt32x2 GetFarthestDepthMip1ResourceDimensions() +{ + FfxUInt32 uWidth; + FfxUInt32 uHeight; + r_farthest_depth_mip1.GetDimensions(uWidth, uHeight); + + return FfxInt32x2(uWidth, uHeight); +} + +FfxFloat32 LoadFarthestDepthMip1(FfxUInt32x2 iPxPos) +{ + return r_farthest_depth_mip1[iPxPos]; +} + +FfxFloat32 SampleFarthestDepthMip1(FfxFloat32x2 fUV) +{ + return r_farthest_depth_mip1.SampleLevel(s_LinearClamp, fUV, 0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH_MIP1) +RWTexture2D rw_farthest_depth_mip1 : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH_MIP1); + +void StoreFarthestDepthMip1(FfxUInt32x2 iPxPos, FfxFloat32 fDepth) +{ + rw_farthest_depth_mip1[iPxPos] = fDepth; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_CURRENT_LUMA) +Texture2D r_current_luma : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_CURRENT_LUMA); + +FfxFloat32 LoadCurrentLuma(FfxUInt32x2 iPxPos) +{ + return r_current_luma[iPxPos]; +} + +FfxFloat32 SampleCurrentLuma(FfxFloat32x2 uv) +{ + return r_current_luma.SampleLevel(s_LinearClamp, uv, 0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_CURRENT_LUMA) +RWTexture2D rw_current_luma : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_CURRENT_LUMA); + +void StoreCurrentLuma(FfxUInt32x2 iPxPos, FfxFloat32 fLuma) +{ + rw_current_luma[iPxPos] = fLuma; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_LUMA_INSTABILITY) +Texture2D r_luma_instability : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_LUMA_INSTABILITY); + +FfxFloat32 SampleLumaInstability(FfxFloat32x2 uv) +{ + return r_luma_instability.SampleLevel(s_LinearClamp, uv, 0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_LUMA_INSTABILITY) +RWTexture2D rw_luma_instability : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_LUMA_INSTABILITY); + +void StoreLumaInstability(FfxUInt32x2 iPxPos, FfxFloat32 fLumaInstability) +{ + rw_luma_instability[iPxPos] = fLumaInstability; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_PREVIOUS_LUMA) +Texture2D r_previous_luma : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_PREVIOUS_LUMA); + +FfxFloat32 LoadPreviousLuma(FfxUInt32x2 iPxPos) +{ + return r_previous_luma[iPxPos]; +} + +FfxFloat32 SamplePreviousLuma(FfxFloat32x2 uv) +{ + return r_previous_luma.SampleLevel(s_LinearClamp, uv, 0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_NEW_LOCKS) +Texture2D r_new_locks : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_NEW_LOCKS); + +FfxFloat32 LoadNewLocks(FfxUInt32x2 iPxPos) +{ + return r_new_locks[iPxPos]; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_NEW_LOCKS) +RWTexture2D rw_new_locks : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_NEW_LOCKS); + +FfxFloat32 LoadRwNewLocks(FfxUInt32x2 iPxPos) +{ + return rw_new_locks[iPxPos]; +} + +void StoreNewLocks(FfxUInt32x2 iPxPos, FfxFloat32 newLock) +{ + rw_new_locks[iPxPos] = newLock; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_RECONSTRUCTED_PREV_NEAREST_DEPTH) +Texture2D r_reconstructed_previous_nearest_depth : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_RECONSTRUCTED_PREV_NEAREST_DEPTH); + +FfxFloat32 LoadReconstructedPrevDepth(FfxUInt32x2 iPxPos) +{ + return asfloat(r_reconstructed_previous_nearest_depth[iPxPos]); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH) +RWTexture2D rw_reconstructed_previous_nearest_depth : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH); + +void StoreReconstructedDepth(FfxUInt32x2 iPxSample, FfxFloat32 fDepth) +{ + FfxUInt32 uDepth = asuint(fDepth); + +#if FFX_FSR3UPSCALER_OPTION_INVERTED_DEPTH + InterlockedMax(rw_reconstructed_previous_nearest_depth[iPxSample], uDepth); +#else + InterlockedMin(rw_reconstructed_previous_nearest_depth[iPxSample], uDepth); // min for standard, max for inverted depth +#endif +} + +void SetReconstructedDepth(FfxUInt32x2 iPxSample, const FfxUInt32 uValue) +{ + rw_reconstructed_previous_nearest_depth[iPxSample] = uValue; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_DILATED_DEPTH) +RWTexture2D rw_dilated_depth : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_DILATED_DEPTH); + +void StoreDilatedDepth(FFX_PARAMETER_IN FfxUInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32 fDepth) +{ + rw_dilated_depth[iPxPos] = fDepth; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_DILATED_MOTION_VECTORS) +RWTexture2D rw_dilated_motion_vectors : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_DILATED_MOTION_VECTORS); + +void StoreDilatedMotionVector(FFX_PARAMETER_IN FfxUInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x2 fMotionVector) +{ + rw_dilated_motion_vectors[iPxPos] = fMotionVector; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_DILATED_MOTION_VECTORS) +Texture2D r_dilated_motion_vectors : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_DILATED_MOTION_VECTORS); + +FfxFloat32x2 LoadDilatedMotionVector(FfxUInt32x2 iPxInput) +{ + return r_dilated_motion_vectors[iPxInput]; +} + +FfxFloat32x2 SampleDilatedMotionVector(FfxFloat32x2 fUV) +{ + return r_dilated_motion_vectors.SampleLevel(s_LinearClamp, fUV, 0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_DILATED_DEPTH) +Texture2D r_dilated_depth : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_DILATED_DEPTH); + +FfxFloat32 LoadDilatedDepth(FfxUInt32x2 iPxInput) +{ + return r_dilated_depth[iPxInput]; +} + +FfxFloat32 SampleDilatedDepth(FfxFloat32x2 fUV) +{ + return r_dilated_depth.SampleLevel(s_LinearClamp, fUV, 0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_INPUT_EXPOSURE) +Texture2D r_input_exposure : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_INPUT_EXPOSURE); + +FfxFloat32 Exposure() +{ + FfxFloat32 exposure = r_input_exposure[FfxUInt32x2(0, 0)].x; + +#if defined(__XBOX_SCARLETT) + if (exposure < 0.000030517578/** 2^-15 */) { + exposure = 1.0f; + } +#else + if (exposure == 0.0f) { + exposure = 1.0f; + } +#endif // #if defined(__XBOX_SCARLETT) + + return exposure; +} +#endif + +// BEGIN: FSR3UPSCALER_BIND_SRV_LANCZOS_LUT +#if defined(FSR3UPSCALER_BIND_SRV_LANCZOS_LUT) +Texture2D r_lanczos_lut : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_LANCZOS_LUT); +#endif + +FfxFloat32 SampleLanczos2Weight(FfxFloat32 x) +{ +#if defined(FSR3UPSCALER_BIND_SRV_LANCZOS_LUT) + return r_lanczos_lut.SampleLevel(s_LinearClamp, FfxFloat32x2(x / 2, 0.5f), 0); +#else + return 0.f; +#endif +} +// END: FSR3UPSCALER_BIND_SRV_LANCZOS_LUT + +#if defined(FSR3UPSCALER_BIND_SRV_DILATED_REACTIVE_MASKS) +Texture2D r_dilated_reactive_masks : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_DILATED_REACTIVE_MASKS); + +FfxFloat32x4 SampleDilatedReactiveMasks(FfxFloat32x2 fUV) +{ + return r_dilated_reactive_masks.SampleLevel(s_LinearClamp, fUV, 0); +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_DILATED_REACTIVE_MASKS) +RWTexture2D rw_dilated_reactive_masks : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_DILATED_REACTIVE_MASKS); + +void StoreDilatedReactiveMasks(FFX_PARAMETER_IN FfxUInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x4 fDilatedReactiveMasks) +{ + rw_dilated_reactive_masks[iPxPos] = fDilatedReactiveMasks; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_INPUT_OPAQUE_ONLY) +Texture2D r_input_opaque_only : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_INPUT_OPAQUE_ONLY); + +FfxFloat32x3 LoadOpaqueOnly(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos) +{ + return r_input_opaque_only[iPxPos].xyz; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_PREV_PRE_ALPHA_COLOR) +Texture2D r_input_prev_color_pre_alpha : FFX_FSR3UPSCALER_DECLARE_SRV(FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR); + +FfxFloat32x3 LoadPrevPreAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos) +{ + return r_input_prev_color_pre_alpha[iPxPos]; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_PREV_POST_ALPHA_COLOR) +Texture2D r_input_prev_color_post_alpha : FFX_FSR3UPSCALER_DECLARE_SRV(FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR); + +FfxFloat32x3 LoadPrevPostAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos) +{ + return r_input_prev_color_post_alpha[iPxPos]; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_AUTOREACTIVE) && \ + defined(FSR3UPSCALER_BIND_UAV_AUTOCOMPOSITION) + +RWTexture2D rw_output_autoreactive : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_AUTOREACTIVE); +RWTexture2D rw_output_autocomposition : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_AUTOCOMPOSITION); + +void StoreAutoReactive(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos, FFX_PARAMETER_IN FFX_MIN16_F2 fReactive) +{ + rw_output_autoreactive[iPxPos] = fReactive.x; + + rw_output_autocomposition[iPxPos] = fReactive.y; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_PREV_PRE_ALPHA_COLOR) +RWTexture2D rw_output_prev_color_pre_alpha : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_PREV_PRE_ALPHA_COLOR); + +void StorePrevPreAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos, FFX_PARAMETER_IN FFX_MIN16_F3 color) +{ + rw_output_prev_color_pre_alpha[iPxPos] = color; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_PREV_POST_ALPHA_COLOR) +RWTexture2D rw_output_prev_color_post_alpha : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_PREV_POST_ALPHA_COLOR); + +void StorePrevPostAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos, FFX_PARAMETER_IN FFX_MIN16_F3 color) +{ + rw_output_prev_color_post_alpha[iPxPos] = color; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_FRAME_INFO) +RWTexture2D rw_frame_info : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_FRAME_INFO); + +FfxFloat32x4 LoadFrameInfo() +{ + return rw_frame_info[FfxInt32x2(0, 0)]; +} + +void StoreFrameInfo(FfxFloat32x4 fInfo) +{ + rw_frame_info[FfxInt32x2(0, 0)] = fInfo; +} +#endif + +#if defined(FSR3UPSCALER_BIND_SRV_FRAME_INFO) +Texture2D r_frame_info : FFX_FSR3UPSCALER_DECLARE_SRV(FSR3UPSCALER_BIND_SRV_FRAME_INFO); + +FfxFloat32x4 FrameInfo() +{ + return r_frame_info[FfxInt32x2(0, 0)]; +} +#endif + +#if defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_0) && \ + defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_1) && \ + defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_2) && \ + defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_3) && \ + defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_4) && \ + defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_5) + +RWTexture2D rw_spd_mip0 : FFX_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_0); +RWTexture2D rw_spd_mip1 : FFX_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_1); +RWTexture2D rw_spd_mip2 : FFX_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_2); +RWTexture2D rw_spd_mip3 : FFX_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_3); +RWTexture2D rw_spd_mip4 : FFX_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_4); +globallycoherent RWTexture2D rw_spd_mip5 : FFX_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_5); + +FfxFloat32x2 RWLoadPyramid(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 index) +{ +#define LOAD(idx) \ + if (index == idx) \ + { \ + return rw_spd_mip##idx[iPxPos]; \ + } + LOAD(0); + LOAD(1); + LOAD(2); + LOAD(3); + LOAD(4); + LOAD(5); + + return 0; + +#undef LOAD +} + +void StorePyramid(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x2 outValue, FFX_PARAMETER_IN FfxUInt32 index) +{ +#define STORE(idx) \ + if (index == idx) \ + { \ + rw_spd_mip##idx[iPxPos] = outValue; \ + } + + STORE(0); + STORE(1); + STORE(2); + STORE(3); + STORE(4); + STORE(5); + +#undef STORE +} +#endif + +#if defined FSR3UPSCALER_BIND_UAV_SPD_GLOBAL_ATOMIC +globallycoherent RWTexture2D rw_spd_global_atomic : FFX_FSR3UPSCALER_DECLARE_UAV(FSR3UPSCALER_BIND_UAV_SPD_GLOBAL_ATOMIC); + +void SPD_IncreaseAtomicCounter(inout FfxUInt32 spdCounter) +{ + InterlockedAdd(rw_spd_global_atomic[FfxInt32x2(0, 0)], 1, spdCounter); +} + +void SPD_ResetAtomicCounter() +{ + rw_spd_global_atomic[FfxInt32x2(0, 0)] = 0; +} +#endif + +#endif // #if defined(FFX_GPU) diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_common.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_common.h new file mode 100644 index 00000000..87aa596d --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_common.h @@ -0,0 +1,403 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#if !defined(FFX_FSR3UPSCALER_COMMON_H) +#define FFX_FSR3UPSCALER_COMMON_H + +#if defined(FFX_GPU) +#pragma warning(error : 3206) // treat vector truncation warnings as errors +#pragma warning(disable : 3205) // conversion from larger type to smaller +#pragma warning(disable : 3571) // in ffxPow(f, e), f could be negative + +FFX_STATIC const FfxFloat32 FSR3UPSCALER_FP16_MIN = 6.10e-05f; +FFX_STATIC const FfxFloat32 FSR3UPSCALER_FP16_MAX = 65504.0f; +FFX_STATIC const FfxFloat32 FSR3UPSCALER_EPSILON = FSR3UPSCALER_FP16_MIN; +FFX_STATIC const FfxFloat32 FSR3UPSCALER_TONEMAP_EPSILON = FSR3UPSCALER_FP16_MIN; +FFX_STATIC const FfxFloat32 FSR3UPSCALER_FP32_MAX = 3.402823466e+38f; +FFX_STATIC const FfxFloat32 FSR3UPSCALER_FP32_MIN = 1.175494351e-38f; + +// Reconstructed depth usage +FFX_STATIC const FfxFloat32 fReconstructedDepthBilinearWeightThreshold = FSR3UPSCALER_EPSILON * 10; + +FfxFloat32 ReconstructedDepthMvPxThreshold(FfxFloat32 fNearestDepthInMeters) +{ + return ffxLerp(0.25f, 0.75f, ffxSaturate(fNearestDepthInMeters / 100.0f)); +} + +// Accumulation +FFX_STATIC const FfxFloat32 fUpsampleLanczosWeightScale = 1.0f / 16.0f; +FFX_STATIC const FfxFloat32 fAverageLanczosWeightPerFrame = 0.74f * fUpsampleLanczosWeightScale; // Average lanczos weight for jitter accumulated samples +FFX_STATIC const FfxFloat32 fAccumulationMaxOnMotion = 3.0f * fUpsampleLanczosWeightScale; + +#define SHADING_CHANGE_SET_SIZE 5 +FFX_STATIC const FfxInt32 iShadingChangeMipStart = 0; +FFX_STATIC const FfxFloat32 fShadingChangeSamplePow = 1.0f / 1.0f; + + +FFX_STATIC const FfxFloat32 fLockThreshold = 1.0f; +FFX_STATIC const FfxFloat32 fLockMax = 2.0f; + +FFX_STATIC const FfxInt32 REACTIVE = 0; +FFX_STATIC const FfxInt32 DISOCCLUSION = 1; +FFX_STATIC const FfxInt32 SHADING_CHANGE = 2; +FFX_STATIC const FfxInt32 ACCUMULAION = 3; + +FFX_STATIC const FfxInt32 FRAME_INFO_EXPOSURE = 0; +FFX_STATIC const FfxInt32 FRAME_INFO_LOG_LUMA = 1; +FFX_STATIC const FfxInt32 FRAME_INFO_SCENE_AVERAGE_LUMA = 2; + +FfxBoolean TonemapFirstFrame() +{ + const FfxBoolean bEnabled = true; + return FrameIndex() == 0 && bEnabled; +} + +FfxFloat32 AverageLanczosWeightPerFrame() +{ + return 0.74f; +} + +FfxInt32x2 ShadingChangeRenderSize() +{ + return FfxInt32x2(RenderSize() * 0.5f); +} + +FfxInt32x2 ShadingChangeMaxRenderSize() +{ + return FfxInt32x2(MaxRenderSize() * 0.5f); +} + +FfxInt32x2 PreviousFrameShadingChangeRenderSize() +{ + return FfxInt32x2(PreviousFrameRenderSize() * 0.5f); +} + +#if defined(FSR3UPSCALER_BIND_SRV_FRAME_INFO) +FfxFloat32 SceneAverageLuma() +{ + return FrameInfo()[FRAME_INFO_SCENE_AVERAGE_LUMA]; +} +#endif + +// Auto exposure +FFX_STATIC const FfxFloat32 resetAutoExposureAverageSmoothing = 1e4f; + +struct AccumulationPassCommonParams +{ + FfxInt32x2 iPxHrPos; + FfxFloat32x2 fHrUv; + FfxFloat32x2 fLrUvJittered; + FfxFloat32x2 fLrUv_HwSampler; + FfxFloat32x2 fMotionVector; + FfxFloat32x2 fReprojectedHrUv; + FfxFloat32 f4KVelocity; + FfxFloat32 fDisocclusion; + FfxFloat32 fReactiveMask; + FfxFloat32 fShadingChange; + FfxFloat32 fAccumulation; + FfxFloat32 fLumaInstabilityFactor; + FfxFloat32 fFarthestDepthInMeters; + + FfxBoolean bIsExistingSample; + FfxBoolean bIsNewSample; +}; + +FfxFloat32 Get4KVelocity(FfxFloat32x2 fMotionVector) +{ + return length(fMotionVector * FfxFloat32x2(3840.0f, 2160.0f)); +} + +struct RectificationBox +{ + FfxFloat32x3 boxCenter; + FfxFloat32x3 boxVec; + FfxFloat32x3 aabbMin; + FfxFloat32x3 aabbMax; + FfxFloat32 fBoxCenterWeight; +}; + +struct AccumulationPassData +{ + RectificationBox clippingBox; + FfxFloat32x3 fUpsampledColor; + FfxFloat32 fUpsampledWeight; + FfxFloat32x3 fHistoryColor; + FfxFloat32 fHistoryWeight; + FfxFloat32 fLock; + FfxFloat32 fLockContributionThisFrame; +}; + +void RectificationBoxAddInitialSample(FFX_PARAMETER_INOUT RectificationBox rectificationBox, const FfxFloat32x3 colorSample, const FfxFloat32 fSampleWeight) +{ + rectificationBox.aabbMin = colorSample; + rectificationBox.aabbMax = colorSample; + + FfxFloat32x3 weightedSample = colorSample * fSampleWeight; + rectificationBox.boxCenter = weightedSample; + rectificationBox.boxVec = colorSample * weightedSample; + rectificationBox.fBoxCenterWeight = fSampleWeight; +} + +void RectificationBoxAddSample(FfxBoolean bInitialSample, FFX_PARAMETER_INOUT RectificationBox rectificationBox, const FfxFloat32x3 colorSample, const FfxFloat32 fSampleWeight) +{ + if (bInitialSample) { + RectificationBoxAddInitialSample(rectificationBox, colorSample, fSampleWeight); + } else { + rectificationBox.aabbMin = ffxMin(rectificationBox.aabbMin, colorSample); + rectificationBox.aabbMax = ffxMax(rectificationBox.aabbMax, colorSample); + + FfxFloat32x3 weightedSample = colorSample * fSampleWeight; + rectificationBox.boxCenter += weightedSample; + rectificationBox.boxVec += colorSample * weightedSample; + rectificationBox.fBoxCenterWeight += fSampleWeight; + } +} + +void RectificationBoxComputeVarianceBoxData(FFX_PARAMETER_INOUT RectificationBox rectificationBox) +{ + rectificationBox.fBoxCenterWeight = (abs(rectificationBox.fBoxCenterWeight) > FfxFloat32(FSR3UPSCALER_FP32_MIN) ? rectificationBox.fBoxCenterWeight : FfxFloat32(1.f)); + rectificationBox.boxCenter /= rectificationBox.fBoxCenterWeight; + rectificationBox.boxVec /= rectificationBox.fBoxCenterWeight; + FfxFloat32x3 stdDev = sqrt(abs(rectificationBox.boxVec - rectificationBox.boxCenter * rectificationBox.boxCenter)); + rectificationBox.boxVec = stdDev; +} + +FfxFloat32x3 SafeRcp3(FfxFloat32x3 v) +{ + return (all(FFX_NOT_EQUAL(v, FfxFloat32x3(0, 0, 0)))) ? (FfxFloat32x3(1, 1, 1) / v) : FfxFloat32x3(0, 0, 0); +} + +FfxFloat32 MinDividedByMax(const FfxFloat32 v0, const FfxFloat32 v1, const FfxFloat32 fOnZeroReturnValue) +{ + const FfxFloat32 m = ffxMax(v0, v1); + return m != 0 ? ffxMin(v0, v1) / m : fOnZeroReturnValue; +} + +FfxFloat32 MinDividedByMax(const FfxFloat32 v0, const FfxFloat32 v1) +{ + const FfxFloat32 m = ffxMax(v0, v1); + return m != 0 ? ffxMin(v0, v1) / m : 0; +} + +FfxFloat32x3 YCoCgToRGB(FfxFloat32x3 fYCoCg) +{ + FfxFloat32x3 fRgb; + + fRgb = FfxFloat32x3( + fYCoCg.x + fYCoCg.y - fYCoCg.z, + fYCoCg.x + fYCoCg.z, + fYCoCg.x - fYCoCg.y - fYCoCg.z); + + return fRgb; +} + +FfxFloat32x3 RGBToYCoCg(FfxFloat32x3 fRgb) +{ + FfxFloat32x3 fYCoCg; + + fYCoCg = FfxFloat32x3( + 0.25f * fRgb.r + 0.5f * fRgb.g + 0.25f * fRgb.b, + 0.5f * fRgb.r - 0.5f * fRgb.b, + -0.25f * fRgb.r + 0.5f * fRgb.g - 0.25f * fRgb.b); + + return fYCoCg; +} + +FfxFloat32 RGBToLuma(FfxFloat32x3 fLinearRgb) +{ + return dot(fLinearRgb, FfxFloat32x3(0.2126f, 0.7152f, 0.0722f)); +} + +FfxFloat32 RGBToPerceivedLuma(FfxFloat32x3 fLinearRgb) +{ + FfxFloat32 fLuminance = RGBToLuma(fLinearRgb); + + FfxFloat32 fPercievedLuminance = 0; + if (fLuminance <= 216.0f / 24389.0f) { + fPercievedLuminance = fLuminance * (24389.0f / 27.0f); + } + else { + fPercievedLuminance = ffxPow(fLuminance, 1.0f / 3.0f) * 116.0f - 16.0f; + } + + return fPercievedLuminance * 0.01f; +} + +FfxFloat32x3 Tonemap(FfxFloat32x3 fRgb) +{ + return fRgb / (ffxMax(ffxMax(0.f, fRgb.r), ffxMax(fRgb.g, fRgb.b)) + 1.f).xxx; +} + +FfxFloat32x3 InverseTonemap(FfxFloat32x3 fRgb) +{ + return fRgb / ffxMax(FSR3UPSCALER_TONEMAP_EPSILON, 1.f - ffxMax(fRgb.r, ffxMax(fRgb.g, fRgb.b))).xxx; +} + +FfxBoolean IsUvInside(FfxFloat32x2 fUv) +{ + return (fUv.x >= 0.0f && fUv.x <= 1.0f) && (fUv.y >= 0.0f && fUv.y <= 1.0f); +} + +FfxInt32x2 ClampLoad(FfxInt32x2 iPxSample, FfxInt32x2 iPxOffset, FfxInt32x2 iTextureSize) +{ + FfxInt32x2 result = iPxSample + iPxOffset; + result.x = ffxMax(0, ffxMin(result.x, iTextureSize.x - 1)); + result.y = ffxMax(0, ffxMin(result.y, iTextureSize.y - 1)); + return result; +} + +FfxFloat32x2 ClampUv(FfxFloat32x2 fUv, FfxInt32x2 iTextureSize, FfxInt32x2 iResourceSize) +{ + const FfxFloat32x2 fSampleLocation = fUv * iTextureSize; + const FfxFloat32x2 fClampedLocation = ffxMax(FfxFloat32x2(0.5f, 0.5f), ffxMin(fSampleLocation, FfxFloat32x2(iTextureSize) - FfxFloat32x2(0.5f, 0.5f))); + const FfxFloat32x2 fClampedUv = fClampedLocation / FfxFloat32x2(iResourceSize); + + return fClampedUv; +} + +FfxBoolean IsOnScreen(FfxInt32x2 pos, FfxInt32x2 size) +{ + return all(FFX_LESS_THAN(FfxUInt32x2(pos), FfxUInt32x2(size))); +} + +FfxFloat32 ComputeAutoExposureFromLavg(FfxFloat32 Lavg) +{ + Lavg = exp(Lavg); + + const FfxFloat32 S = 100.0f; //ISO arithmetic speed + const FfxFloat32 K = 12.5f; + FfxFloat32 ExposureISO100 = log2((Lavg * S) / K); + + const FfxFloat32 q = 0.65f; + FfxFloat32 Lmax = (78.0f / (q * S)) * ffxPow(2.0f, ExposureISO100); + + return 1.0f / Lmax; +} + +FfxInt32x2 ComputeHrPosFromLrPos(FfxInt32x2 iPxLrPos) +{ + FfxFloat32x2 fSrcJitteredPos = FfxFloat32x2(iPxLrPos) + 0.5f - Jitter(); + FfxFloat32x2 fLrPosInHr = (fSrcJitteredPos / RenderSize()) * UpscaleSize(); + FfxInt32x2 iPxHrPos = FfxInt32x2(floor(fLrPosInHr)); + return iPxHrPos; +} + +FfxFloat32x2 ComputeNdc(FfxFloat32x2 fPxPos, FfxInt32x2 iSize) +{ + return fPxPos / FfxFloat32x2(iSize) * FfxFloat32x2(2.0f, -2.0f) + FfxFloat32x2(-1.0f, 1.0f); +} + +FfxFloat32 GetViewSpaceDepth(FfxFloat32 fDeviceDepth) +{ + const FfxFloat32x4 fDeviceToViewDepth = DeviceToViewSpaceTransformFactors(); + + // fDeviceToViewDepth details found in ffx_fsr3upscaler.cpp + return (fDeviceToViewDepth[1] / (fDeviceDepth - fDeviceToViewDepth[0])); +} + +FfxFloat32 GetViewSpaceDepthInMeters(FfxFloat32 fDeviceDepth) +{ + return GetViewSpaceDepth(fDeviceDepth) * ViewSpaceToMetersFactor(); +} + +FfxFloat32x3 GetViewSpacePosition(FfxInt32x2 iViewportPos, FfxInt32x2 iViewportSize, FfxFloat32 fDeviceDepth) +{ + const FfxFloat32x4 fDeviceToViewDepth = DeviceToViewSpaceTransformFactors(); + + const FfxFloat32 Z = GetViewSpaceDepth(fDeviceDepth); + + const FfxFloat32x2 fNdcPos = ComputeNdc(iViewportPos, iViewportSize); + const FfxFloat32 X = fDeviceToViewDepth[2] * fNdcPos.x * Z; + const FfxFloat32 Y = fDeviceToViewDepth[3] * fNdcPos.y * Z; + + return FfxFloat32x3(X, Y, Z); +} + +FfxFloat32x3 GetViewSpacePositionInMeters(FfxInt32x2 iViewportPos, FfxInt32x2 iViewportSize, FfxFloat32 fDeviceDepth) +{ + return GetViewSpacePosition(iViewportPos, iViewportSize, fDeviceDepth) * ViewSpaceToMetersFactor(); +} + +FfxFloat32 GetMaxDistanceInMeters() +{ +#if FFX_FSR3UPSCALER_OPTION_INVERTED_DEPTH + return GetViewSpaceDepth(0.0f) * ViewSpaceToMetersFactor(); +#else + return GetViewSpaceDepth(1.0f) * ViewSpaceToMetersFactor(); +#endif +} + + +struct BilinearSamplingData +{ + FfxInt32x2 iOffsets[4]; + FfxFloat32 fWeights[4]; + FfxInt32x2 iBasePos; +}; + +BilinearSamplingData GetBilinearSamplingData(FfxFloat32x2 fUv, FfxInt32x2 iSize) +{ + BilinearSamplingData data; + + FfxFloat32x2 fPxSample = (fUv * iSize) - FfxFloat32x2(0.5f, 0.5f); + data.iBasePos = FfxInt32x2(floor(fPxSample)); + FfxFloat32x2 fPxFrac = ffxFract(fPxSample); + + data.iOffsets[0] = FfxInt32x2(0, 0); + data.iOffsets[1] = FfxInt32x2(1, 0); + data.iOffsets[2] = FfxInt32x2(0, 1); + data.iOffsets[3] = FfxInt32x2(1, 1); + + data.fWeights[0] = (1 - fPxFrac.x) * (1 - fPxFrac.y); + data.fWeights[1] = (fPxFrac.x) * (1 - fPxFrac.y); + data.fWeights[2] = (1 - fPxFrac.x) * (fPxFrac.y); + data.fWeights[3] = (fPxFrac.x) * (fPxFrac.y); + + return data; +} + +struct PlaneData +{ + FfxFloat32x3 fNormal; + FfxFloat32 fDistanceFromOrigin; +}; + +PlaneData GetPlaneFromPoints(FfxFloat32x3 fP0, FfxFloat32x3 fP1, FfxFloat32x3 fP2) +{ + PlaneData plane; + + FfxFloat32x3 v0 = fP0 - fP1; + FfxFloat32x3 v1 = fP0 - fP2; + plane.fNormal = normalize(cross(v0, v1)); + plane.fDistanceFromOrigin = -dot(fP0, plane.fNormal); + + return plane; +} + +FfxFloat32 PointToPlaneDistance(PlaneData plane, FfxFloat32x3 fPoint) +{ + return abs(dot(plane.fNormal, fPoint) + plane.fDistanceFromOrigin); +} + +#endif // #if defined(FFX_GPU) + +#endif //!defined(FFX_FSR3UPSCALER_COMMON_H) diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_debug_view.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_debug_view.h new file mode 100644 index 00000000..6f4fa33f --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_debug_view.h @@ -0,0 +1,159 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +struct FfxDebugViewport +{ + FfxInt32x2 offset; + FfxInt32x2 size; +}; + +// Macro to cull and draw debug viewport +#define DRAW_VIEWPORT(function, pos, vp) \ + { \ + if (pointIsInsideViewport(pos, vp)) \ + { \ + function(pos, vp); \ + } \ + } + +FfxFloat32x2 getTransformedUv(FfxInt32x2 iPxPos, FfxDebugViewport vp) +{ + FfxFloat32x2 fUv = (FfxFloat32x2(iPxPos - vp.offset) + 0.5f) / vp.size; + + return fUv; +} + +FfxFloat32x3 getMotionVectorColor(FfxFloat32x2 fMotionVector) +{ + return FfxFloat32x3(0.5f + fMotionVector * RenderSize() * 0.5f, 0.5f); +} + +FfxFloat32x4 getUnusedIndicationColor(FfxInt32x2 iPxPos, FfxDebugViewport vp) +{ + FfxInt32x2 basePos = iPxPos - vp.offset; + + FfxFloat32 ar = FfxFloat32(vp.size.x) / FfxFloat32(vp.size.y); + + return FfxFloat32x4(basePos.x == FfxInt32(basePos.y * ar), 0, 0, 1); +} + +void drawDilatedMotionVectors(FfxInt32x2 iPxPos, FfxDebugViewport vp) +{ + FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp); + + FfxFloat32x2 fUv_HW = ClampUv(fUv, RenderSize(), MaxRenderSize()); + + FfxFloat32x2 fMotionVector = SampleDilatedMotionVector(fUv_HW); + + StoreUpscaledOutput(iPxPos, getMotionVectorColor(fMotionVector)); +} + +void drawDisocclusionMask(FfxInt32x2 iPxPos, FfxDebugViewport vp) +{ + FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp); + + FfxFloat32x2 fUv_HW = ClampUv(fUv, RenderSize(), MaxRenderSize()); + + FfxFloat32 fDisocclusionFactor = ffxSaturate(SampleDilatedReactiveMasks(fUv_HW)[DISOCCLUSION]); + + StoreUpscaledOutput(iPxPos, FfxFloat32x3(0, fDisocclusionFactor, 0)); +} + +void drawDetailProtectionTakedown(FfxInt32x2 iPxPos, FfxDebugViewport vp) +{ + FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp); + + FfxFloat32x2 fUv_HW = ClampUv(fUv, RenderSize(), MaxRenderSize()); + + FfxFloat32 fProtectionTakedown = ffxSaturate(SampleDilatedReactiveMasks(fUv_HW)[REACTIVE]); + + StoreUpscaledOutput(iPxPos, FfxFloat32x3(0, fProtectionTakedown, 0)); +} + +void drawReactiveness(FfxInt32x2 iPxPos, FfxDebugViewport vp) +{ + FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp); + + FfxFloat32x2 fUv_HW = ClampUv(fUv, RenderSize(), MaxRenderSize()); + + FfxFloat32 fShadingChange = ffxSaturate(SampleDilatedReactiveMasks(fUv_HW)[SHADING_CHANGE]); + + StoreUpscaledOutput(iPxPos, FfxFloat32x3(0, fShadingChange, 0)); +} + +void drawProtectedAreas(FfxInt32x2 iPxPos, FfxDebugViewport vp) +{ + FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp); + + FfxFloat32 fProtection = ffxSaturate(SampleHistory(fUv).w - fLockThreshold); + + StoreUpscaledOutput(iPxPos, FfxFloat32x3(fProtection, 0, 0)); +} + +void drawDilatedDepthInMeters(FfxInt32x2 iPxPos, FfxDebugViewport vp) +{ + FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp); + + FfxFloat32x2 fUv_HW = ClampUv(fUv, RenderSize(), MaxRenderSize()); + + const FfxFloat32 fDilatedDepth = SampleDilatedDepth(fUv_HW); + const FfxFloat32 fDepthInMeters = GetViewSpaceDepthInMeters(fDilatedDepth); + + StoreUpscaledOutput(iPxPos, FfxFloat32x3(ffxSaturate(fDepthInMeters / 25.0f), 0, 0)); +} + +FfxBoolean pointIsInsideViewport(FfxInt32x2 iPxPos, FfxDebugViewport vp) +{ + FfxInt32x2 extent = vp.offset + vp.size; + + return (iPxPos.x >= vp.offset.x && iPxPos.x < extent.x) && (iPxPos.y >= vp.offset.y && iPxPos.y < extent.y); +} + +void DebugView(FfxInt32x2 iPxPos) +{ +#define VIEWPORT_GRID_SIZE_X 3 +#define VIEWPORT_GRID_SIZE_Y 3 + + FfxFloat32x2 fViewportScale = FfxFloat32x2(1.0f / VIEWPORT_GRID_SIZE_X, 1.0f / VIEWPORT_GRID_SIZE_Y); + FfxInt32x2 iViewportSize = FfxInt32x2(UpscaleSize() * fViewportScale); + + // compute grid [y][x] for easier placement of viewports + FfxDebugViewport vp[VIEWPORT_GRID_SIZE_Y][VIEWPORT_GRID_SIZE_X]; + for (FfxInt32 y = 0; y < VIEWPORT_GRID_SIZE_Y; y++) + { + for (FfxInt32 x = 0; x < VIEWPORT_GRID_SIZE_X; x++) + { + vp[y][x].offset = iViewportSize * FfxInt32x2(x, y); + vp[y][x].size = iViewportSize; + } + } + + // top row + DRAW_VIEWPORT(drawDilatedMotionVectors, iPxPos, vp[0][0]); + DRAW_VIEWPORT(drawProtectedAreas, iPxPos, vp[0][1]); + DRAW_VIEWPORT(drawDilatedDepthInMeters, iPxPos, vp[0][2]); + + // bottom row + DRAW_VIEWPORT(drawDisocclusionMask, iPxPos, vp[2][0]); + DRAW_VIEWPORT(drawReactiveness, iPxPos, vp[2][1]); + DRAW_VIEWPORT(drawDetailProtectionTakedown, iPxPos, vp[2][2]); +} diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_luma_instability.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_luma_instability.h new file mode 100644 index 00000000..624b7ca9 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_luma_instability.h @@ -0,0 +1,115 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +struct LumaInstabilityFactorData +{ + FfxFloat32x4 fLumaHistory; + FfxFloat32 fLumaInstabilityFactor; +}; + +LumaInstabilityFactorData ComputeLumaInstabilityFactor(LumaInstabilityFactorData data, FfxFloat32 fCurrentFrameLuma, FfxFloat32 fFarthestDepthInMeters) +{ + const FfxInt32 N_MINUS_1 = 0; + const FfxInt32 N_MINUS_2 = 1; + const FfxInt32 N_MINUS_3 = 2; + const FfxInt32 N_MINUS_4 = 3; + + FfxFloat32 fLumaInstability = 0.0f; + const FfxFloat32 fDiffs0 = (fCurrentFrameLuma - data.fLumaHistory[N_MINUS_1]); + const FfxFloat32 fSimilarity0 = MinDividedByMax(fCurrentFrameLuma, data.fLumaHistory[N_MINUS_1], 1.0f); + + FfxFloat32 fMaxSimilarity = fSimilarity0; + + if (fSimilarity0 < 1.0f) { + for (int i = N_MINUS_2; i <= N_MINUS_4; i++) { + const FfxFloat32 fDiffs1 = (fCurrentFrameLuma - data.fLumaHistory[i]); + const FfxFloat32 fSimilarity1 = MinDividedByMax(fCurrentFrameLuma, data.fLumaHistory[i]); + + if (sign(fDiffs0) == sign(fDiffs1)) { + + fMaxSimilarity = ffxMax(fMaxSimilarity, fSimilarity1); + } + } + + fLumaInstability = FfxFloat32(fMaxSimilarity > fSimilarity0); + } + + // Shift history + data.fLumaHistory[N_MINUS_4] = data.fLumaHistory[N_MINUS_3]; + data.fLumaHistory[N_MINUS_3] = data.fLumaHistory[N_MINUS_2]; + data.fLumaHistory[N_MINUS_2] = data.fLumaHistory[N_MINUS_1]; + data.fLumaHistory[N_MINUS_1] = fCurrentFrameLuma; + + data.fLumaHistory /= Exposure(); + + data.fLumaInstabilityFactor = fLumaInstability * FfxFloat32(data.fLumaHistory[N_MINUS_4] != 0); + + return data; +} + +void LumaInstability(FfxInt32x2 iPxPos) +{ + LumaInstabilityFactorData data; + data.fLumaInstabilityFactor = 0.0f; + data.fLumaHistory = FfxFloat32x4(0.0f, 0.0f, 0.0f, 0.0f); + + const FfxFloat32x2 fDilatedMotionVector = LoadDilatedMotionVector(iPxPos); + const FfxFloat32x2 fUv = (iPxPos + 0.5f) / RenderSize(); + const FfxFloat32x2 fUvCurrFrameJittered = fUv + Jitter() / RenderSize(); + const FfxFloat32x2 fUvPrevFrameJittered = fUv + PreviousFrameJitter() / PreviousFrameRenderSize(); + const FfxFloat32x2 fReprojectedUv = fUvPrevFrameJittered + fDilatedMotionVector; + + if (IsUvInside(fReprojectedUv)) + { + const FfxFloat32x2 fUvReactive_HW = ClampUv(fUvCurrFrameJittered, RenderSize(), MaxRenderSize()); + + const FfxFloat32x4 fDilatedReactiveMasks = SampleDilatedReactiveMasks(fUvReactive_HW); + const FfxFloat32 fReactiveMask = ffxSaturate(fDilatedReactiveMasks[REACTIVE]); + const FfxFloat32 fDisocclusion = ffxSaturate(fDilatedReactiveMasks[DISOCCLUSION]); + const FfxFloat32 fShadingChange = ffxSaturate(fDilatedReactiveMasks[SHADING_CHANGE]); + const FfxFloat32 fAccumulation = ffxSaturate(fDilatedReactiveMasks[ACCUMULAION]); + + const FfxBoolean bAccumulationFactor = fAccumulation > 0.9f; + + const FfxBoolean bComputeInstability = bAccumulationFactor; + + if (bComputeInstability) { + + const FfxFloat32x2 fUv_HW = ClampUv(fUvCurrFrameJittered, RenderSize(), MaxRenderSize()); + const FfxFloat32 fCurrentFrameLuma = SampleCurrentLuma(fUv_HW) * Exposure(); + + const FfxFloat32x2 fReprojectedUv_HW = ClampUv(fReprojectedUv, PreviousFrameRenderSize(), MaxRenderSize()); + data.fLumaHistory = SampleLumaHistory(fReprojectedUv_HW) * DeltaPreExposure() * Exposure(); + + const FfxFloat32x2 fFarthestDepthUv_HW = ClampUv(fUvCurrFrameJittered, RenderSize() / 2, GetFarthestDepthMip1ResourceDimensions()); + const FfxFloat32 fFarthestDepthInMeters = SampleFarthestDepthMip1(fFarthestDepthUv_HW); + + data = ComputeLumaInstabilityFactor(data, fCurrentFrameLuma, fFarthestDepthInMeters); + + const FfxFloat32 fVelocityWeight = 1.0f - ffxSaturate(Get4KVelocity(fDilatedMotionVector) / 20.0f); + data.fLumaInstabilityFactor *= fVelocityWeight * (1.0f - fDisocclusion) * (1.0f - fReactiveMask) * (1.0f - fShadingChange); + } + } + + StoreLumaHistory(iPxPos, data.fLumaHistory); + StoreLumaInstability(iPxPos, data.fLumaInstabilityFactor); +} diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_luma_pyramid.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_luma_pyramid.h new file mode 100644 index 00000000..41c5dc7f --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_luma_pyramid.h @@ -0,0 +1,192 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +FFX_GROUPSHARED FfxUInt32 spdCounter; + +void SpdIncreaseAtomicCounter(FfxUInt32 slice) +{ + SPD_IncreaseAtomicCounter(spdCounter); +} + +FfxUInt32 SpdGetAtomicCounter() +{ + return spdCounter; +} + +void SpdResetAtomicCounter(FfxUInt32 slice) +{ + SPD_ResetAtomicCounter(); +} + +#ifndef SPD_PACKED_ONLY +FFX_GROUPSHARED FfxFloat32 spdIntermediateR[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateG[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateB[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateA[16][16]; + +FFX_STATIC const FfxInt32 LOG_LUMA = 0; +FFX_STATIC const FfxInt32 LUMA = 1; +FFX_STATIC const FfxInt32 DEPTH_IN_METERS = 2; + +FfxFloat32x4 SpdLoadSourceImage(FfxFloat32x2 iPxPos, FfxUInt32 slice) +{ + //We assume linear data. if non-linear input (sRGB, ...), + //then we should convert to linear first and back to sRGB on output. + const FfxInt32x2 iPxSamplePos = ClampLoad(FfxInt32x2(iPxPos), FfxInt32x2(0, 0), FfxInt32x2(RenderSize())); + + const FfxFloat32 fLuma = LoadCurrentLuma(iPxSamplePos); + const FfxFloat32 fLogLuma = ffxMax(FSR3UPSCALER_EPSILON, log(fLuma)); + const FfxFloat32 fFarthestDepthInMeters = LoadFarthestDepth(iPxSamplePos); + + FfxFloat32x4 fOutput = FfxFloat32x4(0.0f, 0.0f, 0.0f, 0.0f); + fOutput[LOG_LUMA] = fLogLuma; + fOutput[LUMA] = fLuma; + fOutput[DEPTH_IN_METERS] = fFarthestDepthInMeters; + + return fOutput; +} + +FfxFloat32x4 SpdLoad(FfxInt32x2 tex, FfxUInt32 slice) +{ + return FfxFloat32x4(RWLoadPyramid(tex, 5), 0, 0); +} + +FfxFloat32x4 SpdReduce4(FfxFloat32x4 v0, FfxFloat32x4 v1, FfxFloat32x4 v2, FfxFloat32x4 v3) +{ + return (v0 + v1 + v2 + v3) * 0.25f; +} + +void SpdStore(FfxInt32x2 pix, FfxFloat32x4 outValue, FfxUInt32 index, FfxUInt32 slice) +{ + if (index == 5) + { + StorePyramid(pix, outValue.xy, index); + } + else if (index == 0) { + StoreFarthestDepthMip1(pix, outValue[DEPTH_IN_METERS]); + } + + if (index == MipCount() - 1) { //accumulate on 1x1 level + + if (all(FFX_EQUAL(pix, FfxInt32x2(0, 0)))) + { + FfxFloat32x4 frameInfo = LoadFrameInfo(); + const FfxFloat32 fSceneAvgLuma = outValue[LUMA]; + const FfxFloat32 fPrevLogLuma = frameInfo[FRAME_INFO_LOG_LUMA]; + FfxFloat32 fLogLuma = outValue[LOG_LUMA]; + + if (fPrevLogLuma < resetAutoExposureAverageSmoothing) // Compare Lavg, so small or negative values + { + fLogLuma = fPrevLogLuma + (fLogLuma - fPrevLogLuma) * (1.0f - exp(-DeltaTime())); + fLogLuma = ffxMax(0.0f, fLogLuma); + } + + frameInfo[FRAME_INFO_EXPOSURE] = ComputeAutoExposureFromLavg(fLogLuma); + frameInfo[FRAME_INFO_LOG_LUMA] = fLogLuma; + frameInfo[FRAME_INFO_SCENE_AVERAGE_LUMA] = fSceneAvgLuma; + + StoreFrameInfo(frameInfo); + } + } +} + +FfxFloat32x4 SpdLoadIntermediate(FfxUInt32 x, FfxUInt32 y) +{ + return FfxFloat32x4( + spdIntermediateR[x][y], + spdIntermediateG[x][y], + spdIntermediateB[x][y], + spdIntermediateA[x][y]); +} +void SpdStoreIntermediate(FfxUInt32 x, FfxUInt32 y, FfxFloat32x4 value) +{ + spdIntermediateR[x][y] = value.x; + spdIntermediateG[x][y] = value.y; + spdIntermediateB[x][y] = value.z; + spdIntermediateA[x][y] = value.w; +} + +#endif + +// define fetch and store functions Packed +#if FFX_HALF + +FFX_GROUPSHARED FfxFloat16x2 spdIntermediateRG[16][16]; +FFX_GROUPSHARED FfxFloat16x2 spdIntermediateBA[16][16]; + +FfxFloat16x4 SpdLoadSourceImageH(FfxFloat32x2 tex, FfxUInt32 slice) +{ + return FfxFloat16x4(0, 0, 0, 0); +} + +FfxFloat16x4 SpdLoadH(FfxInt32x2 p, FfxUInt32 slice) +{ + return FfxFloat16x4(0, 0, 0, 0); +} + +void SpdStoreH(FfxInt32x2 p, FfxFloat16x4 value, FfxUInt32 mip, FfxUInt32 slice) +{ +} + +FfxFloat16x4 SpdLoadIntermediateH(FfxUInt32 x, FfxUInt32 y) +{ + return FfxFloat16x4( + spdIntermediateRG[x][y].x, + spdIntermediateRG[x][y].y, + spdIntermediateBA[x][y].x, + spdIntermediateBA[x][y].y); +} + +void SpdStoreIntermediateH(FfxUInt32 x, FfxUInt32 y, FfxFloat16x4 value) +{ + spdIntermediateRG[x][y] = value.xy; + spdIntermediateBA[x][y] = value.zw; +} + +FfxFloat16x4 SpdReduce4H(FfxFloat16x4 v0, FfxFloat16x4 v1, FfxFloat16x4 v2, FfxFloat16x4 v3) +{ + return (v0 + v1 + v2 + v3) * FfxFloat16(0.25); +} +#endif + +#include "spd/ffx_spd.h" + +void ComputeAutoExposure(FfxUInt32x3 WorkGroupId, FfxUInt32 LocalThreadIndex) +{ +#if FFX_HALF + SpdDownsampleH( + FfxUInt32x2(WorkGroupId.xy), + FfxUInt32(LocalThreadIndex), + FfxUInt32(MipCount()), + FfxUInt32(NumWorkGroups()), + FfxUInt32(WorkGroupId.z), + FfxUInt32x2(WorkGroupOffset())); +#else + SpdDownsample( + FfxUInt32x2(WorkGroupId.xy), + FfxUInt32(LocalThreadIndex), + FfxUInt32(MipCount()), + FfxUInt32(NumWorkGroups()), + FfxUInt32(WorkGroupId.z), + FfxUInt32x2(WorkGroupOffset())); +#endif +} diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_prepare_inputs.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_prepare_inputs.h new file mode 100644 index 00000000..59c765b5 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_prepare_inputs.h @@ -0,0 +1,152 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +void ReconstructPrevDepth(FfxInt32x2 iPxPos, FfxFloat32 fDepth, FfxFloat32x2 fMotionVector) +{ + const FfxFloat32 fNearestDepthInMeters = ffxMin(GetViewSpaceDepthInMeters(fDepth), FSR3UPSCALER_FP16_MAX); + const FfxFloat32 fReconstructedDeptMvThreshold = ReconstructedDepthMvPxThreshold(fNearestDepthInMeters); + + // Discard small mvs + fMotionVector *= FfxFloat32(Get4KVelocity(fMotionVector) > fReconstructedDeptMvThreshold); + + const FfxFloat32x2 fUv = (iPxPos + FfxFloat32(0.5)) / RenderSize(); + const FfxFloat32x2 fReprojectedUv = fUv + fMotionVector; + const BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fReprojectedUv, RenderSize()); + + // Project current depth into previous frame locations. + // Push to all pixels having some contribution if reprojection is using bilinear logic. + for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++) { + + const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex]; + const FfxFloat32 fWeight = bilinearInfo.fWeights[iSampleIndex]; + + if (fWeight > fReconstructedDepthBilinearWeightThreshold) { + + const FfxInt32x2 iStorePos = bilinearInfo.iBasePos + iOffset; + if (IsOnScreen(iStorePos, RenderSize())) { + StoreReconstructedDepth(iStorePos, fDepth); + } + } + } +} + +struct DepthExtents +{ + FfxFloat32 fNearest; + FfxInt32x2 fNearestCoord; + FfxFloat32 fFarthest; +}; + +DepthExtents FindDepthExtents(FFX_PARAMETER_IN FfxInt32x2 iPxPos) +{ + DepthExtents extents; + const FfxInt32 iSampleCount = 9; + const FfxInt32x2 iSampleOffsets[iSampleCount] = { + FfxInt32x2(+0, +0), + FfxInt32x2(+1, +0), + FfxInt32x2(+0, +1), + FfxInt32x2(+0, -1), + FfxInt32x2(-1, +0), + FfxInt32x2(-1, +1), + FfxInt32x2(+1, +1), + FfxInt32x2(-1, -1), + FfxInt32x2(+1, -1), + }; + + // pull out the depth loads to allow SC to batch them + FfxFloat32 depth[9]; + FfxInt32 iSampleIndex = 0; + FFX_UNROLL + for (iSampleIndex = 0; iSampleIndex < iSampleCount; ++iSampleIndex) { + + FfxInt32x2 iPos = iPxPos + iSampleOffsets[iSampleIndex]; + depth[iSampleIndex] = LoadInputDepth(iPos); + } + + // find closest depth + extents.fNearestCoord = iPxPos; + extents.fNearest = depth[0]; + extents.fFarthest = depth[0]; + FFX_UNROLL + for (iSampleIndex = 1; iSampleIndex < iSampleCount; ++iSampleIndex) { + + const FfxInt32x2 iPos = iPxPos + iSampleOffsets[iSampleIndex]; + if (IsOnScreen(iPos, RenderSize())) { + + FfxFloat32 fNdDepth = depth[iSampleIndex]; +#if FFX_FSR3UPSCALER_OPTION_INVERTED_DEPTH + if (fNdDepth > extents.fNearest) { + extents.fFarthest = ffxMin(extents.fFarthest, fNdDepth); +#else + if (fNdDepth < extents.fNearest) { + extents.fFarthest = ffxMax(extents.fFarthest, fNdDepth); +#endif + extents.fNearestCoord = iPos; + extents.fNearest = fNdDepth; + } + } + } + + return extents; +} + +FfxFloat32x2 DilateMotionVector(FfxInt32x2 iPxPos, const DepthExtents depthExtents) +{ +#if FFX_FSR3UPSCALER_OPTION_LOW_RESOLUTION_MOTION_VECTORS + const FfxInt32x2 iSamplePos = iPxPos; + const FfxInt32x2 iMotionVectorPos = depthExtents.fNearestCoord; +#else + const FfxInt32x2 iSamplePos = ComputeHrPosFromLrPos(iPxPos); + const FfxInt32x2 iMotionVectorPos = ComputeHrPosFromLrPos(depthExtents.fNearestCoord); +#endif + + const FfxFloat32x2 fDilatedMotionVector = LoadInputMotionVector(iMotionVectorPos); + + return fDilatedMotionVector; +} + +FfxFloat32 GetCurrentFrameLuma(FfxInt32x2 iPxPos) +{ + //We assume linear data. if non-linear input (sRGB, ...), + //then we should convert to linear first and back to sRGB on output. + const FfxFloat32x3 fRgb = ffxMax(FfxFloat32x3(0, 0, 0), LoadInputColor(iPxPos)); + const FfxFloat32 fLuma = RGBToLuma(fRgb); + + return fLuma; +} + +void PrepareInputs(FfxInt32x2 iPxPos) +{ + const DepthExtents depthExtents = FindDepthExtents(iPxPos); + const FfxFloat32x2 fDilatedMotionVector = DilateMotionVector(iPxPos, depthExtents); + + ReconstructPrevDepth(iPxPos, depthExtents.fNearest, fDilatedMotionVector); + + StoreDilatedMotionVector(iPxPos, fDilatedMotionVector); + StoreDilatedDepth(iPxPos, depthExtents.fNearest); + + const FfxFloat32 fFarthestDepthInMeters = ffxMin(GetViewSpaceDepthInMeters(depthExtents.fFarthest), FSR3UPSCALER_FP16_MAX); + StoreFarthestDepth(iPxPos, fFarthestDepthInMeters); + + const FfxFloat32 fLuma = GetCurrentFrameLuma(iPxPos); + StoreCurrentLuma(iPxPos, fLuma); +} diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_prepare_reactivity.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_prepare_reactivity.h new file mode 100644 index 00000000..ae24545c --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_prepare_reactivity.h @@ -0,0 +1,283 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +FfxFloat32 ComputeDisocclusions(FfxFloat32x2 fUv, FfxFloat32x2 fMotionVector, FfxFloat32 fCurrentDepthViewSpace) +{ + const FfxFloat32 fNearestDepthInMeters = ffxMin(fCurrentDepthViewSpace * ViewSpaceToMetersFactor(), FSR3UPSCALER_FP16_MAX); + const FfxFloat32 fReconstructedDeptMvThreshold = ReconstructedDepthMvPxThreshold(fNearestDepthInMeters); + + fMotionVector *= FfxFloat32(Get4KVelocity(fMotionVector) > fReconstructedDeptMvThreshold); + + const FfxFloat32x2 fReprojectedUv = fUv + fMotionVector; + const BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fReprojectedUv, RenderSize()); + + FfxFloat32 fDisocclusion = 0.0f; + FfxFloat32 fWeightSum = 0.0f; + FfxBoolean bPotentialDisocclusion = true; + + for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4 && bPotentialDisocclusion; iSampleIndex++) + { + + const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex]; + const FfxInt32x2 iSamplePos = ClampLoad(bilinearInfo.iBasePos, iOffset, FfxInt32x2(RenderSize())); + + if (IsOnScreen(iSamplePos, RenderSize())) { + const FfxFloat32 fWeight = bilinearInfo.fWeights[iSampleIndex]; + if (fWeight > fReconstructedDepthBilinearWeightThreshold) { + + const FfxFloat32 fPrevNearestDepthViewSpace = GetViewSpaceDepth(LoadReconstructedPrevDepth(iSamplePos)); + const FfxFloat32 fDepthDifference = fCurrentDepthViewSpace - fPrevNearestDepthViewSpace; + + bPotentialDisocclusion = bPotentialDisocclusion && (fDepthDifference > FSR3UPSCALER_FP32_MIN); + + if (bPotentialDisocclusion) { + const FfxFloat32 fHalfViewportWidth = length(FfxFloat32x2(RenderSize()) * 0.5f); + const FfxFloat32 fDepthThreshold = ffxMax(fCurrentDepthViewSpace, fPrevNearestDepthViewSpace); + + const FfxFloat32 Ksep = 1.37e-05f; + const FfxFloat32 fRequiredDepthSeparation = Ksep * fHalfViewportWidth * fDepthThreshold; + + fDisocclusion += ffxSaturate(FfxFloat32(fRequiredDepthSeparation / fDepthDifference)) * fWeight; + fWeightSum += fWeight; + } + } + } + } + + fDisocclusion = (bPotentialDisocclusion && fWeightSum > 0) ? ffxSaturate(1.0f - fDisocclusion / fWeightSum) : 0.0f; + + return fDisocclusion; +} + +FfxFloat32 ComputeMotionDivergence(FfxFloat32x2 fUv, FfxFloat32x2 fMotionVector, FfxFloat32 fCurrentDepthSample) +{ + const FfxInt32x2 iPxReprojectedPos = FfxInt32x2((fUv + fMotionVector) * RenderSize()); + const FfxFloat32 fReprojectedDepth = LoadDilatedDepth(iPxReprojectedPos); + const FfxFloat32x2 fReprojectedMotionVector = LoadDilatedMotionVector(iPxReprojectedPos); + + const FfxFloat32 fReprojectedVelocity = Get4KVelocity(fReprojectedMotionVector); + const FfxFloat32 f4KVelocity = Get4KVelocity(fMotionVector); + + const FfxFloat32 fMaxLen = max(length(fMotionVector), length(fReprojectedMotionVector)); + + const FfxFloat32 fNucleusDepthInMeters = GetViewSpaceDepthInMeters(fReprojectedDepth); + const FfxFloat32 fCurrentDepthInMeters = GetViewSpaceDepthInMeters(fCurrentDepthSample); + + const FfxFloat32 fDistanceFactor = MinDividedByMax(fNucleusDepthInMeters, fCurrentDepthInMeters); + const FfxFloat32 fVelocityFactor = ffxSaturate(f4KVelocity / 10.0f); + const FfxFloat32 fMotionVectorFieldConfidence = (1.0f - ffxSaturate(fReprojectedVelocity / f4KVelocity)) * fDistanceFactor * fVelocityFactor; + + return fMotionVectorFieldConfidence; +} + +FfxFloat32 DilateReactiveMasks(FfxInt32x2 iPxPos, FfxFloat32x2 fUv) +{ + FfxFloat32 fDilatedReactiveMasks = 0.0f; + + FFX_UNROLL + for (FfxInt32 y = -1; y <=1; y++) + { + FFX_UNROLL + for (FfxInt32 x = -1; x <= 1; x++) + { + const FfxInt32x2 sampleCoord = ClampLoad(iPxPos, FfxInt32x2(x, y), FfxInt32x2(RenderSize())); + fDilatedReactiveMasks = ffxMax(fDilatedReactiveMasks, LoadReactiveMask(sampleCoord)); + } + } + + return fDilatedReactiveMasks; +} + +FfxFloat32 DilateTransparencyAndCompositionMasks(FfxInt32x2 iPxPos, FfxFloat32x2 fUv) +{ + const FfxFloat32x2 fUvTransparencyAndCompositionMask = ClampUv(fUv, RenderSize(), GetTransparencyAndCompositionMaskResourceDimensions()); + return SampleTransparencyAndCompositionMask(fUvTransparencyAndCompositionMask); +} + +FfxFloat32 ComputeThinFeatureConfidence(FfxInt32x2 iPxPos) +{ + /* + 1 2 3 + 4 0 5 + 6 7 8 + */ + + const FfxInt32 iNucleusIndex = 0; + const FfxInt32 iSampleCount = 9; + const FfxInt32x2 iSampleOffsets[iSampleCount] = { + FfxInt32x2(+0, +0), + FfxInt32x2(-1, -1), + FfxInt32x2(+0, -1), + FfxInt32x2(+1, -1), + FfxInt32x2(-1, +0), + FfxInt32x2(+1, +0), + FfxInt32x2(-1, +1), + FfxInt32x2(+0, +1), + FfxInt32x2(+1, +1), + }; + + FfxFloat32 fSamples[iSampleCount]; + + FfxFloat32 fLumaMin = FSR3UPSCALER_FP32_MAX; + FfxFloat32 fLumaMax = FSR3UPSCALER_FP32_MIN; + + FFX_UNROLL + for (FfxInt32 iSampleIndex = 0; iSampleIndex < iSampleCount; ++iSampleIndex) { + const FfxInt32x2 iPxSamplePos = ClampLoad(iPxPos, iSampleOffsets[iSampleIndex], FfxInt32x2(RenderSize())); + fSamples[iSampleIndex] = LoadCurrentLuma(iPxSamplePos) * Exposure(); + + fLumaMin = ffxMin(fLumaMin, fSamples[iSampleIndex]); + fLumaMax = ffxMax(fLumaMax, fSamples[iSampleIndex]); + } + + const FfxFloat32 fThreshold = 0.9f; + FfxFloat32 fDissimilarLumaMin = FSR3UPSCALER_FP32_MAX; + FfxFloat32 fDissimilarLumaMax = 0; + +#define SETBIT(x) (1U << x) + + FfxUInt32 uPatternMask = SETBIT(iNucleusIndex); // Flag nucleus as similar + + const FfxUInt32 uNumRejectionMasks = 4; + const FfxUInt32 uRejectionMasks[uNumRejectionMasks] = { + SETBIT(1) | SETBIT(2) | SETBIT(4) | SETBIT(iNucleusIndex), // Upper left + SETBIT(2) | SETBIT(3) | SETBIT(5) | SETBIT(iNucleusIndex), // Upper right + SETBIT(4) | SETBIT(6) | SETBIT(7) | SETBIT(iNucleusIndex), // Lower left + SETBIT(5) | SETBIT(7) | SETBIT(8) | SETBIT(iNucleusIndex) // Lower right + }; + + FfxInt32 iBitIndex = 1; + FFX_UNROLL + for (FfxInt32 iSampleIndex = 1; iSampleIndex < iSampleCount; ++iSampleIndex, ++iBitIndex) { + + const FfxFloat32 fDifference = abs(fSamples[iSampleIndex] - fSamples[iNucleusIndex]) / (fLumaMax - fLumaMin); + + if (fDifference < fThreshold) + { + uPatternMask |= SETBIT(iBitIndex); + } + else + { + fDissimilarLumaMin = ffxMin(fDissimilarLumaMin, fSamples[iSampleIndex]); + fDissimilarLumaMax = ffxMax(fDissimilarLumaMax, fSamples[iSampleIndex]); + } + } + + const FfxBoolean bIsRidge = fSamples[iNucleusIndex] > fDissimilarLumaMax || fSamples[iNucleusIndex] < fDissimilarLumaMin; + + if (FFX_FALSE == bIsRidge) + { + return 0.0f; + } + + FFX_UNROLL + for (FfxInt32 i = 0; i < uNumRejectionMasks; i++) + { + if ((uPatternMask & uRejectionMasks[i]) == uRejectionMasks[i]) + { + return 0.0f; + } + } + + return 1.0f - fLumaMin / fLumaMax; +} + +FfxFloat32 UpdateAccumulation(FfxInt32x2 iPxPos, FfxFloat32x2 fUv, FfxFloat32x2 fMotionVector, FfxFloat32 fDisocclusion, FfxFloat32 fShadingChange) +{ + const FfxFloat32x2 fReprojectedUv = fUv + fMotionVector; + FfxFloat32 fAccumulation = 0.0f; + + if (IsUvInside(fReprojectedUv)) { + const FfxFloat32x2 fReprojectedUv_HW = ClampUv(fReprojectedUv, PreviousFrameRenderSize(), MaxRenderSize()); + fAccumulation = ffxSaturate(SampleAccumulation(fReprojectedUv_HW)); + } + const FfxFloat32 fAccumulationAddedPerFrame= AccumulationAddedPerFrame(); //default is 0.333 + + // Assume at frame N+0 fShadingChange is 1.0, and all subsequent frames fShadingChange is 0.0 and fDisocclusion is 0.0. Then, + // frame N+0 fAccumulation will be 0.000 + // frame N+2 fAccumulation will be 0.000 + 0.333 * 1 == 0.333 + // frame N+3 fAccumulation will be 0.000 + 0.333 * 2 == 0.666 + // frame N+4 fAccumulation will be 0.000 + 0.333 * 3 == 0.999 + fAccumulation = ffxLerp(fAccumulation, 0.0f, fShadingChange); + + const FfxFloat32 fMinDisocclusionAccumulation = MinDisocclusionAccumulation(); //default is -0.333 + // Assume at frame N+0 fDisocclusion is 1.0, and all subsequent frames fShadingChange is 0.0 and fDisocclusion is 0.0. Then, + // frame N+0 fAccumulation will be -0.333f (but normalized to store in unorm) + // frame N+1 fAccumulation will be -0.333f + 0.333 * 1 == 0.000 + // frame N+2 fAccumulation will be -0.333f + 0.333 * 2 == 0.333 + // frame N+3 fAccumulation will be -0.333f + 0.333 * 3 == 0.666 + // frame N+4 fAccumulation will be -0.333f + 0.333 * 4 == 0.999 + fAccumulation = ffxLerp(fAccumulation, ffxMin(fMinDisocclusionAccumulation, fAccumulation), fDisocclusion); + + fAccumulation *= FfxFloat32(round(fAccumulation * 100.0f) > 1.0f); + + // Update for next frame, normalize to store in unorm + const FfxFloat32 fAccumulatedFramesToStore = ffxSaturate(fAccumulation + fAccumulationAddedPerFrame); + StoreAccumulation(iPxPos, fAccumulatedFramesToStore); + + return fAccumulation; +} + +FfxFloat32 ComputeShadingChange(FfxFloat32x2 fUv) +{ + // NOTE: Here we re-apply jitter, will be reverted again when sampled in accumulation pass + const FfxFloat32x2 fShadingChangeUv = ClampUv(fUv - Jitter() / RenderSize(), ShadingChangeRenderSize(), ShadingChangeMaxRenderSize()); + const FfxFloat32 fShadingChange = ffxSaturate(SampleShadingChange(fShadingChangeUv)); + + return fShadingChange; +} + +void PrepareReactivity(FfxInt32x2 iPxPos) +{ + const FfxFloat32x2 fUv = (iPxPos + 0.5f) / RenderSize(); + const FfxFloat32x2 fMotionVector = LoadDilatedMotionVector(iPxPos); + + // Discard small mvs + const FfxFloat32 f4KVelocity = Get4KVelocity(fMotionVector); + + const FfxFloat32x2 fDilatedUv = fUv + fMotionVector; + const FfxFloat32 fDilatedDepth = LoadDilatedDepth(iPxPos); + const FfxFloat32 fDepthInMeters = GetViewSpaceDepthInMeters(fDilatedDepth); + + const FfxFloat32 fDisocclusion = ComputeDisocclusions(fUv, fMotionVector, GetViewSpaceDepth(fDilatedDepth)); + const FfxFloat32 fShadingChange = ffxMax(DilateReactiveMasks(iPxPos, fUv), ComputeShadingChange(fUv)); + + const FfxFloat32 fMotionDivergence = ComputeMotionDivergence(fUv, fMotionVector, fDilatedDepth); + const FfxFloat32 fDilatedTransparencyAndComposition = DilateTransparencyAndCompositionMasks(iPxPos, fUv); + const FfxFloat32 fFinalReactiveness = ffxMax(fMotionDivergence, fDilatedTransparencyAndComposition); + + const FfxFloat32 fAccumulation = UpdateAccumulation(iPxPos, fUv, fMotionVector, fDisocclusion, fShadingChange); + + FfxFloat32x4 fOutput; + fOutput[REACTIVE] = fFinalReactiveness; + fOutput[DISOCCLUSION] = fDisocclusion; + fOutput[SHADING_CHANGE] = fShadingChange; + fOutput[ACCUMULAION] = fAccumulation; + + StoreDilatedReactiveMasks(iPxPos, fOutput); + + const FfxFloat32 fLockStrength = ComputeThinFeatureConfidence(iPxPos); + if (fLockStrength > (1.0f / 100.0f)) + { + StoreNewLocks(ComputeHrPosFromLrPos(FfxInt32x2(iPxPos)), fLockStrength); + } +} diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_rcas.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_rcas.h new file mode 100644 index 00000000..f48cffb9 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_rcas.h @@ -0,0 +1,112 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define GROUP_SIZE 8 +#define FSR_RCAS_DENOISE 1 + +#include "ffx_core.h" + +#if FFX_HALF && defined(__XBOX_SCARLETT) && defined(__XBATG_EXTRA_16_BIT_OPTIMISATION) && (__XBATG_EXTRA_16_BIT_OPTIMISATION == 1) + #define FSR_RCAS_PREFER_PAIRED_VERSION 1 +#else + #define FSR_RCAS_PREFER_PAIRED_VERSION 0 +#endif + +void WriteUpscaledOutput(FFX_MIN16_U2 iPxHrPos, FfxFloat32x3 fUpscaledColor) +{ + StoreUpscaledOutput(FFX_MIN16_I2(iPxHrPos), fUpscaledColor); +} + +#if FSR_RCAS_PREFER_PAIRED_VERSION + #define FSR_RCAS_HX2 1 + FfxFloat16x4 FsrRcasLoadHx2(FfxInt16x2 p) + { + return FfxFloat16x4(LoadRCAS_Input(p)); + } + void FsrRcasInputHx2(inout FfxFloat16x2 r, inout FfxFloat16x2 g, inout FfxFloat16x2 b) + { + FfxFloat32 e = Exposure(); + r = FfxFloat16x2(r * e); + g = FfxFloat16x2(g * e); + b = FfxFloat16x2(b * e); + } + + #include "fsr1/ffx_fsr1.h" + + void CurrFilterPaired(FFX_MIN16_U2 pos) + { + FfxFloat16x2 cr; + FfxFloat16x2 cg; + FfxFloat16x2 cb; + FsrRcasHx2(cr, cg, cb, pos, RCASConfig()); + FfxFloat32 InvExposure = 1.0f / Exposure(); + cr = FfxFloat16x2(cr * InvExposure); + cg = FfxFloat16x2(cg * InvExposure); + cb = FfxFloat16x2(cb * InvExposure); + WriteUpscaledOutput(pos, FfxFloat16x3(cr.x, cg.x, cb.x)); //TODO: fix type + pos.x += 8; + WriteUpscaledOutput(pos, FfxFloat16x3(cr.y, cg.y, cb.y)); //TODO: fix type + } +#else + #define FSR_RCAS_F 1 + FfxFloat32x4 FsrRcasLoadF(FfxInt32x2 p) + { + FfxFloat32x4 fColor = LoadRCAS_Input(p); + + fColor.rgb *= Exposure(); + + return fColor; + } + void FsrRcasInputF(inout FfxFloat32 r, inout FfxFloat32 g, inout FfxFloat32 b) {} + + #include "fsr1/ffx_fsr1.h" + + void CurrFilter(FFX_MIN16_U2 pos) + { + FfxFloat32x3 c; + FsrRcasF(c.r, c.g, c.b, pos, RCASConfig()); + + c /= Exposure(); + + WriteUpscaledOutput(pos, c); + } + +#endif // #if FSR_RCAS_PREFER_PAIRED_VERSION + +void RCAS(FfxUInt32x3 LocalThreadId, FfxUInt32x3 WorkGroupId, FfxUInt32x3 Dtid) +{ + // Do remapping of local xy in workgroup for a more PS-like swizzle pattern. + FfxUInt32x2 gxy = ffxRemapForQuad(LocalThreadId.x) + FfxUInt32x2(WorkGroupId.x << 4u, WorkGroupId.y << 4u); +#if FSR_RCAS_PREFER_PAIRED_VERSION + CurrFilterPaired(FFX_MIN16_U2(gxy)); + gxy.y += 8u; + CurrFilterPaired(FFX_MIN16_U2(gxy)); +#else + CurrFilter(FFX_MIN16_U2(gxy)); + gxy.x += 8u; + CurrFilter(FFX_MIN16_U2(gxy)); + gxy.y += 8u; + CurrFilter(FFX_MIN16_U2(gxy)); + gxy.x -= 8u; + CurrFilter(FFX_MIN16_U2(gxy)); +#endif +} diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_reproject.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_reproject.h new file mode 100644 index 00000000..80ff89f8 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_reproject.h @@ -0,0 +1,108 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE +#define FFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE 0 // Reference +#endif + +FfxFloat32x4 WrapHistory(FfxInt32x2 iPxSample) +{ + return LoadHistory(iPxSample); +} + +DeclareCustomFetchBicubicSamples(FetchHistorySamples, WrapHistory) +DeclareCustomTextureSample(HistorySample, FFX_FSR3UPSCALER_GET_LANCZOS_SAMPLER1D(FFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE), FetchHistorySamples) + +#if FFX_HALF +FFX_MIN16_F4 WrapHistory16(FfxInt32x2 iPxSample) +{ + return FFX_MIN16_F4(LoadHistory(iPxSample)); +} + +DeclareCustomFetchBicubicSamplesMin16(FetchHistorySamples16, WrapHistory16) +DeclareCustomTextureSampleMin16(HistorySample16, FFX_FSR3UPSCALER_GET_LANCZOS_SAMPLER1D(FFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE), FetchHistorySamples16) +#endif + +FfxFloat32x2 GetMotionVector(FfxInt32x2 iPxHrPos, FfxFloat32x2 fHrUv) +{ +#if FFX_FSR3UPSCALER_OPTION_LOW_RESOLUTION_MOTION_VECTORS + const FfxFloat32x2 fDilatedMotionVector = LoadDilatedMotionVector(FFX_MIN16_I2(fHrUv * RenderSize())); +#else + const FfxFloat32x2 fDilatedMotionVector = LoadInputMotionVector(iPxHrPos); +#endif + + return fDilatedMotionVector; +} + +void ComputeReprojectedUVs(FFX_PARAMETER_INOUT AccumulationPassCommonParams params) +{ + params.fReprojectedHrUv = params.fHrUv + params.fMotionVector; + + params.bIsExistingSample = IsUvInside(params.fReprojectedHrUv); +} + +#if FFX_FSR3UPSCALER_OPTION_REPROJECT_CATMULL_ROM_5 +// Savage Wind: the history reprojected with a Catmull-Rom filter from 5 bilinear samples (its 4x4 footprint's corners +// left out) instead of Lanczos on 16 loads: the accumulation's largest cost, ~0.3 ms less at 3840x2160 on an RTX 3060. +// The history texture is the upscale size (the upscaler's output, fixed). +FfxFloat32x4 HistorySampleCatmullRom5(FfxFloat32x2 fUv, FfxFloat32x2 fSize) +{ + const FfxFloat32x2 fPx = fUv * fSize; + const FfxFloat32x2 fPx1 = floor(fPx - 0.5f) + 0.5f; + const FfxFloat32x2 f = fPx - fPx1; + const FfxFloat32x2 w0 = f * (-0.5f + f * (1.0f - 0.5f * f)); + const FfxFloat32x2 w1 = 1.0f + f * f * (-2.5f + 1.5f * f); + const FfxFloat32x2 w2 = f * (0.5f + f * (2.0f - 1.5f * f)); + const FfxFloat32x2 w3 = f * f * (-0.5f + 0.5f * f); + const FfxFloat32x2 w12 = w1 + w2; + const FfxFloat32x2 fUv0 = (fPx1 - 1.0f) / fSize; + const FfxFloat32x2 fUv3 = (fPx1 + 2.0f) / fSize; + const FfxFloat32x2 fUv12 = (fPx1 + w2 / w12) / fSize; + const FfxFloat32 k0 = w12.x * w0.y, k1 = w0.x * w12.y, k2 = w12.x * w12.y, k3 = w3.x * w12.y, k4 = w12.x * w3.y; + FfxFloat32x4 c = SampleHistory(FfxFloat32x2(fUv12.x, fUv0.y)) * k0 + + SampleHistory(FfxFloat32x2(fUv0.x, fUv12.y)) * k1 + + SampleHistory(fUv12) * k2 + + SampleHistory(FfxFloat32x2(fUv3.x, fUv12.y)) * k3 + + SampleHistory(FfxFloat32x2(fUv12.x, fUv3.y)) * k4; + return ffxMax(c / (k0 + k1 + k2 + k3 + k4), FfxFloat32x4(0.0f, 0.0f, 0.0f, 0.0f)); +} +#endif + +void ReprojectHistoryColor(const AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data) + +{ +#if FFX_FSR3UPSCALER_OPTION_REPROJECT_CATMULL_ROM_5 + const FfxFloat32x4 fReprojectedHistory = HistorySampleCatmullRom5(params.fReprojectedHrUv, FfxFloat32x2(UpscaleSize())); +#elif FFX_HALF && FFX_FSR3UPSCALER_OPTION_REPROJECT_SAMPLERS_USE_DATA_HALF + const FfxFloat32x4 fReprojectedHistory = FfxFloat32x4(HistorySample16(params.fReprojectedHrUv, UpscaleSize())); +#else + const FfxFloat32x4 fReprojectedHistory = HistorySample(params.fReprojectedHrUv, PreviousFrameUpscaleSize()); +#endif + + data.fHistoryColor = fReprojectedHistory.rgb; + data.fHistoryColor *= DeltaPreExposure(); + data.fHistoryColor *= Exposure(); + + data.fHistoryColor = RGBToYCoCg(data.fHistoryColor); + + data.fLock = fReprojectedHistory.w; +} diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_resources.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_resources.h new file mode 100644 index 00000000..b3d8ddb1 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_resources.h @@ -0,0 +1,100 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FSR3UPSCALER_RESOURCES_H +#define FFX_FSR3UPSCALER_RESOURCES_H + +#if defined(FFX_CPU) || defined(FFX_GPU) +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL 0 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_OPAQUE_ONLY 1 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_COLOR 2 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_MOTION_VECTORS 3 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_DEPTH 4 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_EXPOSURE 5 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK 6 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK 7 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH 8 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS 9 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_DEPTH 10 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR 11 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION 12 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NEW_LOCKS 13 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY 14 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DEBUG_OUTPUT 15 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LANCZOS_LUT 16 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_ATOMIC_COUNT 17 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_UPSCALED_OUTPUT 18 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RCAS_INPUT 19 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION_1 20 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION_2 21 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_1 22 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_2 23 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_REACTIVITY 24 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_TRANSPARENCY_AND_COMPOSITION 25 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_REACTIVE_MASKS 26 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS 27 // same as FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_0 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_0 27 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_1 28 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_2 29 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_3 30 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_4 31 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_5 32 + +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_EXPOSURE 33 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FRAME_INFO 34 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_AUTOREACTIVE 35 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_AUTOCOMPOSITION_DEPRECATED 36 + +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY_1 37 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY_2 38 + +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_1 40 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_2 41 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SHADING_CHANGE 42 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH 43 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH_MIP1 44 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_CURRENT_LUMA 45 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_PREVIOUS_LUMA 46 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_INSTABILITY 48 +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERMEDIATE_FP16x1 49 + + +// Shading change detection mip level setting, value must be in the range [FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_0, FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_12] +//#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_SHADING_CHANGE FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_4 +//#define FFX_FSR3UPSCALER_SHADING_CHANGE_MIP_LEVEL (FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_SHADING_CHANGE - FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SCENE_LUMINANCE) + +#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_COUNT 60 + +#define FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_FSR3UPSCALER 0 +#define FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_SPD 1 +#define FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_RCAS 2 +#define FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_GENREACTIVE 3 +#define FFX_FSR3UPSCALER_CONSTANTBUFFER_COUNT 4 + +#define FFX_FSR3UPSCALER_AUTOREACTIVEFLAGS_APPLY_TONEMAP 1 +#define FFX_FSR3UPSCALER_AUTOREACTIVEFLAGS_APPLY_INVERSETONEMAP 2 +#define FFX_FSR3UPSCALER_AUTOREACTIVEFLAGS_APPLY_THRESHOLD 4 +#define FFX_FSR3UPSCALER_AUTOREACTIVEFLAGS_USE_COMPONENTS_MAX 8 + +#endif // #if defined(FFX_CPU) || defined(FFX_GPU) + +#endif //!defined( FFX_FSR3UPSCALER_RESOURCES_H ) diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_sample.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_sample.h new file mode 100644 index 00000000..7a723d55 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_sample.h @@ -0,0 +1,628 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FSR3UPSCALER_SAMPLE_H +#define FFX_FSR3UPSCALER_SAMPLE_H + +// suppress warnings +#ifdef FFX_HLSL +#pragma warning(disable: 4008) // potentially divide by zero +#endif //FFX_HLSL + +struct FetchedBilinearSamples { + + FfxFloat32x4 fColor00; + FfxFloat32x4 fColor10; + + FfxFloat32x4 fColor01; + FfxFloat32x4 fColor11; +}; + +struct FetchedBicubicSamples { + + FfxFloat32x4 fColor00; + FfxFloat32x4 fColor10; + FfxFloat32x4 fColor20; + FfxFloat32x4 fColor30; + + FfxFloat32x4 fColor01; + FfxFloat32x4 fColor11; + FfxFloat32x4 fColor21; + FfxFloat32x4 fColor31; + + FfxFloat32x4 fColor02; + FfxFloat32x4 fColor12; + FfxFloat32x4 fColor22; + FfxFloat32x4 fColor32; + + FfxFloat32x4 fColor03; + FfxFloat32x4 fColor13; + FfxFloat32x4 fColor23; + FfxFloat32x4 fColor33; +}; + +#if FFX_HALF +struct FetchedBilinearSamplesMin16 { + + FFX_MIN16_F4 fColor00; + FFX_MIN16_F4 fColor10; + + FFX_MIN16_F4 fColor01; + FFX_MIN16_F4 fColor11; +}; + +struct FetchedBicubicSamplesMin16 { + + FFX_MIN16_F4 fColor00; + FFX_MIN16_F4 fColor10; + FFX_MIN16_F4 fColor20; + FFX_MIN16_F4 fColor30; + + FFX_MIN16_F4 fColor01; + FFX_MIN16_F4 fColor11; + FFX_MIN16_F4 fColor21; + FFX_MIN16_F4 fColor31; + + FFX_MIN16_F4 fColor02; + FFX_MIN16_F4 fColor12; + FFX_MIN16_F4 fColor22; + FFX_MIN16_F4 fColor32; + + FFX_MIN16_F4 fColor03; + FFX_MIN16_F4 fColor13; + FFX_MIN16_F4 fColor23; + FFX_MIN16_F4 fColor33; +}; +#else //FFX_HALF +#define FetchedBicubicSamplesMin16 FetchedBicubicSamples +#define FetchedBilinearSamplesMin16 FetchedBilinearSamples +#endif //FFX_HALF + +FfxFloat32x4 Linear(FfxFloat32x4 A, FfxFloat32x4 B, FfxFloat32 t) +{ + return A + (B - A) * t; +} + +FfxFloat32x4 Bilinear(FetchedBilinearSamples BilinearSamples, FfxFloat32x2 fPxFrac) +{ + FfxFloat32x4 fColorX0 = Linear(BilinearSamples.fColor00, BilinearSamples.fColor10, fPxFrac.x); + FfxFloat32x4 fColorX1 = Linear(BilinearSamples.fColor01, BilinearSamples.fColor11, fPxFrac.x); + FfxFloat32x4 fColorXY = Linear(fColorX0, fColorX1, fPxFrac.y); + return fColorXY; +} + +#if FFX_HALF +FFX_MIN16_F4 Linear(FFX_MIN16_F4 A, FFX_MIN16_F4 B, FFX_MIN16_F t) +{ + return A + (B - A) * t; +} + +FFX_MIN16_F4 Bilinear(FetchedBilinearSamplesMin16 BilinearSamples, FFX_MIN16_F2 fPxFrac) +{ + FFX_MIN16_F4 fColorX0 = Linear(BilinearSamples.fColor00, BilinearSamples.fColor10, fPxFrac.x); + FFX_MIN16_F4 fColorX1 = Linear(BilinearSamples.fColor01, BilinearSamples.fColor11, fPxFrac.x); + FFX_MIN16_F4 fColorXY = Linear(fColorX0, fColorX1, fPxFrac.y); + return fColorXY; +} +#endif + +FfxFloat32 Lanczos2NoClamp(FfxFloat32 x) +{ + const FfxFloat32 PI = 3.141592653589793f; // TODO: share SDK constants + return abs(x) < FSR3UPSCALER_EPSILON ? 1.f : (sin(PI * x) / (PI * x)) * (sin(0.5f * PI * x) / (0.5f * PI * x)); +} + +FfxFloat32 Lanczos2(FfxFloat32 x) +{ + x = ffxMin(abs(x), 2.0f); + return Lanczos2NoClamp(x); +} + +#if FFX_HALF + +#if 0 +FFX_MIN16_F Lanczos2NoClamp(FFX_MIN16_F x) +{ + const FFX_MIN16_F PI = FFX_MIN16_F(3.141592653589793f); // TODO: share SDK constants + return abs(x) < FFX_MIN16_F(FSR3UPSCALER_EPSILON) ? FFX_MIN16_F(1.f) : (sin(PI * x) / (PI * x)) * (sin(FFX_MIN16_F(0.5f) * PI * x) / (FFX_MIN16_F(0.5f) * PI * x)); +} +#endif + +FFX_MIN16_F Lanczos2(FFX_MIN16_F x) +{ + x = ffxMin(abs(x), FFX_MIN16_F(2.0f)); + return FFX_MIN16_F(Lanczos2NoClamp(x)); +} +#endif //FFX_HALF + +// FSR1 lanczos approximation. Input is x*x and must be <= 4. +FfxFloat32 Lanczos2ApproxSqNoClamp(FfxFloat32 x2) +{ + FfxFloat32 a = (2.0f / 5.0f) * x2 - 1; + FfxFloat32 b = (1.0f / 4.0f) * x2 - 1; + return ((25.0f / 16.0f) * a * a - (25.0f / 16.0f - 1)) * (b * b); +} + +#if FFX_HALF +FFX_MIN16_F Lanczos2ApproxSqNoClamp(FFX_MIN16_F x2) +{ + FFX_MIN16_F a = FFX_MIN16_F(2.0f / 5.0f) * x2 - FFX_MIN16_F(1); + FFX_MIN16_F b = FFX_MIN16_F(1.0f / 4.0f) * x2 - FFX_MIN16_F(1); + return (FFX_MIN16_F(25.0f / 16.0f) * a * a - FFX_MIN16_F(25.0f / 16.0f - 1)) * (b * b); +} + +#if defined(__XBOX_SCARLETT) && defined(__XBATG_EXTRA_16_BIT_OPTIMISATION) && (__XBATG_EXTRA_16_BIT_OPTIMISATION == 1) +FFX_MIN16_F2 PairedLanczos2ApproxSqNoClamp(FFX_MIN16_F2 x2) +{ + // Xbox ATG (Pavel): + // + // 2.0 * x2 - 5.0 25.0 25.0 - 16.0 (2.0 * x2 - 5.0)^2 - (3.0)^2 (2.0 * x2 - 8.0) * (2.0 * x2 - 2.0) (x2 - 4.0) * (x2 - 1.0) + // a = -------------- ==> ---- * a^2 - -------------- = ----------------------------- = ---------------------------------- = ----------------------- = b * (x2 - 1.0) + // 5.0 16.0 16.0 16.0 16.0 4.0 + // + // so we need to compute just (b * b) * (b * x2 - b), so we should get four packed instructions: 2 fma + 2 mul + // + + FFX_MIN16_F2 b = (0.25 * x2 - 1.0); + return (b * b) * (b * x2 - b); +} +#endif + +#endif //FFX_HALF + +FfxFloat32 Lanczos2ApproxSq(FfxFloat32 x2) +{ + x2 = ffxMin(x2, 4.0f); + return Lanczos2ApproxSqNoClamp(x2); +} + +#if FFX_HALF +FFX_MIN16_F Lanczos2ApproxSq(FFX_MIN16_F x2) +{ + x2 = ffxMin(x2, FFX_MIN16_F(4.0f)); + return Lanczos2ApproxSqNoClamp(x2); +} + +#if defined(__XBOX_SCARLETT) && defined(__XBATG_EXTRA_16_BIT_OPTIMISATION) && (__XBATG_EXTRA_16_BIT_OPTIMISATION == 1) +FFX_MIN16_F2 PairedLanczos2ApproxSq(FFX_MIN16_F2 x2) +{ + x2 = ffxMin(x2, FFX_MIN16_F2(4.0, 4.0)); + return PairedLanczos2ApproxSqNoClamp(x2); +} +#endif +#endif //FFX_HALF + +FfxFloat32 Lanczos2ApproxNoClamp(FfxFloat32 x) +{ + return Lanczos2ApproxSqNoClamp(x * x); +} + +#if FFX_HALF +FFX_MIN16_F Lanczos2ApproxNoClamp(FFX_MIN16_F x) +{ + return Lanczos2ApproxSqNoClamp(x * x); +} +#endif //FFX_HALF + +FfxFloat32 Lanczos2Approx(FfxFloat32 x) +{ + return Lanczos2ApproxSq(x * x); +} + +#if FFX_HALF +FFX_MIN16_F Lanczos2Approx(FFX_MIN16_F x) +{ + return Lanczos2ApproxSq(x * x); +} +#endif //FFX_HALF + +FfxFloat32 Lanczos2_UseLUT(FfxFloat32 x) +{ + return SampleLanczos2Weight(abs(x)); +} + +#if FFX_HALF +FFX_MIN16_F Lanczos2_UseLUT(FFX_MIN16_F x) +{ + return FFX_MIN16_F(SampleLanczos2Weight(abs(x))); +} +#endif //FFX_HALF + +FfxFloat32x4 Lanczos2_UseLUT(FfxFloat32x4 fColor0, FfxFloat32x4 fColor1, FfxFloat32x4 fColor2, FfxFloat32x4 fColor3, FfxFloat32 t) +{ + FfxFloat32 fWeight0 = Lanczos2_UseLUT(-1.f - t); + FfxFloat32 fWeight1 = Lanczos2_UseLUT(-0.f - t); + FfxFloat32 fWeight2 = Lanczos2_UseLUT(+1.f - t); + FfxFloat32 fWeight3 = Lanczos2_UseLUT(+2.f - t); + return (fWeight0 * fColor0 + fWeight1 * fColor1 + fWeight2 * fColor2 + fWeight3 * fColor3) / (fWeight0 + fWeight1 + fWeight2 + fWeight3); +} +#if FFX_HALF +FFX_MIN16_F4 Lanczos2_UseLUT(FFX_MIN16_F4 fColor0, FFX_MIN16_F4 fColor1, FFX_MIN16_F4 fColor2, FFX_MIN16_F4 fColor3, FFX_MIN16_F t) +{ + FFX_MIN16_F fWeight0 = Lanczos2_UseLUT(FFX_MIN16_F(-1.f) - t); + FFX_MIN16_F fWeight1 = Lanczos2_UseLUT(FFX_MIN16_F(-0.f) - t); + FFX_MIN16_F fWeight2 = Lanczos2_UseLUT(FFX_MIN16_F(+1.f) - t); + FFX_MIN16_F fWeight3 = Lanczos2_UseLUT(FFX_MIN16_F(+2.f) - t); + return (fWeight0 * fColor0 + fWeight1 * fColor1 + fWeight2 * fColor2 + fWeight3 * fColor3) / (fWeight0 + fWeight1 + fWeight2 + fWeight3); +} +#endif + +FfxFloat32x4 Lanczos2(FfxFloat32x4 fColor0, FfxFloat32x4 fColor1, FfxFloat32x4 fColor2, FfxFloat32x4 fColor3, FfxFloat32 t) +{ + FfxFloat32 fWeight0 = Lanczos2(-1.f - t); + FfxFloat32 fWeight1 = Lanczos2(-0.f - t); + FfxFloat32 fWeight2 = Lanczos2(+1.f - t); + FfxFloat32 fWeight3 = Lanczos2(+2.f - t); + return (fWeight0 * fColor0 + fWeight1 * fColor1 + fWeight2 * fColor2 + fWeight3 * fColor3) / (fWeight0 + fWeight1 + fWeight2 + fWeight3); +} + +FfxFloat32x4 Lanczos2(FetchedBicubicSamples Samples, FfxFloat32x2 fPxFrac) +{ + FfxFloat32x4 fColorX0 = Lanczos2(Samples.fColor00, Samples.fColor10, Samples.fColor20, Samples.fColor30, fPxFrac.x); + FfxFloat32x4 fColorX1 = Lanczos2(Samples.fColor01, Samples.fColor11, Samples.fColor21, Samples.fColor31, fPxFrac.x); + FfxFloat32x4 fColorX2 = Lanczos2(Samples.fColor02, Samples.fColor12, Samples.fColor22, Samples.fColor32, fPxFrac.x); + FfxFloat32x4 fColorX3 = Lanczos2(Samples.fColor03, Samples.fColor13, Samples.fColor23, Samples.fColor33, fPxFrac.x); + FfxFloat32x4 fColorXY = Lanczos2(fColorX0, fColorX1, fColorX2, fColorX3, fPxFrac.y); + + // Deringing + + // TODO: only use 4 by checking jitter + const FfxInt32 iDeringingSampleCount = 4; + const FfxFloat32x4 fDeringingSamples[4] = { + Samples.fColor11, + Samples.fColor21, + Samples.fColor12, + Samples.fColor22, + }; + + FfxFloat32x4 fDeringingMin = fDeringingSamples[0]; + FfxFloat32x4 fDeringingMax = fDeringingSamples[0]; + + FFX_UNROLL + for (FfxInt32 iSampleIndex = 1; iSampleIndex < iDeringingSampleCount; ++iSampleIndex) { + + fDeringingMin = ffxMin(fDeringingMin, fDeringingSamples[iSampleIndex]); + fDeringingMax = ffxMax(fDeringingMax, fDeringingSamples[iSampleIndex]); + } + + fColorXY = clamp(fColorXY, fDeringingMin, fDeringingMax); + + return fColorXY; +} + +#if FFX_HALF +FFX_MIN16_F4 Lanczos2(FFX_MIN16_F4 fColor0, FFX_MIN16_F4 fColor1, FFX_MIN16_F4 fColor2, FFX_MIN16_F4 fColor3, FFX_MIN16_F t) +{ + FFX_MIN16_F fWeight0 = Lanczos2(FFX_MIN16_F(-1.f) - t); + FFX_MIN16_F fWeight1 = Lanczos2(FFX_MIN16_F(-0.f) - t); + FFX_MIN16_F fWeight2 = Lanczos2(FFX_MIN16_F(+1.f) - t); + FFX_MIN16_F fWeight3 = Lanczos2(FFX_MIN16_F(+2.f) - t); + return (fWeight0 * fColor0 + fWeight1 * fColor1 + fWeight2 * fColor2 + fWeight3 * fColor3) / (fWeight0 + fWeight1 + fWeight2 + fWeight3); +} + +FFX_MIN16_F4 Lanczos2(FetchedBicubicSamplesMin16 Samples, FFX_MIN16_F2 fPxFrac) +{ + FFX_MIN16_F4 fColorX0 = Lanczos2(Samples.fColor00, Samples.fColor10, Samples.fColor20, Samples.fColor30, fPxFrac.x); + FFX_MIN16_F4 fColorX1 = Lanczos2(Samples.fColor01, Samples.fColor11, Samples.fColor21, Samples.fColor31, fPxFrac.x); + FFX_MIN16_F4 fColorX2 = Lanczos2(Samples.fColor02, Samples.fColor12, Samples.fColor22, Samples.fColor32, fPxFrac.x); + FFX_MIN16_F4 fColorX3 = Lanczos2(Samples.fColor03, Samples.fColor13, Samples.fColor23, Samples.fColor33, fPxFrac.x); + FFX_MIN16_F4 fColorXY = Lanczos2(fColorX0, fColorX1, fColorX2, fColorX3, fPxFrac.y); + + // Deringing + + // TODO: only use 4 by checking jitter + const FfxInt32 iDeringingSampleCount = 4; + const FFX_MIN16_F4 fDeringingSamples[4] = { + Samples.fColor11, + Samples.fColor21, + Samples.fColor12, + Samples.fColor22, + }; + + FFX_MIN16_F4 fDeringingMin = fDeringingSamples[0]; + FFX_MIN16_F4 fDeringingMax = fDeringingSamples[0]; + + FFX_UNROLL + for (FfxInt32 iSampleIndex = 1; iSampleIndex < iDeringingSampleCount; ++iSampleIndex) + { + fDeringingMin = ffxMin(fDeringingMin, fDeringingSamples[iSampleIndex]); + fDeringingMax = ffxMax(fDeringingMax, fDeringingSamples[iSampleIndex]); + } + + fColorXY = clamp(fColorXY, fDeringingMin, fDeringingMax); + + return fColorXY; +} +#endif //FFX_HALF + + +FfxFloat32x4 Lanczos2LUT(FetchedBicubicSamples Samples, FfxFloat32x2 fPxFrac) +{ + FfxFloat32x4 fColorX0 = Lanczos2_UseLUT(Samples.fColor00, Samples.fColor10, Samples.fColor20, Samples.fColor30, fPxFrac.x); + FfxFloat32x4 fColorX1 = Lanczos2_UseLUT(Samples.fColor01, Samples.fColor11, Samples.fColor21, Samples.fColor31, fPxFrac.x); + FfxFloat32x4 fColorX2 = Lanczos2_UseLUT(Samples.fColor02, Samples.fColor12, Samples.fColor22, Samples.fColor32, fPxFrac.x); + FfxFloat32x4 fColorX3 = Lanczos2_UseLUT(Samples.fColor03, Samples.fColor13, Samples.fColor23, Samples.fColor33, fPxFrac.x); + FfxFloat32x4 fColorXY = Lanczos2_UseLUT(fColorX0, fColorX1, fColorX2, fColorX3, fPxFrac.y); + + // Deringing + + // TODO: only use 4 by checking jitter + const FfxInt32 iDeringingSampleCount = 4; + const FfxFloat32x4 fDeringingSamples[4] = { + Samples.fColor11, + Samples.fColor21, + Samples.fColor12, + Samples.fColor22, + }; + + FfxFloat32x4 fDeringingMin = fDeringingSamples[0]; + FfxFloat32x4 fDeringingMax = fDeringingSamples[0]; + + FFX_UNROLL + for (FfxInt32 iSampleIndex = 1; iSampleIndex < iDeringingSampleCount; ++iSampleIndex) { + + fDeringingMin = ffxMin(fDeringingMin, fDeringingSamples[iSampleIndex]); + fDeringingMax = ffxMax(fDeringingMax, fDeringingSamples[iSampleIndex]); + } + + fColorXY = clamp(fColorXY, fDeringingMin, fDeringingMax); + + return fColorXY; +} + +#if FFX_HALF +FFX_MIN16_F4 Lanczos2LUT(FetchedBicubicSamplesMin16 Samples, FFX_MIN16_F2 fPxFrac) +{ + FFX_MIN16_F4 fColorX0 = Lanczos2_UseLUT(Samples.fColor00, Samples.fColor10, Samples.fColor20, Samples.fColor30, fPxFrac.x); + FFX_MIN16_F4 fColorX1 = Lanczos2_UseLUT(Samples.fColor01, Samples.fColor11, Samples.fColor21, Samples.fColor31, fPxFrac.x); + FFX_MIN16_F4 fColorX2 = Lanczos2_UseLUT(Samples.fColor02, Samples.fColor12, Samples.fColor22, Samples.fColor32, fPxFrac.x); + FFX_MIN16_F4 fColorX3 = Lanczos2_UseLUT(Samples.fColor03, Samples.fColor13, Samples.fColor23, Samples.fColor33, fPxFrac.x); + FFX_MIN16_F4 fColorXY = Lanczos2_UseLUT(fColorX0, fColorX1, fColorX2, fColorX3, fPxFrac.y); + + // Deringing + + // TODO: only use 4 by checking jitter + const FfxInt32 iDeringingSampleCount = 4; + const FFX_MIN16_F4 fDeringingSamples[4] = { + Samples.fColor11, + Samples.fColor21, + Samples.fColor12, + Samples.fColor22, + }; + + FFX_MIN16_F4 fDeringingMin = fDeringingSamples[0]; + FFX_MIN16_F4 fDeringingMax = fDeringingSamples[0]; + + FFX_UNROLL + for (FfxInt32 iSampleIndex = 1; iSampleIndex < iDeringingSampleCount; ++iSampleIndex) + { + fDeringingMin = ffxMin(fDeringingMin, fDeringingSamples[iSampleIndex]); + fDeringingMax = ffxMax(fDeringingMax, fDeringingSamples[iSampleIndex]); + } + + fColorXY = clamp(fColorXY, fDeringingMin, fDeringingMax); + + return fColorXY; +} +#endif //FFX_HALF + + + +FfxFloat32x4 Lanczos2Approx(FfxFloat32x4 fColor0, FfxFloat32x4 fColor1, FfxFloat32x4 fColor2, FfxFloat32x4 fColor3, FfxFloat32 t) +{ + FfxFloat32 fWeight0 = Lanczos2ApproxNoClamp(-1.f - t); + FfxFloat32 fWeight1 = Lanczos2ApproxNoClamp(-0.f - t); + FfxFloat32 fWeight2 = Lanczos2ApproxNoClamp(+1.f - t); + FfxFloat32 fWeight3 = Lanczos2ApproxNoClamp(+2.f - t); + return (fWeight0 * fColor0 + fWeight1 * fColor1 + fWeight2 * fColor2 + fWeight3 * fColor3) / (fWeight0 + fWeight1 + fWeight2 + fWeight3); +} + +#if FFX_HALF +FFX_MIN16_F4 Lanczos2Approx(FFX_MIN16_F4 fColor0, FFX_MIN16_F4 fColor1, FFX_MIN16_F4 fColor2, FFX_MIN16_F4 fColor3, FFX_MIN16_F t) +{ + FFX_MIN16_F fWeight0 = Lanczos2ApproxNoClamp(FFX_MIN16_F(-1.f) - t); + FFX_MIN16_F fWeight1 = Lanczos2ApproxNoClamp(FFX_MIN16_F(-0.f) - t); + FFX_MIN16_F fWeight2 = Lanczos2ApproxNoClamp(FFX_MIN16_F(+1.f) - t); + FFX_MIN16_F fWeight3 = Lanczos2ApproxNoClamp(FFX_MIN16_F(+2.f) - t); + return (fWeight0 * fColor0 + fWeight1 * fColor1 + fWeight2 * fColor2 + fWeight3 * fColor3) / (fWeight0 + fWeight1 + fWeight2 + fWeight3); +} +#endif //FFX_HALF + +FfxFloat32x4 Lanczos2Approx(FetchedBicubicSamples Samples, FfxFloat32x2 fPxFrac) +{ + FfxFloat32x4 fColorX0 = Lanczos2Approx(Samples.fColor00, Samples.fColor10, Samples.fColor20, Samples.fColor30, fPxFrac.x); + FfxFloat32x4 fColorX1 = Lanczos2Approx(Samples.fColor01, Samples.fColor11, Samples.fColor21, Samples.fColor31, fPxFrac.x); + FfxFloat32x4 fColorX2 = Lanczos2Approx(Samples.fColor02, Samples.fColor12, Samples.fColor22, Samples.fColor32, fPxFrac.x); + FfxFloat32x4 fColorX3 = Lanczos2Approx(Samples.fColor03, Samples.fColor13, Samples.fColor23, Samples.fColor33, fPxFrac.x); + FfxFloat32x4 fColorXY = Lanczos2Approx(fColorX0, fColorX1, fColorX2, fColorX3, fPxFrac.y); + + // Deringing + + // TODO: only use 4 by checking jitter + const FfxInt32 iDeringingSampleCount = 4; + const FfxFloat32x4 fDeringingSamples[4] = { + Samples.fColor11, + Samples.fColor21, + Samples.fColor12, + Samples.fColor22, + }; + + FfxFloat32x4 fDeringingMin = fDeringingSamples[0]; + FfxFloat32x4 fDeringingMax = fDeringingSamples[0]; + + FFX_UNROLL + for (FfxInt32 iSampleIndex = 1; iSampleIndex < iDeringingSampleCount; ++iSampleIndex) + { + fDeringingMin = ffxMin(fDeringingMin, fDeringingSamples[iSampleIndex]); + fDeringingMax = ffxMax(fDeringingMax, fDeringingSamples[iSampleIndex]); + } + + fColorXY = clamp(fColorXY, fDeringingMin, fDeringingMax); + + return fColorXY; +} + +#if FFX_HALF +FFX_MIN16_F4 Lanczos2Approx(FetchedBicubicSamplesMin16 Samples, FFX_MIN16_F2 fPxFrac) +{ + FFX_MIN16_F4 fColorX0 = Lanczos2Approx(Samples.fColor00, Samples.fColor10, Samples.fColor20, Samples.fColor30, fPxFrac.x); + FFX_MIN16_F4 fColorX1 = Lanczos2Approx(Samples.fColor01, Samples.fColor11, Samples.fColor21, Samples.fColor31, fPxFrac.x); + FFX_MIN16_F4 fColorX2 = Lanczos2Approx(Samples.fColor02, Samples.fColor12, Samples.fColor22, Samples.fColor32, fPxFrac.x); + FFX_MIN16_F4 fColorX3 = Lanczos2Approx(Samples.fColor03, Samples.fColor13, Samples.fColor23, Samples.fColor33, fPxFrac.x); + FFX_MIN16_F4 fColorXY = Lanczos2Approx(fColorX0, fColorX1, fColorX2, fColorX3, fPxFrac.y); + + // Deringing + + // TODO: only use 4 by checking jitter + const FfxInt32 iDeringingSampleCount = 4; + const FFX_MIN16_F4 fDeringingSamples[4] = { + Samples.fColor11, + Samples.fColor21, + Samples.fColor12, + Samples.fColor22, + }; + + FFX_MIN16_F4 fDeringingMin = fDeringingSamples[0]; + FFX_MIN16_F4 fDeringingMax = fDeringingSamples[0]; + + FFX_UNROLL + for (FfxInt32 iSampleIndex = 1; iSampleIndex < iDeringingSampleCount; ++iSampleIndex) + { + fDeringingMin = ffxMin(fDeringingMin, fDeringingSamples[iSampleIndex]); + fDeringingMax = ffxMax(fDeringingMax, fDeringingSamples[iSampleIndex]); + } + + fColorXY = clamp(fColorXY, fDeringingMin, fDeringingMax); + + return fColorXY; +} +#endif + +// Clamp by offset direction. Assuming iPxSample is already in range and iPxOffset is compile time constant. +FfxInt32x2 ClampCoord(FfxInt32x2 iPxSample, FfxInt32x2 iPxOffset, FfxInt32x2 iTextureSize) +{ + FfxInt32x2 result = iPxSample + iPxOffset; + result.x = ffxMax(1, ffxMin(result.x, iTextureSize.x - 2)); + result.y = ffxMax(1, ffxMin(result.y, iTextureSize.y - 2)); + return result; +} +#if FFX_HALF +FFX_MIN16_I2 ClampCoord(FFX_MIN16_I2 iPxSample, FFX_MIN16_I2 iPxOffset, FFX_MIN16_I2 iTextureSize) +{ + FFX_MIN16_I2 result = iPxSample + iPxOffset; + result.x = ffxMax(FFX_MIN16_I(1), ffxMin(result.x, iTextureSize.x - FFX_MIN16_I(2))); + result.y = ffxMax(FFX_MIN16_I(1), ffxMin(result.y, iTextureSize.y - FFX_MIN16_I(2))); + return result; +} +#endif //FFX_HALF + + +#define DeclareCustomFetchBicubicSamplesWithType(SampleType, TextureType, AddrType, Name, LoadTexture) \ + SampleType Name(AddrType iPxSample, AddrType iTextureSize) \ + { \ + SampleType Samples; \ + \ + Samples.fColor00 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(-1, -1), iTextureSize))); \ + Samples.fColor10 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+0, -1), iTextureSize))); \ + Samples.fColor20 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+1, -1), iTextureSize))); \ + Samples.fColor30 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+2, -1), iTextureSize))); \ + \ + Samples.fColor01 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(-1, +0), iTextureSize))); \ + Samples.fColor11 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+0, +0), iTextureSize))); \ + Samples.fColor21 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+1, +0), iTextureSize))); \ + Samples.fColor31 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+2, +0), iTextureSize))); \ + \ + Samples.fColor02 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(-1, +1), iTextureSize))); \ + Samples.fColor12 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+0, +1), iTextureSize))); \ + Samples.fColor22 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+1, +1), iTextureSize))); \ + Samples.fColor32 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+2, +1), iTextureSize))); \ + \ + Samples.fColor03 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(-1, +2), iTextureSize))); \ + Samples.fColor13 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+0, +2), iTextureSize))); \ + Samples.fColor23 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+1, +2), iTextureSize))); \ + Samples.fColor33 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+2, +2), iTextureSize))); \ + \ + return Samples; \ + } + +#define DeclareCustomFetchBicubicSamples(Name, LoadTexture) \ + DeclareCustomFetchBicubicSamplesWithType(FetchedBicubicSamples, FfxFloat32x4, FfxInt32x2, Name, LoadTexture) + +#define DeclareCustomFetchBicubicSamplesMin16(Name, LoadTexture) \ + DeclareCustomFetchBicubicSamplesWithType(FetchedBicubicSamplesMin16, FFX_MIN16_F4, FfxInt32x2, Name, LoadTexture) + +#define DeclareCustomFetchBilinearSamplesWithType(SampleType, TextureType,AddrType, Name, LoadTexture) \ + SampleType Name(AddrType iPxSample, AddrType iTextureSize) \ + { \ + SampleType Samples; \ + Samples.fColor00 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+0, +0), iTextureSize))); \ + Samples.fColor10 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+1, +0), iTextureSize))); \ + Samples.fColor01 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+0, +1), iTextureSize))); \ + Samples.fColor11 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+1, +1), iTextureSize))); \ + return Samples; \ + } + +#define DeclareCustomFetchBilinearSamples(Name, LoadTexture) \ + DeclareCustomFetchBilinearSamplesWithType(FetchedBilinearSamples, FfxFloat32x4, FfxInt32x2, Name, LoadTexture) + +#define DeclareCustomFetchBilinearSamplesMin16(Name, LoadTexture) \ + DeclareCustomFetchBilinearSamplesWithType(FetchedBilinearSamplesMin16, FFX_MIN16_F4, FfxInt32x2, Name, LoadTexture) + +// BE CAREFUL: there is some precision issues and (3253, 125) leading to (3252.9989778, 125.001102) +// is common, so iPxSample can "jitter" +#define DeclareCustomTextureSample(Name, InterpolateSamples, FetchSamples) \ + FfxFloat32x4 Name(FfxFloat32x2 fUvSample, FfxInt32x2 iTextureSize) \ + { \ + FfxFloat32x2 fPxSample = (fUvSample * FfxFloat32x2(iTextureSize)) - FfxFloat32x2(0.5f, 0.5f); \ + FfxFloat32x2 fPxFrac = ffxFract(fPxSample); \ + /* Clamp base coords */ \ + fPxSample.x = ffxMax(0.0f, ffxMin(FfxFloat32(iTextureSize.x-1), fPxSample.x)); \ + fPxSample.y = ffxMax(0.0f, ffxMin(FfxFloat32(iTextureSize.y-1), fPxSample.y)); \ + /* */ \ + FfxInt32x2 iPxSample = FfxInt32x2(floor(fPxSample)); \ + FfxFloat32x4 fColorXY = FfxFloat32x4(InterpolateSamples(FetchSamples(iPxSample, iTextureSize), fPxFrac)); \ + return fColorXY; \ + } + +#define DeclareCustomTextureSampleMin16(Name, InterpolateSamples, FetchSamples) \ + FFX_MIN16_F4 Name(FfxFloat32x2 fUvSample, FfxInt32x2 iTextureSize) \ + { \ + FfxFloat32x2 fPxSample = (fUvSample * FfxFloat32x2(iTextureSize)) - FfxFloat32x2(0.5f, 0.5f); \ + FFX_MIN16_F2 fPxFrac = FFX_MIN16_F2(ffxFract(fPxSample)); \ + /* Clamp base coords */ \ + fPxSample.x = ffxMax(0.0f, ffxMin(FfxFloat32(iTextureSize.x), fPxSample.x)); \ + fPxSample.y = ffxMax(0.0f, ffxMin(FfxFloat32(iTextureSize.y), fPxSample.y)); \ + /* */ \ + FfxInt32x2 iPxSample = FfxInt32x2(floor(fPxSample)); \ + FFX_MIN16_F4 fColorXY = FFX_MIN16_F4(InterpolateSamples(FetchSamples(iPxSample, iTextureSize), fPxFrac)); \ + return fColorXY; \ + } + +#define FFX_FSR3UPSCALER_CONCAT_ID(x, y) x ## y +#define FFX_FSR3UPSCALER_CONCAT(x, y) FFX_FSR3UPSCALER_CONCAT_ID(x, y) +#define FFX_FSR3UPSCALER_SAMPLER_1D_0 Lanczos2 +#define FFX_FSR3UPSCALER_SAMPLER_1D_1 Lanczos2LUT +#define FFX_FSR3UPSCALER_SAMPLER_1D_2 Lanczos2Approx + +#define FFX_FSR3UPSCALER_GET_LANCZOS_SAMPLER1D(x) FFX_FSR3UPSCALER_CONCAT(FFX_FSR3UPSCALER_SAMPLER_1D_, x) + +#endif //!defined( FFX_FSR3UPSCALER_SAMPLE_H ) diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_shading_change.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_shading_change.h new file mode 100644 index 00000000..2eb23aac --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_shading_change.h @@ -0,0 +1,68 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +FFX_STATIC const FfxInt32 s_MipLevelsToUse = 3; + +struct ShadingChangeLumaInfo +{ + FfxFloat32 fSamples[s_MipLevelsToUse]; +}; + +ShadingChangeLumaInfo ComputeShadingChangeLuma(FfxInt32x2 iPxPos, FfxFloat32x2 fUv, const FfxInt32x2 iCurrentSize) +{ + ShadingChangeLumaInfo info; + + const FfxFloat32x2 fMipUv = ClampUv(fUv, ShadingChangeRenderSize(), GetSPDMipDimensions(0)); + + FFX_UNROLL + for (FfxInt32 iMipLevel = iShadingChangeMipStart; iMipLevel < s_MipLevelsToUse; iMipLevel++) { + + const FfxFloat32x2 fSample = SampleSPDMipLevel(fMipUv, iMipLevel); + + info.fSamples[iMipLevel] = abs(fSample.x * fSample.y); + } + + return info; +} + +void ShadingChange(FfxInt32x2 iPxPos) +{ + if (IsOnScreen(FfxInt32x2(iPxPos), ShadingChangeRenderSize())) { + + const FfxFloat32x2 fUv = (iPxPos + 0.5f) / ShadingChangeRenderSize(); + const FfxFloat32x2 fUvJittered = fUv + Jitter() / RenderSize(); + + const ShadingChangeLumaInfo info = ComputeShadingChangeLuma(iPxPos, fUvJittered, ShadingChangeRenderSize()); + + const FfxFloat32 fScale = 1.0f + iShadingChangeMipStart / s_MipLevelsToUse; + FfxFloat32 fShadingChange = 0.0f; + FFX_UNROLL + for (int iMipLevel = iShadingChangeMipStart; iMipLevel < s_MipLevelsToUse; iMipLevel++) + { + if (info.fSamples[iMipLevel] > 0) { + fShadingChange = ffxMax(fShadingChange, info.fSamples[iMipLevel]) * fScale; + } + } + + StoreShadingChange(iPxPos, ffxSaturate(fShadingChange)); + } +} diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_shading_change_pyramid.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_shading_change_pyramid.h new file mode 100644 index 00000000..63ca5d6d --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_shading_change_pyramid.h @@ -0,0 +1,297 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +FFX_GROUPSHARED FfxUInt32 spdCounter; + +void SpdIncreaseAtomicCounter(FfxUInt32 slice) +{ + SPD_IncreaseAtomicCounter(spdCounter); +} + +FfxUInt32 SpdGetAtomicCounter() +{ + return spdCounter; +} + +void SpdResetAtomicCounter(FfxUInt32 slice) +{ + SPD_ResetAtomicCounter(); +} + +#ifndef SPD_PACKED_ONLY +FFX_GROUPSHARED FfxFloat32 spdIntermediateR[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateG[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateB[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateA[16][16]; + +FFX_STATIC const FfxInt32 DIFFERENCE = 0; +FFX_STATIC const FfxInt32 SIGN_SUM = 1; +FFX_STATIC const FfxInt32 MIP0_INDICATOR = 2; + +FfxFloat32x2 Sort2(FfxFloat32x2 v) +{ + return FfxFloat32x2(ffxMin(v.x, v.y), ffxMax(v.x, v.y)); +} + +struct SampleSet +{ + FfxFloat32 fSamples[SHADING_CHANGE_SET_SIZE]; +}; + +#define CompareSwap(i, j) \ +{ \ +FfxFloat32 fTmp = ffxMin(fSet.fSamples[i], fSet.fSamples[j]);\ +fSet.fSamples[j] = ffxMax(fSet.fSamples[i], fSet.fSamples[j]);\ +fSet.fSamples[i] = fTmp;\ +} + +#if SHADING_CHANGE_SET_SIZE == 5 +FFX_STATIC const FfxInt32x2 iSampleOffsets[5] = {FfxInt32x2(+0, +0), FfxInt32x2(-1, +0), FfxInt32x2(+1, +0), FfxInt32x2(+0, -1), FfxInt32x2(+0, +1)}; + +void SortSet(FFX_PARAMETER_INOUT SampleSet fSet) +{ + CompareSwap(0, 3); + CompareSwap(1, 4); + CompareSwap(0, 2); + CompareSwap(1, 3); + CompareSwap(0, 1); + CompareSwap(2, 4); + CompareSwap(1, 2); + CompareSwap(3, 4); + CompareSwap(2, 3); +} +#endif + +FfxFloat32 ComputeMinimumDifference(FfxInt32x2 iPxPos, SampleSet fSet0, SampleSet fSet1) +{ + FfxFloat32 fMinDiff = FSR3UPSCALER_FP16_MAX - 1; + FfxInt32 a = 0; + FfxInt32 b = 0; + + SortSet(fSet0); + SortSet(fSet1); + + const FfxFloat32 fMax = ffxMin(fSet0.fSamples[SHADING_CHANGE_SET_SIZE-1], fSet1.fSamples[SHADING_CHANGE_SET_SIZE-1]); + + if (fMax > FSR3UPSCALER_FP32_MIN) { + + FFX_UNROLL + for (FfxInt32 i = 0; i < SHADING_CHANGE_SET_SIZE && (fMinDiff < FSR3UPSCALER_FP16_MAX); i++) { + + FfxFloat32 fDiff = fSet0.fSamples[a] - fSet1.fSamples[b]; + + if (abs(fDiff) > FSR3UPSCALER_FP16_MIN) { + + fDiff = sign(fDiff) * (1.0f - MinDividedByMax(fSet0.fSamples[a], fSet1.fSamples[b])); + + fMinDiff = (abs(fDiff) < abs(fMinDiff)) ? fDiff : fMinDiff; + + a += FfxInt32(fSet0.fSamples[a] < fSet1.fSamples[b]); + b += FfxInt32(fSet0.fSamples[a] >= fSet1.fSamples[b]); + } + else + { + fMinDiff = FSR3UPSCALER_FP16_MAX; + } + } + } + + return fMinDiff * FfxFloat32(fMinDiff < (FSR3UPSCALER_FP16_MAX - 1)); +} + +SampleSet GetCurrentLumaBilinearSamples(FfxFloat32x2 fUv) +{ + const FfxFloat32x2 fUvJittered = fUv + Jitter() / RenderSize(); + const FfxInt32x2 iBasePos = FfxInt32x2(floor(fUvJittered * RenderSize())); + + SampleSet fSet; + + for (FfxInt32 iSampleIndex = 0; iSampleIndex < SHADING_CHANGE_SET_SIZE; iSampleIndex++) { + const FfxInt32x2 iSamplePos = ClampLoad(iBasePos, iSampleOffsets[iSampleIndex], RenderSize()); + fSet.fSamples[iSampleIndex] = LoadCurrentLuma(iSamplePos) * Exposure(); + fSet.fSamples[iSampleIndex] = ffxPow(fSet.fSamples[iSampleIndex], fShadingChangeSamplePow); + fSet.fSamples[iSampleIndex] = ffxMax(fSet.fSamples[iSampleIndex], FSR3UPSCALER_EPSILON); + } + + return fSet; +} + +struct PreviousLumaBilinearSamplesData +{ + SampleSet fSet; + FfxBoolean bIsExistingSample; +}; + +PreviousLumaBilinearSamplesData GetPreviousLumaBilinearSamples(FfxFloat32x2 fUv, FfxFloat32x2 fMotionVector) +{ + PreviousLumaBilinearSamplesData data; + + const FfxFloat32x2 fUvJittered = fUv + PreviousFrameJitter() / PreviousFrameRenderSize(); + const FfxFloat32x2 fReprojectedUv = fUvJittered + fMotionVector; + + data.bIsExistingSample = IsUvInside(fReprojectedUv); + + if (data.bIsExistingSample) { + + const FfxInt32x2 iBasePos = FfxInt32x2(floor(fReprojectedUv * PreviousFrameRenderSize())); + + for (FfxInt32 iSampleIndex = 0; iSampleIndex < SHADING_CHANGE_SET_SIZE; iSampleIndex++) { + + const FfxInt32x2 iSamplePos = ClampLoad(iBasePos, iSampleOffsets[iSampleIndex], PreviousFrameRenderSize()); + data.fSet.fSamples[iSampleIndex] = LoadPreviousLuma(iSamplePos) * DeltaPreExposure() * Exposure(); + data.fSet.fSamples[iSampleIndex] = ffxPow(data.fSet.fSamples[iSampleIndex], fShadingChangeSamplePow); + data.fSet.fSamples[iSampleIndex] = ffxMax(data.fSet.fSamples[iSampleIndex], FSR3UPSCALER_EPSILON); + } + } + + return data; +} + +FfxFloat32 ComputeDiff(FfxInt32x2 iPxPos, FfxFloat32x2 fUv, FfxFloat32x2 fMotionVector) +{ + FfxFloat32 fMinDiff = 0.0f; + + const SampleSet fCurrentSamples = GetCurrentLumaBilinearSamples(fUv); + const PreviousLumaBilinearSamplesData previousData = GetPreviousLumaBilinearSamples(fUv, fMotionVector); + + if (previousData.bIsExistingSample) { + fMinDiff = ComputeMinimumDifference(iPxPos, fCurrentSamples, previousData.fSet); + } + + return fMinDiff; +} + +FfxFloat32x4 SpdLoadSourceImage(FfxFloat32x2 iPxPos, FfxUInt32 slice) +{ + const FfxInt32x2 iPxSamplePos = ClampLoad(FfxInt32x2(iPxPos), FfxInt32x2(0, 0), FfxInt32x2(RenderSize())); + const FfxFloat32x2 fDilatedMotionVector = LoadDilatedMotionVector(iPxSamplePos); + const FfxFloat32x2 fUv = (iPxSamplePos + 0.5f) / RenderSize(); + + const FfxFloat32 fScaledAndSignedLumaDiff = ComputeDiff(iPxSamplePos, fUv, fDilatedMotionVector); + + FfxFloat32x4 fOutput = FfxFloat32x4(0.0f, 0.0f, 0.0f, 0.0f); + fOutput[DIFFERENCE] = fScaledAndSignedLumaDiff; + fOutput[SIGN_SUM] = (fScaledAndSignedLumaDiff != 0.0f) ? sign(fScaledAndSignedLumaDiff) : 0.0f; + fOutput[MIP0_INDICATOR] = 1.0f; + + return fOutput; +} + +FfxFloat32x4 SpdLoad(FfxInt32x2 tex, FfxUInt32 slice) +{ + return FfxFloat32x4(RWLoadPyramid(tex, 5), 0, 0); +} + +FfxFloat32x4 SpdReduce4(FfxFloat32x4 v0, FfxFloat32x4 v1, FfxFloat32x4 v2, FfxFloat32x4 v3) +{ + return (v0 + v1 + v2 + v3) * 0.25f; +} + +void SpdStore(FfxInt32x2 pix, FfxFloat32x4 outValue, FfxUInt32 index, FfxUInt32 slice) +{ + if (index >= iShadingChangeMipStart) + { + StorePyramid(pix, outValue.xy, index); + } +} + +FfxFloat32x4 SpdLoadIntermediate(FfxUInt32 x, FfxUInt32 y) +{ + return FfxFloat32x4( + spdIntermediateR[x][y], + spdIntermediateG[x][y], + spdIntermediateB[x][y], + spdIntermediateA[x][y]); +} +void SpdStoreIntermediate(FfxUInt32 x, FfxUInt32 y, FfxFloat32x4 value) +{ + spdIntermediateR[x][y] = value.x; + spdIntermediateG[x][y] = value.y; + spdIntermediateB[x][y] = value.z; + spdIntermediateA[x][y] = value.w; +} + +#endif + +// define fetch and store functions Packed +#if FFX_HALF + +FFX_GROUPSHARED FfxFloat16x2 spdIntermediateRG[16][16]; +FFX_GROUPSHARED FfxFloat16x2 spdIntermediateBA[16][16]; + +FfxFloat16x4 SpdLoadSourceImageH(FfxFloat32x2 tex, FfxUInt32 slice) +{ + return FfxFloat16x4(0, 0, 0, 0); +} + +FfxFloat16x4 SpdLoadH(FfxInt32x2 p, FfxUInt32 slice) +{ + return FfxFloat16x4(0, 0, 0, 0); +} + +void SpdStoreH(FfxInt32x2 p, FfxFloat16x4 value, FfxUInt32 mip, FfxUInt32 slice) +{ +} + +FfxFloat16x4 SpdLoadIntermediateH(FfxUInt32 x, FfxUInt32 y) +{ + return FfxFloat16x4( + spdIntermediateRG[x][y].x, + spdIntermediateRG[x][y].y, + spdIntermediateBA[x][y].x, + spdIntermediateBA[x][y].y); +} + +void SpdStoreIntermediateH(FfxUInt32 x, FfxUInt32 y, FfxFloat16x4 value) +{ + spdIntermediateRG[x][y] = value.xy; + spdIntermediateBA[x][y] = value.zw; +} + +FfxFloat16x4 SpdReduce4H(FfxFloat16x4 v0, FfxFloat16x4 v1, FfxFloat16x4 v2, FfxFloat16x4 v3) +{ + return (v0 + v1 + v2 + v3) * FfxFloat16(0.25); +} +#endif + +#include "spd/ffx_spd.h" + +void ComputeShadingChangePyramid(FfxUInt32x3 WorkGroupId, FfxUInt32 LocalThreadIndex) +{ +#if FFX_HALF + SpdDownsampleH( + FfxUInt32x2(WorkGroupId.xy), + FfxUInt32(LocalThreadIndex), + FfxUInt32(MipCount()), + FfxUInt32(NumWorkGroups()), + FfxUInt32(WorkGroupId.z), + FfxUInt32x2(WorkGroupOffset())); +#else + SpdDownsample( + FfxUInt32x2(WorkGroupId.xy), + FfxUInt32(LocalThreadIndex), + FfxUInt32(MipCount()), + FfxUInt32(NumWorkGroups()), + FfxUInt32(WorkGroupId.z), + FfxUInt32x2(WorkGroupOffset())); +#endif +} diff --git a/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_upsample.h b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_upsample.h new file mode 100644 index 00000000..801a0a90 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_upsample.h @@ -0,0 +1,644 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +void Deringing(RectificationBox clippingBox, FFX_PARAMETER_INOUT FfxFloat32x3 fColor) +{ + fColor = clamp(fColor, clippingBox.aabbMin, clippingBox.aabbMax); +} + +#ifndef FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE +#define FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE 2 // Approximate +#endif + +FfxFloat32 GetUpsampleLanczosWeight(FfxFloat32x2 fSrcSampleOffset, FfxFloat32 fKernelWeight) +{ + FfxFloat32x2 fSrcSampleOffsetBiased = fSrcSampleOffset * fKernelWeight.xx; +#if FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 0 // LANCZOS_TYPE_REFERENCE + FfxFloat32 fSampleWeight = Lanczos2(length(fSrcSampleOffsetBiased)); +#elif FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 1 // LANCZOS_TYPE_LUT + FfxFloat32 fSampleWeight = Lanczos2_UseLUT(length(fSrcSampleOffsetBiased)); +#elif FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 2 // LANCZOS_TYPE_APPROXIMATE + FfxFloat32 fSampleWeight = Lanczos2ApproxSq(dot(fSrcSampleOffsetBiased, fSrcSampleOffsetBiased)); +#else +#error "Invalid Lanczos type" +#endif + return fSampleWeight; +} + +#if FFX_HALF +FFX_MIN16_F GetUpsampleLanczosWeight(FFX_MIN16_F2 fSrcSampleOffset, FFX_MIN16_F fKernelWeight) +{ + FFX_MIN16_F2 fSrcSampleOffsetBiased = fSrcSampleOffset * fKernelWeight.xx; +#if FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 0 // LANCZOS_TYPE_REFERENCE + FFX_MIN16_F fSampleWeight = Lanczos2(length(fSrcSampleOffsetBiased)); +#elif FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 1 // LANCZOS_TYPE_LUT + FFX_MIN16_F fSampleWeight = Lanczos2_UseLUT(length(fSrcSampleOffsetBiased)); +#elif FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 2 // LANCZOS_TYPE_APPROXIMATE + FFX_MIN16_F fSampleWeight = Lanczos2ApproxSq(dot(fSrcSampleOffsetBiased, fSrcSampleOffsetBiased)); + + // To Test: Save reciproqual sqrt compute + // FfxFloat32 fSampleWeight = Lanczos2Sq_UseLUT(dot(fSrcSampleOffsetBiased, fSrcSampleOffsetBiased)); +#else +#error "Invalid Lanczos type" +#endif + return fSampleWeight; +} +#endif + +FfxFloat32 ComputeMaxKernelWeight(const AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data) { + + const FfxFloat32 fKernelSizeBias = 1.0f + (1.0f / FfxFloat32x2(DownscaleFactor()) - 1.0f).x; + + return ffxMin(FfxFloat32(1.99f), fKernelSizeBias); +} + +FfxFloat32x3 LoadPreparedColor(FfxInt32x2 iSamplePos) +{ + const FfxFloat32x3 fRgb = ffxMax(FfxFloat32x3(0, 0, 0), LoadInputColor(iSamplePos)) * Exposure(); + const FfxFloat32x3 fPreparedYCoCg = RGBToYCoCg(fRgb); + + return fPreparedYCoCg; +} + +#if FFX_HALF && (FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 2) && defined(__XBOX_SCARLETT) && defined(__XBATG_EXTRA_16_BIT_OPTIMISATION) && (__XBATG_EXTRA_16_BIT_OPTIMISATION == 1) +#define FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS 1 +#else +#define FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS 0 +#endif + +#if FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS + +void LoadPreparedColorPairedRgb(FFX_PARAMETER_OUT FFX_MIN16_F2 r, + FFX_PARAMETER_OUT FFX_MIN16_F2 g, + FFX_PARAMETER_OUT FFX_MIN16_F2 b, + FfxInt32x2 iSamplePos0, + FfxInt32x2 iSamplePos1) +{ + const FFX_MIN16_F3 sample0 = FFX_MIN16_F3(LoadInputColor(iSamplePos0)); + const FFX_MIN16_F3 sample1 = FFX_MIN16_F3(LoadInputColor(iSamplePos1)); + + r = ffxMax(FFX_MIN16_F2(0, 0), FFX_MIN16_F2(sample0.r, sample1.r)); + g = ffxMax(FFX_MIN16_F2(0, 0), FFX_MIN16_F2(sample0.g, sample1.g)); + b = ffxMax(FFX_MIN16_F2(0, 0), FFX_MIN16_F2(sample0.b, sample1.b)); + + r = FFX_MIN16_F2(r * Exposure()); + g = FFX_MIN16_F2(g * Exposure()); + b = FFX_MIN16_F2(b * Exposure()); +} + +void TonemapPaired(FFX_PARAMETER_INOUT FFX_MIN16_F2 r, FFX_PARAMETER_INOUT FFX_MIN16_F2 g, FFX_PARAMETER_INOUT FFX_MIN16_F2 b) +{ + FFX_MIN16_F2 denomF16 = ffxMax(ffxMax(ffxMax(0.0, r), g), b) + FFX_MIN16_F2(1.0, 1.0); + + // NOTE: expect 2 x v_cvt_f32_f16 + FfxFloat32x2 denomF32 = FfxFloat32x2(denomF16); + // NOTE: expect 2 x v_rcp_f32 + FfxFloat32x2 normF32 = FfxFloat32x2(1.0, 1.0) / denomF32; + // NOTE: expect 2 x v_cvt_f16_f32 + FFX_MIN16_F2 normF16 = FFX_MIN16_F2(normF32); + + r *= normF16; + g *= normF16; + b *= normF16; +} + +void RGBToYCoCgPaired(FFX_PARAMETER_INOUT FFX_MIN16_F2 r, FFX_PARAMETER_INOUT FFX_MIN16_F2 g, FFX_PARAMETER_INOUT FFX_MIN16_F2 b) +{ + /** + * NOTE: given the following conversion + * + * fYCoCg = FfxFloat32x3( + * 0.25f * fRgb.r + 0.5f * fRgb.g + 0.25f * fRgb.b, + * 0.5f * fRgb.r - 0.5f * fRgb.b, + * -0.25f * fRgb.r + 0.5f * fRgb.g - 0.25f * fRgb.b); + * + * it's possible to notice that we can compute: + * RplusBdiv4 = 0.25 * (R + B) + * + * so everything else is computed in 3 instructions + * Y = G * 0.5 + RplusBdiv4 + * Co = 2 * RplusBdiv4 - G + * Cg = G * 0.5 - RplusBdiv4 + */ + + // NOTE: expect v_pk_add_f32 + v_pk_mul_f32 + FFX_MIN16_F2 RplusBdiv4 = (r + b) * 0.25; + FFX_MIN16_F2 G = g; + FFX_MIN16_F2 B = b; + + // NOTE: expect 3x v_pk_fma_f32 + r = G * 0.5 + RplusBdiv4; + g = RplusBdiv4 * 2.0 - B; + b = G * 0.5 - RplusBdiv4; +} + +FFX_MIN16_F2 Compute3x3SamplesMinMaxPaired(FFX_PARAMETER_IN FFX_MIN16_F2 sampleCenter, + FFX_PARAMETER_IN FFX_MIN16_F2 sample0, + FFX_PARAMETER_IN FFX_MIN16_F2 sample1, + FFX_PARAMETER_IN FFX_MIN16_F2 sample2, + FFX_PARAMETER_IN FFX_MIN16_F2 sample3) +{ + FFX_MIN16_F2 twoMinValues = ffxMin(ffxMin(sample0, sample1), ffxMin(sample2, sample3)); + FFX_MIN16_F2 twoMaxValues = ffxMax(ffxMax(sample0, sample1), ffxMax(sample2, sample3)); + + return FFX_MIN16_F2( + ffxMin3Half(twoMinValues.x, twoMinValues.y, sampleCenter.x), + ffxMax3Half(twoMaxValues.x, twoMaxValues.y, sampleCenter.x) + ); +} + + +FFX_MIN16_F2 Bool2ToFloat16x2(bool x, bool y) +{ + uint lo = x ? 0x00003c00 : 0x00000000; + uint hi = y ? 0x3c000000 : 0x00000000; + return FFX_MIN16_F2(__XB_AsHalf(lo).x, __XB_AsHalf(hi).y); +} + +struct PairedRectificationBoxAndAccumulatedColorAndWeight +{ + FFX_MIN16_F2 boxCenterR; + FFX_MIN16_F2 boxCenterG; + FFX_MIN16_F2 boxCenterB; + + FFX_MIN16_F2 boxVecR; + FFX_MIN16_F2 boxVecG; + FFX_MIN16_F2 boxVecB; + + FFX_MIN16_F2 fBoxCenterWeight; + + FFX_MIN16_F2 fColorR; + FFX_MIN16_F2 fColorG; + FFX_MIN16_F2 fColorB; + FFX_MIN16_F2 fWeight; + + FFX_MIN16_F fKernelBiasSq; + FFX_MIN16_F fRectificationCurveBias; + + void setKernelBiasAndRectificationCurveBias(FfxFloat32 kernelBias, FfxFloat32 rectificationCurveBias) + { + fKernelBiasSq = FFX_MIN16_F(kernelBias * kernelBias); + fRectificationCurveBias = FFX_MIN16_F(rectificationCurveBias); + } + + void initUpscaledColor(FFX_MIN16_F fSrcSampleOffsetSq, FFX_MIN16_F fOnScreenWeight, FFX_MIN16_F2 sampleR, FFX_MIN16_F2 sampleG, FFX_MIN16_F2 sampleB) + { + #if FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 2 // LANCZOS_TYPE_APPROXIMATE + const FFX_MIN16_F2 LanczosUpsampleWeight = FFX_MIN16_F2( + PairedLanczos2ApproxSq(fSrcSampleOffsetSq * fKernelBiasSq).x, + 0.0 + ); + #else + #error "Only LANCZOS_TYPE_APPROXIMATE is supported in paired version so far" + #endif + const FFX_MIN16_F2 fSampleWeight = fOnScreenWeight * LanczosUpsampleWeight; + + fColorR = sampleR * fSampleWeight; + fColorG = sampleG * fSampleWeight; + fColorB = sampleB * fSampleWeight; + fWeight = fSampleWeight; + } + + void initBox(FFX_MIN16_F fSrcSampleOffsetSq, FFX_MIN16_F fOnScreenWeight, FFX_MIN16_F2 sampleR, FFX_MIN16_F2 sampleG, FFX_MIN16_F2 sampleB) + { + const FFX_MIN16_F2 fBoxSampleWeight = FFX_MIN16_F2( + exp(fRectificationCurveBias * fSrcSampleOffsetSq) * fOnScreenWeight, + 0.0 + ); + + FFX_MIN16_F2 weightedSampleR = sampleR * fBoxSampleWeight; + FFX_MIN16_F2 weightedSampleG = sampleG * fBoxSampleWeight; + FFX_MIN16_F2 weightedSampleB = sampleB * fBoxSampleWeight; + + boxCenterR = weightedSampleR; + boxCenterG = weightedSampleG; + boxCenterB = weightedSampleB; + + boxVecR = sampleR * weightedSampleR; + boxVecG = sampleG * weightedSampleG; + boxVecB = sampleB * weightedSampleB; + + fBoxCenterWeight = fBoxSampleWeight; + } + + void addUpscaledColorSample(FFX_MIN16_F2 fSrcSampleOffsetSq, FFX_MIN16_F2 fOnScreenWeight, FFX_MIN16_F2 sampleR, FFX_MIN16_F2 sampleG, FFX_MIN16_F2 sampleB) + { + #if FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 2 // LANCZOS_TYPE_APPROXIMATE + const FFX_MIN16_F2 LanczosUpsampleWeight = PairedLanczos2ApproxSq(fSrcSampleOffsetSq * fKernelBiasSq); + #else + #error "Only LANCZOS_TYPE_APPROXIMATE is supported in paired version so far" + #endif + const FFX_MIN16_F2 fSampleWeight = fOnScreenWeight * LanczosUpsampleWeight; + + fColorR += sampleR * fSampleWeight; + fColorG += sampleG * fSampleWeight; + fColorB += sampleB * fSampleWeight; + fWeight += fSampleWeight; + } + + void addBoxSample(FFX_MIN16_F2 fSrcSampleOffsetSq, FFX_MIN16_F2 fOnScreenWeight, FFX_MIN16_F2 sampleR, FFX_MIN16_F2 sampleG, FFX_MIN16_F2 sampleB) + { + // NOTE: ideally expect here 2x v_fma_mix + 2x v_exp_f32 + 2x v_fma_mix + const FFX_MIN16_F2 fBoxSampleWeight = exp(fRectificationCurveBias * fSrcSampleOffsetSq) * fOnScreenWeight; + + FFX_MIN16_F2 weightedSampleR = sampleR * fBoxSampleWeight; + FFX_MIN16_F2 weightedSampleG = sampleG * fBoxSampleWeight; + FFX_MIN16_F2 weightedSampleB = sampleB * fBoxSampleWeight; + + boxCenterR += weightedSampleR; + boxCenterG += weightedSampleG; + boxCenterB += weightedSampleB; + + boxVecR += sampleR * weightedSampleR; + boxVecG += sampleG * weightedSampleG; + boxVecB += sampleB * weightedSampleB; + + fBoxCenterWeight += fBoxSampleWeight; + } + + void finalizeUpscaledColor(FFX_PARAMETER_OUT FfxFloat32x4 upscaledColorAndWeight) + { + upscaledColorAndWeight.r = fColorR.x + fColorR.y; + upscaledColorAndWeight.g = fColorG.x + fColorG.y; + upscaledColorAndWeight.b = fColorB.x + fColorB.y; + + upscaledColorAndWeight.a = fWeight.x + fWeight.y; + } + + void finalizeBox(FFX_PARAMETER_OUT FfxFloat32x2 boxCenterAndVecR, + FFX_PARAMETER_OUT FfxFloat32x2 boxCenterAndVecG, + FFX_PARAMETER_OUT FfxFloat32x2 boxCenterAndVecB, + FFX_PARAMETER_OUT FfxFloat32 boxCenterWeight) + { + boxCenterAndVecR = FfxFloat32x2(boxCenterR.x + boxCenterR.y, boxVecR.x + boxVecR.y); + boxCenterAndVecG = FfxFloat32x2(boxCenterG.x + boxCenterG.y, boxVecG.x + boxVecG.y); + boxCenterAndVecB = FfxFloat32x2(boxCenterB.x + boxCenterB.y, boxVecB.x + boxVecB.y); + + boxCenterWeight = fBoxCenterWeight.x + fBoxCenterWeight.y; + } +}; +#endif // #if FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS + +void ComputeUpsampledColorAndWeight(const AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data) +{ + // We compute a sliced lanczos filter with 2 lobes (other slices are accumulated temporaly) + const FfxFloat32x2 fDstOutputPos = FfxFloat32x2(params.iPxHrPos) + FFX_BROADCAST_FLOAT32X2(0.5f); + const FfxFloat32x2 fSrcOutputPos = fDstOutputPos * DownscaleFactor(); + const FfxInt32x2 iSrcInputPos = FfxInt32x2(floor(fSrcOutputPos)); + const FfxFloat32x2 fSrcUnjitteredPos = (FfxFloat32x2(iSrcInputPos) + FfxFloat32x2(0.5f, 0.5f)) - Jitter(); // This is the un-jittered position of the sample at offset 0,0 + const FfxFloat32x2 fBaseSampleOffset = FfxFloat32x2(fSrcUnjitteredPos - fSrcOutputPos); + + FfxInt32x2 offsetTL; + offsetTL.x = (fSrcUnjitteredPos.x > fSrcOutputPos.x) ? FfxInt32(-2) : FfxInt32(-1); + offsetTL.y = (fSrcUnjitteredPos.y > fSrcOutputPos.y) ? FfxInt32(-2) : FfxInt32(-1); + + //Load samples + // If fSrcUnjitteredPos.y > fSrcOutputPos.y, indicates offsetTL.y = -2, sample offset Y will be [-2, 1], clipbox will be rows [1, 3]. + // Flip row# for sampling offset in this case, so first 0~2 rows in the sampled array can always be used for computing the clipbox. + // This reduces branch or cmove on sampled colors, but moving this overhead to sample position / weight calculation time which apply to less values. + const FfxBoolean bFlipRow = fSrcUnjitteredPos.y > fSrcOutputPos.y; + const FfxBoolean bFlipCol = fSrcUnjitteredPos.x > fSrcOutputPos.x; + const FfxFloat32x2 fOffsetTL = FfxFloat32x2(offsetTL); + + const FfxBoolean bIsInitialSample = (params.fAccumulation == 0.0f); + +#if FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS + // Unroll the loop to load samples on Scarlett to help the shader compiler + const FFX_MIN16_F2 fSampleOffsetX02 = __XB_AsHalf(bFlipCol ? __XB_AsUInt(FFX_MIN16_F2( 1, -1)) : __XB_AsUInt(FFX_MIN16_F2(-1, 1))); + const FFX_MIN16_F2 fSampleOffsetY02 = __XB_AsHalf(bFlipRow ? __XB_AsUInt(FFX_MIN16_F2( 1, -1)) : __XB_AsUInt(FFX_MIN16_F2(-1, 1))); + + typedef FfxInt32 FfxTexCoordI; + typedef FfxInt32x2 FfxTexCoordI2; + + const FfxTexCoordI2 iSrcSamplePosX01 = FfxTexCoordI2(iSrcInputPos.xx) + (bFlipCol ? FfxTexCoordI2( 1, 0) : FfxTexCoordI2(-1, 0)); + const FfxTexCoordI2 iSrcSamplePosX23 = FfxTexCoordI2(iSrcInputPos.xx) + (bFlipCol ? FfxTexCoordI2(-1, -2) : FfxTexCoordI2( 1, 2)); + + const FfxTexCoordI2 iSrcSamplePosY01 = FfxTexCoordI2(iSrcInputPos.yy) + (bFlipRow ? FfxTexCoordI2( 1, 0) : FfxTexCoordI2(-1, 0)); + const FfxTexCoordI2 iSrcSamplePosY23 = FfxTexCoordI2(iSrcInputPos.yy) + (bFlipRow ? FfxTexCoordI2(-1, -2) : FfxTexCoordI2( 1, 2)); + + const FfxTexCoordI2 renderSizeLastTexelCoord = FfxTexCoordI2(RenderSize()) - FfxTexCoordI2(1, 1); + + const FfxTexCoordI2 iSrcSamplePosX01Clamped = FfxTexCoordI2( + __XB_Med3_I32(iSrcSamplePosX01.x, 0, renderSizeLastTexelCoord.x), + __XB_Med3_I32(iSrcSamplePosX01.y, 0, renderSizeLastTexelCoord.x) + ); + + const FfxTexCoordI2 iSrcSamplePosX23Clamped = FfxTexCoordI2( + __XB_Med3_I32(iSrcSamplePosX23.x, 0, renderSizeLastTexelCoord.x), + __XB_Med3_I32(iSrcSamplePosX23.y, 0, renderSizeLastTexelCoord.x) + ); + + const FfxTexCoordI2 iSrcSamplePosY01Clamped = FfxTexCoordI2( + __XB_Med3_I32(iSrcSamplePosY01.x, 0, renderSizeLastTexelCoord.y), + __XB_Med3_I32(iSrcSamplePosY01.y, 0, renderSizeLastTexelCoord.y) + ); + + const FfxTexCoordI2 iSrcSamplePosY23Clamped = FfxTexCoordI2( + __XB_Med3_I32(iSrcSamplePosY23.x, 0, renderSizeLastTexelCoord.y), + __XB_Med3_I32(iSrcSamplePosY23.y, 0, renderSizeLastTexelCoord.y) + ); + + FFX_MIN16_F2 TopCornerR, BotCornerR, HorzR, VertR, CenterR; + FFX_MIN16_F2 TopCornerG, BotCornerG, HorzG, VertG, CenterG; + FFX_MIN16_F2 TopCornerB, BotCornerB, HorzB, VertB, CenterB; + + LoadPreparedColorPairedRgb(TopCornerR, TopCornerG, TopCornerB, + FfxTexCoordI2(iSrcSamplePosX01Clamped.x, iSrcSamplePosY01Clamped.x), + FfxTexCoordI2(iSrcSamplePosX23Clamped.x, iSrcSamplePosY01Clamped.x) + ); + + LoadPreparedColorPairedRgb(BotCornerR, BotCornerG, BotCornerB, + FfxTexCoordI2(iSrcSamplePosX01Clamped.x, iSrcSamplePosY23Clamped.x), + FfxTexCoordI2(iSrcSamplePosX23Clamped.x, iSrcSamplePosY23Clamped.x) + ); + + LoadPreparedColorPairedRgb(HorzR, HorzG, HorzB, + FfxTexCoordI2(iSrcSamplePosX01Clamped.x, iSrcSamplePosY01Clamped.y), + FfxTexCoordI2(iSrcSamplePosX23Clamped.x, iSrcSamplePosY01Clamped.y) + ); + + LoadPreparedColorPairedRgb(VertR, VertG, VertB, + FfxTexCoordI2(iSrcSamplePosX01Clamped.y, iSrcSamplePosY01Clamped.x), + FfxTexCoordI2(iSrcSamplePosX01Clamped.y, iSrcSamplePosY23Clamped.x) + ); + + // NOTE: duplicated data + LoadPreparedColorPairedRgb(CenterR, CenterG, CenterB, + FfxTexCoordI2(iSrcSamplePosX01Clamped.y, iSrcSamplePosY01Clamped.y), + FfxTexCoordI2(iSrcSamplePosX01Clamped.y, iSrcSamplePosY01Clamped.y) + ); + + #if FFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT + if (bIsInitialSample) + { + TonemapPaired(TopCornerR, TopCornerG, TopCornerB); + TonemapPaired(BotCornerR, BotCornerG, BotCornerB); + TonemapPaired(HorzR, HorzG, HorzB); + TonemapPaired(VertR, VertG, VertB); + TonemapPaired(CenterR, CenterG, CenterB); + } + #endif + + RGBToYCoCgPaired(TopCornerR, TopCornerG, TopCornerB); + RGBToYCoCgPaired(BotCornerR, BotCornerG, BotCornerB); + RGBToYCoCgPaired(HorzR, HorzG, HorzB); + RGBToYCoCgPaired(VertR, VertG, VertB); + RGBToYCoCgPaired(CenterR, CenterG, CenterB); + +#else + FfxFloat32x3 fSamples[9]; + FfxInt32 iSampleIndex = 0; + + FFX_UNROLL + for (FfxInt32 row = 0; row < 3; row++) { + FFX_UNROLL + for (FfxInt32 col = 0; col < 3; col++) { + const FfxInt32x2 iSampleColRow = FfxInt32x2(bFlipCol ? (3 - col) : col, bFlipRow ? (3 - row) : row); + const FfxInt32x2 iSrcSamplePos = FfxInt32x2(iSrcInputPos) + offsetTL + iSampleColRow; + const FfxInt32x2 iSampleCoord = ClampLoad(iSrcSamplePos, FfxInt32x2(0, 0), FfxInt32x2(RenderSize())); + + fSamples[iSampleIndex] = LoadPreparedColor(iSampleCoord); + + ++iSampleIndex; + } + } + +#if FFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT + if (bIsInitialSample) + { + for (iSampleIndex = 0; iSampleIndex < 9; ++iSampleIndex) + { + //YCoCg -> RGB -> Tonemap -> YCoCg (Use RGB tonemapper to avoid color desaturation) + fSamples[iSampleIndex] = RGBToYCoCg(Tonemap(YCoCgToRGB(fSamples[iSampleIndex]))); + } + } +#endif + +#endif // #if FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS + + // Identify how much of each upsampled color to be used for this frame + const FfxFloat32 fKernelBiasMax = ComputeMaxKernelWeight(params, data); + const FfxFloat32 fKernelBiasMin = ffxMax(1.0f, ((1.0f + fKernelBiasMax) * 0.3f)); + + const FfxFloat32 fKernelBiasWeight = + ffxMin(1.0f - params.fDisocclusion * 0.5f, + ffxMin(1.0f - params.fShadingChange, + ffxSaturate(data.fHistoryWeight * 5.0f) + )); + + const FfxFloat32 fKernelBias = ffxLerp(fKernelBiasMin, fKernelBiasMax, fKernelBiasWeight); + +#if FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS + // Unroll the loop to load samples on Scarlett to help the shader compiler + const bool coordX0OnScreen = iSrcSamplePosX01.x == iSrcSamplePosX01Clamped.x; + const bool coordX1OnScreen = iSrcSamplePosX01.y == iSrcSamplePosX01Clamped.y; + const bool coordX2OnScreen = iSrcSamplePosX23.x == iSrcSamplePosX23Clamped.x; + + const bool coordY0OnScreen = iSrcSamplePosY01.x == iSrcSamplePosY01Clamped.x; + const bool coordY1OnScreen = iSrcSamplePosY01.y == iSrcSamplePosY01Clamped.y; + const bool coordY2OnScreen = iSrcSamplePosY23.x == iSrcSamplePosY23Clamped.x; + + const FFX_MIN16_F2 fBaseSampleOffsetHalf = FFX_MIN16_F2(fBaseSampleOffset); + + const FFX_MIN16_F2 fSrcSampleOffsetX_02 = fBaseSampleOffsetHalf.xx + fSampleOffsetX02; + const FFX_MIN16_F2 fSrcSampleOffsetY_02 = fBaseSampleOffsetHalf.yy + fSampleOffsetY02; + + const FFX_MIN16_F2 fSrcSampleOffsetXSq_02 = fSrcSampleOffsetX_02 * fSrcSampleOffsetX_02; + const FFX_MIN16_F2 fSrcSampleOffsetYSq_02 = fSrcSampleOffsetY_02 * fSrcSampleOffsetY_02; + const FFX_MIN16_F2 fSrcSampleOffsetXYSq_11 = fBaseSampleOffsetHalf * fBaseSampleOffsetHalf; + + const FfxFloat32 fRectificationCurveBias = -2.3f; + PairedRectificationBoxAndAccumulatedColorAndWeight pairedBox; + pairedBox.setKernelBiasAndRectificationCurveBias(fKernelBias, fRectificationCurveBias); + + // init by o o o + // o x o + // o o o + pairedBox.initBox( + fSrcSampleOffsetXYSq_11.x + fSrcSampleOffsetXYSq_11.y, + Bool2ToFloat16x2(coordX1OnScreen && coordY1OnScreen, false).x, + CenterR, CenterG, CenterB + ); + + // add remaining two samples from 1st row x o x + // o * o + // o o o + pairedBox.addBoxSample( + fSrcSampleOffsetXSq_02 + fSrcSampleOffsetYSq_02.xx, + Bool2ToFloat16x2(coordX0OnScreen && coordY0OnScreen, coordX2OnScreen && coordY0OnScreen), + TopCornerR, TopCornerG, TopCornerB + ); + + // add two samples from 2nd row * o * + // o * o + // x o x + pairedBox.addBoxSample( + fSrcSampleOffsetXSq_02 + fSrcSampleOffsetYSq_02.yy, + Bool2ToFloat16x2(coordX0OnScreen && coordY2OnScreen, coordX2OnScreen && coordY2OnScreen), + BotCornerR, BotCornerG, BotCornerB + ); + + // add two samples from 3rd row * o * + // x * x + // * o * + pairedBox.addBoxSample( + fSrcSampleOffsetXSq_02 + fSrcSampleOffsetXYSq_11.yy, + Bool2ToFloat16x2(coordX0OnScreen && coordY1OnScreen, coordX2OnScreen && coordY1OnScreen), + HorzR, HorzG, HorzB + ); + + // add remaining samples * x * + // * * * + // * x * + pairedBox.addBoxSample( + fSrcSampleOffsetXYSq_11.xx + fSrcSampleOffsetYSq_02, + Bool2ToFloat16x2(coordX1OnScreen && coordY0OnScreen, coordX1OnScreen && coordY2OnScreen), + VertR, VertG, VertB + ); + + FfxFloat32x2 boxCenterAndVecR, boxCenterAndVecG, boxCenterAndVecB; + FfxFloat32 boxCenterWeight; + pairedBox.finalizeBox(boxCenterAndVecR, boxCenterAndVecG, boxCenterAndVecB, boxCenterWeight); + + if (!bIsInitialSample) + { + pairedBox.initUpscaledColor( + fSrcSampleOffsetXYSq_11.x + fSrcSampleOffsetXYSq_11.y, + Bool2ToFloat16x2(coordX1OnScreen && coordY1OnScreen, false).x, + CenterR, CenterG, CenterB + ); + + // add remaining two samples from 1st row x o x + // o * o + // o o o + pairedBox.addUpscaledColorSample( + fSrcSampleOffsetXSq_02 + fSrcSampleOffsetYSq_02.xx, + Bool2ToFloat16x2(coordX0OnScreen && coordY0OnScreen, coordX2OnScreen && coordY0OnScreen), + TopCornerR, TopCornerG, TopCornerB + ); + + // add two samples from 2nd row * o * + // o * o + // x o x + pairedBox.addUpscaledColorSample( + fSrcSampleOffsetXSq_02 + fSrcSampleOffsetYSq_02.yy, + Bool2ToFloat16x2(coordX0OnScreen && coordY2OnScreen, coordX2OnScreen && coordY2OnScreen), + BotCornerR, BotCornerG, BotCornerB + ); + + // add two samples from 3rd row * o * + // x * x + // * o * + pairedBox.addUpscaledColorSample( + fSrcSampleOffsetXSq_02 + fSrcSampleOffsetXYSq_11.yy, + Bool2ToFloat16x2(coordX0OnScreen && coordY1OnScreen, coordX2OnScreen && coordY1OnScreen), + HorzR, HorzG, HorzB + ); + + // add remaining samples * x * + // * * * + // * x * + pairedBox.addUpscaledColorSample( + fSrcSampleOffsetXYSq_11.xx + fSrcSampleOffsetYSq_02, + Bool2ToFloat16x2(coordX1OnScreen && coordY0OnScreen, coordX1OnScreen && coordY2OnScreen), + VertR, VertG, VertB + ); + + FfxFloat32x4 upscaledColorAndWeight = 0.0; + pairedBox.finalizeUpscaledColor(upscaledColorAndWeight); + + data.fUpsampledColor = FfxFloat32x3(upscaledColorAndWeight.rgb); + data.fUpsampledWeight = FfxFloat32(upscaledColorAndWeight.w); + } + + FFX_MIN16_F2 aabbMinMaxR = Compute3x3SamplesMinMaxPaired(CenterR, TopCornerR, BotCornerR, HorzR, VertR); + FFX_MIN16_F2 aabbMinMaxG = Compute3x3SamplesMinMaxPaired(CenterG, TopCornerG, BotCornerG, HorzG, VertG); + FFX_MIN16_F2 aabbMinMaxB = Compute3x3SamplesMinMaxPaired(CenterB, TopCornerB, BotCornerB, HorzB, VertB); + + data.clippingBox.boxCenter = FfxFloat32x3(boxCenterAndVecR.x, boxCenterAndVecG.x, boxCenterAndVecB.x); + data.clippingBox.boxVec = FfxFloat32x3(boxCenterAndVecR.y, boxCenterAndVecG.y, boxCenterAndVecB.y); + data.clippingBox.aabbMin = FfxFloat32x3(aabbMinMaxR.x, aabbMinMaxG.x, aabbMinMaxB.x); + data.clippingBox.aabbMax = FfxFloat32x3(aabbMinMaxR.y, aabbMinMaxG.y, aabbMinMaxB.y); + data.clippingBox.fBoxCenterWeight = FfxFloat32(boxCenterWeight); +#else + + iSampleIndex = 0; + + FFX_UNROLL + for (FfxInt32 row = 0; row < 3; row++) + { + FFX_UNROLL + for (FfxInt32 col = 0; col < 3; col++) + { + const FfxInt32x2 sampleColRow = FfxInt32x2(bFlipCol ? (3 - col) : col, bFlipRow ? (3 - row) : row); + const FfxFloat32x2 fOffset = fOffsetTL + FfxFloat32x2(sampleColRow); + const FfxFloat32x2 fSrcSampleOffset = fBaseSampleOffset + fOffset; + + const FfxInt32x2 iSrcSamplePos = FfxInt32x2(iSrcInputPos) + FfxInt32x2(offsetTL) + sampleColRow; + const FfxFloat32 fOnScreenFactor = FfxFloat32(IsOnScreen(FfxInt32x2(iSrcSamplePos), FfxInt32x2(RenderSize()))); + + if (!bIsInitialSample) + { + const FfxFloat32 fSampleWeight = fOnScreenFactor * FfxFloat32(GetUpsampleLanczosWeight(fSrcSampleOffset, fKernelBias)); + + data.fUpsampledColor += fSamples[iSampleIndex] * fSampleWeight; + data.fUpsampledWeight += fSampleWeight; + } + + // Update rectification box + { + const FfxFloat32 fRectificationCurveBias = -2.3f; + const FfxFloat32 fSrcSampleOffsetSq = dot(fSrcSampleOffset, fSrcSampleOffset); + const FfxFloat32 fBoxSampleWeight = exp(fRectificationCurveBias * fSrcSampleOffsetSq) * fOnScreenFactor; + + const FfxBoolean bInitialSample = (row == 0) && (col == 0); + RectificationBoxAddSample(bInitialSample, data.clippingBox, fSamples[iSampleIndex], fBoxSampleWeight); + } + ++iSampleIndex; + } + } + +#endif // #if FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS + + RectificationBoxComputeVarianceBoxData(data.clippingBox); + + data.fUpsampledWeight *= FfxFloat32(data.fUpsampledWeight > FSR3UPSCALER_EPSILON); + + if (data.fUpsampledWeight > FSR3UPSCALER_EPSILON) { + // Normalize for deringing (we need to compare colors) + data.fUpsampledColor = data.fUpsampledColor / data.fUpsampledWeight; + data.fUpsampledWeight *= fAverageLanczosWeightPerFrame; + + Deringing(data.clippingBox, data.fUpsampledColor); + } + + // Initial samples using tonemapped upsampling + if (bIsInitialSample) { +#if FFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT + data.fUpsampledColor = RGBToYCoCg(InverseTonemap(YCoCgToRGB(data.clippingBox.boxCenter))); +#else + data.fUpsampledColor = data.clippingBox.boxCenter; +#endif + data.fUpsampledWeight = 1.0f; + data.fHistoryWeight = 0.0f; + } +} diff --git a/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_accumulate_pass.glsl b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_accumulate_pass.glsl new file mode 100644 index 00000000..3b935755 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_accumulate_pass.glsl @@ -0,0 +1,75 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#version 450 + +#extension GL_GOOGLE_include_directive : require +#extension GL_EXT_samplerless_texture_functions : require +// Needed for rw_upscaled_output declaration +#extension GL_EXT_shader_image_load_formatted : require + +#define FSR3UPSCALER_BIND_SRV_INPUT_EXPOSURE 0 +#define FSR3UPSCALER_BIND_SRV_DILATED_REACTIVE_MASKS 1 +#if FFX_FSR3UPSCALER_OPTION_LOW_RESOLUTION_MOTION_VECTORS +#define FSR3UPSCALER_BIND_SRV_DILATED_MOTION_VECTORS 2 +#else +#define FSR3UPSCALER_BIND_SRV_INPUT_MOTION_VECTORS 2 +#endif +#define FSR3UPSCALER_BIND_SRV_INTERNAL_UPSCALED 3 +#define FSR3UPSCALER_BIND_SRV_LANCZOS_LUT 4 +#define FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH_MIP1 5 + +#define FSR3UPSCALER_BIND_SRV_CURRENT_LUMA 6 +#define FSR3UPSCALER_BIND_SRV_LUMA_INSTABILITY 7 +#define FSR3UPSCALER_BIND_SRV_INPUT_COLOR 8 + +#define FSR3UPSCALER_BIND_UAV_INTERNAL_UPSCALED 9 +#define FSR3UPSCALER_BIND_UAV_UPSCALED_OUTPUT 10 +#define FSR3UPSCALER_BIND_UAV_NEW_LOCKS 11 + +#define FSR3UPSCALER_BIND_CB_FSR3UPSCALER 12 + +#include "fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h" +#include "fsr3upscaler/ffx_fsr3upscaler_common.h" +#include "fsr3upscaler/ffx_fsr3upscaler_sample.h" +#include "fsr3upscaler/ffx_fsr3upscaler_upsample.h" +#include "fsr3upscaler/ffx_fsr3upscaler_reproject.h" +#include "fsr3upscaler/ffx_fsr3upscaler_accumulate.h" + +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#define FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT 8 +#endif // FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#ifndef FFX_FSR3UPSCALER_NUM_THREADS +#define FFX_FSR3UPSCALER_NUM_THREADS layout (local_size_x = FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH, local_size_y = FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT, local_size_z = FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH) in; +#endif // #ifndef FFX_FSR3UPSCALER_NUM_THREADS + +FFX_FSR3UPSCALER_NUM_THREADS +void main() +{ + Accumulate(FfxInt32x2(gl_GlobalInvocationID.xy)); +} diff --git a/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_autogen_reactive_pass.glsl b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_autogen_reactive_pass.glsl new file mode 100644 index 00000000..474cb512 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_autogen_reactive_pass.glsl @@ -0,0 +1,84 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#version 450 + +#extension GL_GOOGLE_include_directive : require +#extension GL_EXT_samplerless_texture_functions : require + +#define FSR3UPSCALER_BIND_SRV_INPUT_OPAQUE_ONLY 0 +#define FSR3UPSCALER_BIND_SRV_INPUT_COLOR 1 + +#define FSR3UPSCALER_BIND_UAV_AUTOREACTIVE 2 +#define FSR3UPSCALER_BIND_UAV_AUTOCOMPOSITION 3 + +#define FSR3UPSCALER_BIND_CB_FSR3UPSCALER 4 +#define FSR3UPSCALER_BIND_CB_REACTIVE 5 + +#include "fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h" +#include "fsr3upscaler/ffx_fsr3upscaler_common.h" + +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#define FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT 8 +#endif // FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#ifndef FFX_FSR3UPSCALER_NUM_THREADS +#define FFX_FSR3UPSCALER_NUM_THREADS layout (local_size_x = FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH, local_size_y = FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT, local_size_z = FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH) in; +#endif // #ifndef FFX_FSR3UPSCALER_NUM_THREADS + +FFX_FSR3UPSCALER_NUM_THREADS +void main() +{ + FfxUInt32x2 uGroupId = gl_WorkGroupID.xy; + FfxUInt32x2 uGroupThreadId = gl_LocalInvocationID.xy; + FfxUInt32x2 uDispatchThreadId = uGroupId * FfxUInt32x2(FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH, FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT) + uGroupThreadId; + + FfxFloat32x3 ColorPreAlpha = LoadOpaqueOnly(FFX_MIN16_I2(uDispatchThreadId)).rgb; + FfxFloat32x3 ColorPostAlpha = LoadInputColor(FfxInt32x2(uDispatchThreadId)).rgb; + + if ((GenReactiveFlags() & FFX_FSR3UPSCALER_AUTOREACTIVEFLAGS_APPLY_TONEMAP) != 0) + { + ColorPreAlpha = Tonemap(ColorPreAlpha); + ColorPostAlpha = Tonemap(ColorPostAlpha); + } + + if ((GenReactiveFlags() & FFX_FSR3UPSCALER_AUTOREACTIVEFLAGS_APPLY_INVERSETONEMAP) != 0) + { + ColorPreAlpha = InverseTonemap(ColorPreAlpha); + ColorPostAlpha = InverseTonemap(ColorPostAlpha); + } + + FfxFloat32 out_reactive_value = 0.f; + FfxFloat32x3 delta = abs(ColorPostAlpha - ColorPreAlpha); + + out_reactive_value = ((GenReactiveFlags() & FFX_FSR3UPSCALER_AUTOREACTIVEFLAGS_USE_COMPONENTS_MAX)!=0) ? max(delta.x, max(delta.y, delta.z)) : length(delta); + out_reactive_value *= GenReactiveScale(); + + out_reactive_value = ((GenReactiveFlags() & FFX_FSR3UPSCALER_AUTOREACTIVEFLAGS_APPLY_THRESHOLD)!=0) ? ((out_reactive_value < GenReactiveThreshold()) ? 0 : GenReactiveBinaryValue()) : out_reactive_value; + + imageStore(rw_output_autoreactive, FfxInt32x2(uDispatchThreadId), FfxFloat32x4(out_reactive_value, 0.0, 0.0, 0.0)); +} diff --git a/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_debug_view_pass.glsl b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_debug_view_pass.glsl new file mode 100644 index 00000000..4840e5bd --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_debug_view_pass.glsl @@ -0,0 +1,59 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#version 450 + +#extension GL_GOOGLE_include_directive : require +#extension GL_EXT_samplerless_texture_functions : require + +#define FSR3UPSCALER_BIND_SRV_DILATED_REACTIVE_MASKS 0 +#define FSR3UPSCALER_BIND_SRV_DILATED_MOTION_VECTORS 1 +#define FSR3UPSCALER_BIND_SRV_DILATED_DEPTH 2 +#define FSR3UPSCALER_BIND_SRV_INTERNAL_UPSCALED 3 +#define FSR3UPSCALER_BIND_SRV_INPUT_EXPOSURE 4 + +#define FSR3UPSCALER_BIND_UAV_UPSCALED_OUTPUT 5 + +#define FSR3UPSCALER_BIND_CB_FSR3UPSCALER 6 + +#include "fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h" +#include "fsr3upscaler/ffx_fsr3upscaler_common.h" +#include "fsr3upscaler/ffx_fsr3upscaler_debug_view.h" + +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#define FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#ifndef FFX_FSR3UPSCALER_NUM_THREADS +#define FFX_FSR3UPSCALER_NUM_THREADS layout (local_size_x = FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH, local_size_y = FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT, local_size_z = FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH) in; +#endif // #ifndef FFX_FSR3UPSCALER_NUM_THREADS + +FFX_FSR3UPSCALER_NUM_THREADS +void main() +{ + DebugView(FfxInt32x2(gl_GlobalInvocationID.xy)); +} diff --git a/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_luma_instability_pass.glsl b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_luma_instability_pass.glsl new file mode 100644 index 00000000..6d5db88e --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_luma_instability_pass.glsl @@ -0,0 +1,62 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#version 450 + +#extension GL_GOOGLE_include_directive : require +#extension GL_EXT_samplerless_texture_functions : require + +#define FSR3UPSCALER_BIND_SRV_INPUT_EXPOSURE 0 +#define FSR3UPSCALER_BIND_SRV_DILATED_REACTIVE_MASKS 1 +#define FSR3UPSCALER_BIND_SRV_DILATED_MOTION_VECTORS 2 +#define FSR3UPSCALER_BIND_SRV_FRAME_INFO 3 +#define FSR3UPSCALER_BIND_SRV_LUMA_HISTORY 4 +#define FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH_MIP1 5 +#define FSR3UPSCALER_BIND_SRV_CURRENT_LUMA 6 + +#define FSR3UPSCALER_BIND_UAV_LUMA_HISTORY 7 +#define FSR3UPSCALER_BIND_UAV_LUMA_INSTABILITY 8 + +#define FSR3UPSCALER_BIND_CB_FSR3UPSCALER 9 + +#include "fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h" +#include "fsr3upscaler/ffx_fsr3upscaler_common.h" +#include "fsr3upscaler/ffx_fsr3upscaler_luma_instability.h" + +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#define FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT 8 +#endif // FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#ifndef FFX_FSR3UPSCALER_NUM_THREADS +#define FFX_FSR3UPSCALER_NUM_THREADS layout (local_size_x = FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH, local_size_y = FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT, local_size_z = FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH) in; +#endif // #ifndef FFX_FSR3UPSCALER_NUM_THREADS + +FFX_FSR3UPSCALER_NUM_THREADS +void main() +{ + LumaInstability(FfxInt32x2(gl_GlobalInvocationID.xy)); +} diff --git a/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_luma_pyramid_pass.glsl b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_luma_pyramid_pass.glsl new file mode 100644 index 00000000..29f4c8f8 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_luma_pyramid_pass.glsl @@ -0,0 +1,65 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#version 450 + +#extension GL_GOOGLE_include_directive : require +#extension GL_EXT_samplerless_texture_functions : require + +#define FSR3UPSCALER_BIND_SRV_CURRENT_LUMA 0 +#define FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH 1 + +#define FSR3UPSCALER_BIND_UAV_SPD_GLOBAL_ATOMIC 2 +#define FSR3UPSCALER_BIND_UAV_FRAME_INFO 3 +#define FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_0 4 +#define FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_1 5 +#define FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_2 6 +#define FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_3 7 +#define FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_4 8 +#define FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_5 9 +#define FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH_MIP1 10 + +#define FSR3UPSCALER_BIND_CB_FSR3UPSCALER 11 +#define FSR3UPSCALER_BIND_CB_SPD 12 + +#include "fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h" +#include "fsr3upscaler/ffx_fsr3upscaler_common.h" +#include "fsr3upscaler/ffx_fsr3upscaler_luma_pyramid.h" + +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH 256 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#define FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#ifndef FFX_FSR3UPSCALER_NUM_THREADS +#define FFX_FSR3UPSCALER_NUM_THREADS layout (local_size_x = FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH, local_size_y = FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT, local_size_z = FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH) in; +#endif // #ifndef FFX_FSR3UPSCALER_NUM_THREADS + +FFX_FSR3UPSCALER_NUM_THREADS +void main() +{ + ComputeAutoExposure(gl_WorkGroupID, gl_LocalInvocationIndex); +} diff --git a/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_prepare_inputs_pass.glsl b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_prepare_inputs_pass.glsl new file mode 100644 index 00000000..6e3c5722 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_prepare_inputs_pass.glsl @@ -0,0 +1,61 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#version 450 + +#extension GL_GOOGLE_include_directive : require +#extension GL_EXT_samplerless_texture_functions : require + +#define FSR3UPSCALER_BIND_SRV_INPUT_MOTION_VECTORS 0 +#define FSR3UPSCALER_BIND_SRV_INPUT_DEPTH 1 +#define FSR3UPSCALER_BIND_SRV_INPUT_COLOR 2 + +#define FSR3UPSCALER_BIND_UAV_DILATED_MOTION_VECTORS 3 +#define FSR3UPSCALER_BIND_UAV_DILATED_DEPTH 4 +#define FSR3UPSCALER_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH 5 +#define FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH 6 +#define FSR3UPSCALER_BIND_UAV_CURRENT_LUMA 7 + +#define FSR3UPSCALER_BIND_CB_FSR3UPSCALER 8 + +#include "fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h" +#include "fsr3upscaler/ffx_fsr3upscaler_common.h" +#include "fsr3upscaler/ffx_fsr3upscaler_prepare_inputs.h" + +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#define FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#ifndef FFX_FSR3UPSCALER_NUM_THREADS +#define FFX_FSR3UPSCALER_NUM_THREADS layout (local_size_x = FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH, local_size_y = FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT, local_size_z = FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH) in; +#endif // #ifndef FFX_FSR3UPSCALER_NUM_THREADS + +FFX_FSR3UPSCALER_NUM_THREADS +void main() +{ + PrepareInputs(FfxInt32x2(gl_GlobalInvocationID.xy)); +} diff --git a/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_prepare_reactivity_pass.glsl b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_prepare_reactivity_pass.glsl new file mode 100644 index 00000000..e09d5d36 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_prepare_reactivity_pass.glsl @@ -0,0 +1,65 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#version 450 + +#extension GL_GOOGLE_include_directive : require +#extension GL_EXT_samplerless_texture_functions : require + +#define FSR3UPSCALER_BIND_SRV_RECONSTRUCTED_PREV_NEAREST_DEPTH 0 +#define FSR3UPSCALER_BIND_SRV_DILATED_MOTION_VECTORS 1 +#define FSR3UPSCALER_BIND_SRV_DILATED_DEPTH 2 +#define FSR3UPSCALER_BIND_SRV_REACTIVE_MASK 3 +#define FSR3UPSCALER_BIND_SRV_TRANSPARENCY_AND_COMPOSITION_MASK 4 +#define FSR3UPSCALER_BIND_SRV_ACCUMULATION 5 +#define FSR3UPSCALER_BIND_SRV_SHADING_CHANGE 6 +#define FSR3UPSCALER_BIND_SRV_CURRENT_LUMA 7 +#define FSR3UPSCALER_BIND_SRV_INPUT_EXPOSURE 8 + +#define FSR3UPSCALER_BIND_UAV_DILATED_REACTIVE_MASKS 9 +#define FSR3UPSCALER_BIND_UAV_NEW_LOCKS 10 +#define FSR3UPSCALER_BIND_UAV_ACCUMULATION 11 + +#define FSR3UPSCALER_BIND_CB_FSR3UPSCALER 12 + +#include "fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h" +#include "fsr3upscaler/ffx_fsr3upscaler_common.h" +#include "fsr3upscaler/ffx_fsr3upscaler_prepare_reactivity.h" + +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#define FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#ifndef FFX_FSR3UPSCALER_NUM_THREADS +#define FFX_FSR3UPSCALER_NUM_THREADS layout (local_size_x = FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH, local_size_y = FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT, local_size_z = FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH) in; +#endif // #ifndef FFX_FSR3UPSCALER_NUM_THREADS + +FFX_FSR3UPSCALER_NUM_THREADS +void main() +{ + PrepareReactivity(FfxInt32x2(gl_GlobalInvocationID.xy)); +} diff --git a/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_rcas_pass.glsl b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_rcas_pass.glsl new file mode 100644 index 00000000..112c2e5f --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_rcas_pass.glsl @@ -0,0 +1,59 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#version 450 + +#extension GL_GOOGLE_include_directive : require +#extension GL_EXT_samplerless_texture_functions : require +// Needed for rw_upscaled_output declaration +#extension GL_EXT_shader_image_load_formatted : require + +#define FSR3UPSCALER_BIND_SRV_INPUT_EXPOSURE 0 +#define FSR3UPSCALER_BIND_SRV_RCAS_INPUT 1 + +#define FSR3UPSCALER_BIND_UAV_UPSCALED_OUTPUT 2 + +#define FSR3UPSCALER_BIND_CB_FSR3UPSCALER 3 +#define FSR3UPSCALER_BIND_CB_RCAS 4 + +#include "fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h" +#include "fsr3upscaler/ffx_fsr3upscaler_common.h" +#include "fsr3upscaler/ffx_fsr3upscaler_rcas.h" + +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH 64 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#define FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#ifndef FFX_FSR3UPSCALER_NUM_THREADS +#define FFX_FSR3UPSCALER_NUM_THREADS layout (local_size_x = FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH, local_size_y = FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT, local_size_z = FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH) in; +#endif // #ifndef FFX_FSR3UPSCALER_NUM_THREADS + +FFX_FSR3UPSCALER_NUM_THREADS +void main() +{ + RCAS(gl_LocalInvocationID.xyz, gl_WorkGroupID.xyz, gl_GlobalInvocationID.xyz); +} diff --git a/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_shading_change_pass.glsl b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_shading_change_pass.glsl new file mode 100644 index 00000000..539728f0 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_shading_change_pass.glsl @@ -0,0 +1,55 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#version 450 + +#extension GL_GOOGLE_include_directive : require +#extension GL_EXT_samplerless_texture_functions : require + +#define FSR3UPSCALER_BIND_SRV_SPD_MIPS 0 + +#define FSR3UPSCALER_BIND_UAV_SHADING_CHANGE 1 + +#define FSR3UPSCALER_BIND_CB_FSR3UPSCALER 2 + +#include "fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h" +#include "fsr3upscaler/ffx_fsr3upscaler_common.h" +#include "fsr3upscaler/ffx_fsr3upscaler_shading_change.h" + +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#define FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#ifndef FFX_FSR3UPSCALER_NUM_THREADS +#define FFX_FSR3UPSCALER_NUM_THREADS layout (local_size_x = FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH, local_size_y = FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT, local_size_z = FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH) in; +#endif // #ifndef FFX_FSR3UPSCALER_NUM_THREADS + +FFX_FSR3UPSCALER_NUM_THREADS +void main() +{ + ShadingChange(FfxInt32x2(gl_GlobalInvocationID.xy)); +} diff --git a/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_shading_change_pyramid_pass.glsl b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_shading_change_pyramid_pass.glsl new file mode 100644 index 00000000..5e02d3da --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/src/backends/vk/shaders/fsr3upscaler/ffx_fsr3upscaler_shading_change_pyramid_pass.glsl @@ -0,0 +1,67 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#version 450 + +#extension GL_GOOGLE_include_directive : require +#extension GL_EXT_samplerless_texture_functions : require + +#define FSR3UPSCALER_BIND_SRV_CURRENT_LUMA 0 +#define FSR3UPSCALER_BIND_SRV_PREVIOUS_LUMA 1 +#define FSR3UPSCALER_BIND_SRV_DILATED_MOTION_VECTORS 2 +#define FSR3UPSCALER_BIND_SRV_INPUT_EXPOSURE 3 + + +#define FSR3UPSCALER_BIND_UAV_SPD_GLOBAL_ATOMIC 4 +#define FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_0 5 +#define FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_1 6 +#define FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_2 7 +#define FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_3 8 +#define FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_4 9 +#define FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_5 10 + + +#define FSR3UPSCALER_BIND_CB_FSR3UPSCALER 11 +#define FSR3UPSCALER_BIND_CB_SPD 12 + +#include "fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h" +#include "fsr3upscaler/ffx_fsr3upscaler_common.h" +#include "fsr3upscaler/ffx_fsr3upscaler_shading_change_pyramid.h" + +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH 256 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#define FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#define FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#ifndef FFX_FSR3UPSCALER_NUM_THREADS +#define FFX_FSR3UPSCALER_NUM_THREADS layout (local_size_x = FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH, local_size_y = FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT, local_size_z = FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH) in; +#endif // #ifndef FFX_FSR3UPSCALER_NUM_THREADS + +FFX_FSR3UPSCALER_NUM_THREADS +void main() +{ + ComputeShadingChangePyramid(gl_WorkGroupID, gl_LocalInvocationIndex); +} diff --git a/runtime/third_party/FidelityFX/sdk/src/components/fsr3upscaler/ffx_fsr3upscaler.cpp b/runtime/third_party/FidelityFX/sdk/src/components/fsr3upscaler/ffx_fsr3upscaler.cpp new file mode 100644 index 00000000..b5f1f747 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/src/components/fsr3upscaler/ffx_fsr3upscaler.cpp @@ -0,0 +1,1509 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#include // for max used inside SPD CPU code. +#include // for fabs, abs, sinf, sqrt, etc. +#include // for memset +#include // for FLT_EPSILON +#include + +#define FFX_CPU + +#ifdef __clang__ +#pragma clang diagnostic ignored "-Wunused-function" +#pragma clang diagnostic ignored "-Wsign-compare" +#endif + +#include +#include +#include +#include +#include +#include +#include + +// max queued frames for descriptor management +static const uint32_t FSR3UPSCALER_MAX_QUEUED_FRAMES = 16; + +#include "ffx_fsr3upscaler_private.h" + +// lists to map shader resource bindpoint name to resource identifier +typedef struct ResourceBinding +{ + uint32_t index; + wchar_t name[64]; +}ResourceBinding; + +static const ResourceBinding srvTextureBindingTable[] = +{ + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_COLOR, L"r_input_color_jittered"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_OPAQUE_ONLY, L"r_input_opaque_only"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_MOTION_VECTORS, L"r_input_motion_vectors"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_DEPTH, L"r_input_depth" }, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_EXPOSURE, L"r_input_exposure"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FRAME_INFO, L"r_frame_info"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK, L"r_reactive_mask"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK, L"r_transparency_and_composition_mask"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH, L"r_reconstructed_previous_nearest_depth"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS, L"r_dilated_motion_vectors"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_DEPTH, L"r_dilated_depth"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR, L"r_internal_upscaled_color"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION, L"r_accumulation"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY, L"r_luma_history" }, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RCAS_INPUT, L"r_rcas_input"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LANCZOS_LUT, L"r_lanczos_lut"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS, L"r_spd_mips"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_REACTIVE_MASKS, L"r_dilated_reactive_masks"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NEW_LOCKS, L"r_new_locks"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH, L"r_farthest_depth"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH_MIP1, L"r_farthest_depth_mip1"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SHADING_CHANGE, L"r_shading_change"}, + + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_CURRENT_LUMA, L"r_current_luma"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_PREVIOUS_LUMA, L"r_previous_luma"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_INSTABILITY, L"r_luma_instability"}, +}; + +static const ResourceBinding uavTextureBindingTable[] = +{ + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH, L"rw_reconstructed_previous_nearest_depth"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS, L"rw_dilated_motion_vectors"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_DEPTH, L"rw_dilated_depth"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR, L"rw_internal_upscaled_color"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION, L"rw_accumulation"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY, L"rw_luma_history"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_UPSCALED_OUTPUT, L"rw_upscaled_output"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_REACTIVE_MASKS, L"rw_dilated_reactive_masks"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FRAME_INFO, L"rw_frame_info"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_ATOMIC_COUNT, L"rw_spd_global_atomic"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NEW_LOCKS, L"rw_new_locks"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_AUTOREACTIVE, L"rw_output_autoreactive"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SHADING_CHANGE, L"rw_shading_change"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH, L"rw_farthest_depth"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH_MIP1, L"rw_farthest_depth_mip1"}, + + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_CURRENT_LUMA, L"rw_current_luma"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_INSTABILITY, L"rw_luma_instability"}, + + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_0, L"rw_spd_mip0"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_1, L"rw_spd_mip1"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_2, L"rw_spd_mip2"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_3, L"rw_spd_mip3"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_4, L"rw_spd_mip4"}, + {FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_5, L"rw_spd_mip5"}, + + +}; + +static const ResourceBinding constantBufferBindingTable[] = +{ + {FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_FSR3UPSCALER, L"cbFSR3Upscaler"}, + {FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_SPD, L"cbSPD"}, + {FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_RCAS, L"cbRCAS"}, + {FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_GENREACTIVE, L"cbGenerateReactive"}, +}; + +typedef struct Fsr3UpscalerRcasConstants { + + uint32_t rcasConfig[4]; +} FfxRcasConstants; + +typedef struct Fsr3UpscalerSpdConstants { + + uint32_t mips; + uint32_t numworkGroups; + uint32_t workGroupOffset[2]; + uint32_t renderSize[2]; +} Fsr3UpscalerSpdConstants; + +typedef struct Fsr3UpscalerGenerateReactiveConstants +{ + float scale; + float threshold; + float binaryValue; + uint32_t flags; + +} Fsr3UpscalerGenerateReactiveConstants; + +typedef struct Fsr3UpscalerGenerateReactiveConstants2 +{ + float autoTcThreshold; + float autoTcScale; + float autoReactiveScale; + float autoReactiveMax; + +} Fsr3UpscalerGenerateReactiveConstants2; + +typedef union Fsr3UpscalerSecondaryUnion { + + Fsr3UpscalerRcasConstants rcas; + Fsr3UpscalerSpdConstants spd; + Fsr3UpscalerGenerateReactiveConstants2 autogenReactive; +} Fsr3UpscalerSecondaryUnion; + +// Lanczos +static float lanczos2(float value) +{ + return abs(value) < FFX_EPSILON ? 1.f : (sinf(FFX_PI * value) / (FFX_PI * value)) * (sinf(0.5f * FFX_PI * value) / (0.5f * FFX_PI * value)); +} + +// Calculate halton number for index and base. +static float halton(int32_t index, int32_t base) +{ + float f = 1.0f, result = 0.0f; + + for (int32_t currentIndex = index; currentIndex > 0;) { + + f /= (float)base; + result = result + f * (float)(currentIndex % base); + currentIndex = (uint32_t)(floorf((float)(currentIndex) / (float)(base))); + } + + return result; +} + +static void fsr3upscalerDebugCheckDispatch(FfxFsr3UpscalerContext_Private* context, const FfxFsr3UpscalerDispatchDescription* params) +{ + if (params->commandList == nullptr) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_ERROR, L"commandList is null"); + } + + if (params->color.resource == nullptr) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_ERROR, L"color resource is null"); + } + + if (params->depth.resource == nullptr) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_ERROR, L"depth resource is null"); + } + + if (params->motionVectors.resource == nullptr) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_ERROR, L"motionVectors resource is null"); + } + + if (params->exposure.resource != nullptr) + { + if ((context->contextDescription.flags & FFX_FSR3UPSCALER_ENABLE_AUTO_EXPOSURE) == FFX_FSR3UPSCALER_ENABLE_AUTO_EXPOSURE) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, L"exposure resource provided, however auto exposure flag is present"); + } + } + + if (params->output.resource == nullptr) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_ERROR, L"output resource is null"); + } + + if (fabs(params->jitterOffset.x) > 1.0f || fabs(params->jitterOffset.y) > 1.0f) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, L"jitterOffset contains value outside of expected range [-1.0, 1.0]"); + } + + if ((params->motionVectorScale.x > (float)context->contextDescription.maxRenderSize.width) || + (params->motionVectorScale.y > (float)context->contextDescription.maxRenderSize.height)) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, L"motionVectorScale contains scale value greater than maxRenderSize"); + } + if ((params->motionVectorScale.x == 0.0f) || + (params->motionVectorScale.y == 0.0f)) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, L"motionVectorScale contains zero scale value"); + } + + if ((params->renderSize.width > context->contextDescription.maxRenderSize.width) || + (params->renderSize.height > context->contextDescription.maxRenderSize.height)) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, L"renderSize is greater than context maxRenderSize"); + } + if ((params->renderSize.width == 0) || + (params->renderSize.height == 0)) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, L"renderSize contains zero dimension"); + } + + if (params->sharpness < 0.0f || params->sharpness > 1.0f) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, L"sharpness contains value outside of expected range [0.0, 1.0]"); + } + + if (params->frameTimeDelta < 1.0f) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, L"frameTimeDelta is less than 1.0f - this value should be milliseconds (~16.6f for 60fps)"); + } + + if (params->preExposure == 0.0f) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_ERROR, L"preExposure provided as 0.0f which is invalid"); + } + + bool infiniteDepth = (context->contextDescription.flags & FFX_FSR3UPSCALER_ENABLE_DEPTH_INFINITE) == FFX_FSR3UPSCALER_ENABLE_DEPTH_INFINITE; + bool inverseDepth = (context->contextDescription.flags & FFX_FSR3UPSCALER_ENABLE_DEPTH_INVERTED) == FFX_FSR3UPSCALER_ENABLE_DEPTH_INVERTED; + + if (inverseDepth) + { + if (params->cameraNear < params->cameraFar) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, + L"FFX_FSR3UPSCALER_ENABLE_DEPTH_INVERTED flag is present yet cameraNear is less than cameraFar"); + } + if (infiniteDepth) + { + if (params->cameraNear != FLT_MAX) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, + L"FFX_FSR3UPSCALER_ENABLE_DEPTH_INFINITE and FFX_FSR3UPSCALER_ENABLE_DEPTH_INVERTED present, yet cameraNear != FLT_MAX"); + } + } + if (params->cameraFar < 0.075f) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, + L"FFX_FSR3UPSCALER_ENABLE_DEPTH_INVERTED present, cameraFar value is very low which may result in depth separation artefacting"); + } + } + else + { + if (params->cameraNear > params->cameraFar) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, + L"cameraNear is greater than cameraFar in non-inverted-depth context"); + } + if (infiniteDepth) + { + if (params->cameraFar != FLT_MAX) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, + L"FFX_FSR3UPSCALER_ENABLE_DEPTH_INFINITE present, yet cameraFar != FLT_MAX"); + } + } + if (params->cameraNear < 0.075f) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_WARNING, + L"cameraNear value is very low which may result in depth separation artefacting"); + } + } + + if (params->cameraFovAngleVertical <= 0.0f) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_ERROR, L"cameraFovAngleVertical is 0.0f - this value should be > 0.0f"); + } + if (params->cameraFovAngleVertical > FFX_PI) + { + FFX_PRINT_MESSAGE(FFX_MESSAGE_TYPE_ERROR, L"cameraFovAngleVertical is greater than 180 degrees/PI"); + } +} + +static FfxErrorCode patchResourceBindings(FfxPipelineState* inoutPipeline) +{ + for (uint32_t srvIndex = 0; srvIndex < inoutPipeline->srvTextureCount; ++srvIndex) + { + int32_t mapIndex = 0; + for (mapIndex = 0; mapIndex < _countof(srvTextureBindingTable); ++mapIndex) + { + if (0 == wcscmp(srvTextureBindingTable[mapIndex].name, inoutPipeline->srvTextureBindings[srvIndex].name)) + break; + } + if (mapIndex == _countof(srvTextureBindingTable)) + return FFX_ERROR_INVALID_ARGUMENT; + + inoutPipeline->srvTextureBindings[srvIndex].resourceIdentifier = srvTextureBindingTable[mapIndex].index; + } + + for (uint32_t uavIndex = 0; uavIndex < inoutPipeline->uavTextureCount; ++uavIndex) + { + int32_t mapIndex = 0; + for (mapIndex = 0; mapIndex < _countof(uavTextureBindingTable); ++mapIndex) + { + if (0 == wcscmp(uavTextureBindingTable[mapIndex].name, inoutPipeline->uavTextureBindings[uavIndex].name)) + break; + } + if (mapIndex == _countof(uavTextureBindingTable)) + return FFX_ERROR_INVALID_ARGUMENT; + + inoutPipeline->uavTextureBindings[uavIndex].resourceIdentifier = uavTextureBindingTable[mapIndex].index; + } + + for (uint32_t cbIndex = 0; cbIndex < inoutPipeline->constCount; ++cbIndex) + { + int32_t mapIndex = 0; + for (mapIndex = 0; mapIndex < _countof(constantBufferBindingTable); ++mapIndex) + { + if (0 == wcscmp(constantBufferBindingTable[mapIndex].name, inoutPipeline->constantBufferBindings[cbIndex].name)) + break; + } + if (mapIndex == _countof(constantBufferBindingTable)) + return FFX_ERROR_INVALID_ARGUMENT; + + inoutPipeline->constantBufferBindings[cbIndex].resourceIdentifier = constantBufferBindingTable[mapIndex].index; + } + + return FFX_OK; +} + +static uint32_t getPipelinePermutationFlags(uint32_t contextFlags, FfxFsr3UpscalerPass passId, bool fp16, bool force64, bool useLut) +{ + // work out what permutation to load. + uint32_t flags = 0; + flags |= (contextFlags & FFX_FSR3UPSCALER_ENABLE_HIGH_DYNAMIC_RANGE) ? FSR3UPSCALER_SHADER_PERMUTATION_HDR_COLOR_INPUT : 0; + flags |= (contextFlags & FFX_FSR3UPSCALER_ENABLE_DISPLAY_RESOLUTION_MOTION_VECTORS) ? 0 : FSR3UPSCALER_SHADER_PERMUTATION_LOW_RES_MOTION_VECTORS; + flags |= (contextFlags & FFX_FSR3UPSCALER_ENABLE_MOTION_VECTORS_JITTER_CANCELLATION) ? FSR3UPSCALER_SHADER_PERMUTATION_JITTER_MOTION_VECTORS : 0; + flags |= (contextFlags & FFX_FSR3UPSCALER_ENABLE_DEPTH_INVERTED) ? FSR3UPSCALER_SHADER_PERMUTATION_DEPTH_INVERTED : 0; + flags |= (passId == FFX_FSR3UPSCALER_PASS_ACCUMULATE_SHARPEN) ? FSR3UPSCALER_SHADER_PERMUTATION_ENABLE_SHARPENING : 0; + flags |= (useLut) ? FSR3UPSCALER_SHADER_PERMUTATION_USE_LANCZOS_TYPE : 0; + flags |= (force64) ? FSR3UPSCALER_SHADER_PERMUTATION_FORCE_WAVE64 : 0; +#if defined(_GAMING_XBOX) + /** On Xbox we enable 16-bit math, and use 32-bit within the shader only where it's necessary. */ + flags |= (fp16) ? FSR3UPSCALER_SHADER_PERMUTATION_ALLOW_FP16 : 0; +#else + flags |= (fp16 && (passId != FFX_FSR3UPSCALER_PASS_RCAS)) ? FSR3UPSCALER_SHADER_PERMUTATION_ALLOW_FP16 : 0; +#endif // defined(_GAMING_XBOX) + return flags; +} + +static FfxErrorCode createPipelineStates(FfxFsr3UpscalerContext_Private* context) +{ + FFX_ASSERT(context); + + FfxPipelineDescription pipelineDescription = {}; + pipelineDescription.contextFlags = context->contextDescription.flags; + pipelineDescription.stage = FFX_BIND_COMPUTE_SHADER_STAGE; + + // Samplers + pipelineDescription.samplerCount = 2; + FfxSamplerDescription samplerDescs[2] = { { FFX_FILTER_TYPE_MINMAGMIP_POINT, FFX_ADDRESS_MODE_CLAMP, FFX_ADDRESS_MODE_CLAMP, FFX_ADDRESS_MODE_CLAMP, FFX_BIND_COMPUTE_SHADER_STAGE }, + { FFX_FILTER_TYPE_MINMAGMIP_LINEAR, FFX_ADDRESS_MODE_CLAMP, FFX_ADDRESS_MODE_CLAMP, FFX_ADDRESS_MODE_CLAMP, FFX_BIND_COMPUTE_SHADER_STAGE} }; + pipelineDescription.samplers = samplerDescs; + + // Root constants + pipelineDescription.rootConstantBufferCount = 2; + FfxRootConstantDescription rootConstantDescs[2] = { {sizeof(Fsr3UpscalerConstants) / sizeof(uint32_t), FFX_BIND_COMPUTE_SHADER_STAGE }, + { sizeof(Fsr3UpscalerSecondaryUnion) / sizeof(uint32_t), FFX_BIND_COMPUTE_SHADER_STAGE } }; + pipelineDescription.rootConstants = rootConstantDescs; + + // Query device capabilities + FfxDeviceCapabilities capabilities; + context->contextDescription.backendInterface.fpGetDeviceCapabilities(&context->contextDescription.backendInterface, &capabilities); + + // Setup a few options used to determine permutation flags + bool haveShaderModel66 = capabilities.maximumSupportedShaderModel >= FFX_SHADER_MODEL_6_6; + bool supportedFP16 = capabilities.fp16Supported; + bool canForceWave64 = false; + bool useLut = false; + + const uint32_t waveLaneCountMin = capabilities.waveLaneCountMin; + const uint32_t waveLaneCountMax = capabilities.waveLaneCountMax; + if (waveLaneCountMin == 32 && waveLaneCountMax == 64) + { + useLut = true; + canForceWave64 = haveShaderModel66; + } + else + { + canForceWave64 = false; + } + + // Work out what permutation to load. + uint32_t contextFlags = context->contextDescription.flags; + + // Set up pipeline descriptor (basically RootSignature and binding) + wcscpy_s(pipelineDescription.name, L"FSR3-LUMA-PYRAMID"); + FFX_VALIDATE(context->contextDescription.backendInterface.fpCreatePipeline(&context->contextDescription.backendInterface, FFX_EFFECT_FSR3UPSCALER, FFX_FSR3UPSCALER_PASS_LUMA_PYRAMID, + getPipelinePermutationFlags(contextFlags, FFX_FSR3UPSCALER_PASS_LUMA_PYRAMID, supportedFP16, canForceWave64, useLut), + &pipelineDescription, context->effectContextId, &context->pipelineLumaPyramid)); + wcscpy_s(pipelineDescription.name, L"FSR3-RCAS"); + FFX_VALIDATE(context->contextDescription.backendInterface.fpCreatePipeline(&context->contextDescription.backendInterface, FFX_EFFECT_FSR3UPSCALER, FFX_FSR3UPSCALER_PASS_RCAS, + getPipelinePermutationFlags(contextFlags, FFX_FSR3UPSCALER_PASS_RCAS, supportedFP16, canForceWave64, useLut), + &pipelineDescription, context->effectContextId, &context->pipelineRCAS)); + wcscpy_s(pipelineDescription.name, L"FSR3-GEN_REACTIVE"); + FFX_VALIDATE(context->contextDescription.backendInterface.fpCreatePipeline(&context->contextDescription.backendInterface, FFX_EFFECT_FSR3UPSCALER, FFX_FSR3UPSCALER_PASS_GENERATE_REACTIVE, + getPipelinePermutationFlags(contextFlags, FFX_FSR3UPSCALER_PASS_GENERATE_REACTIVE, supportedFP16, canForceWave64, useLut), + &pipelineDescription, context->effectContextId, &context->pipelineGenerateReactive)); + + pipelineDescription.rootConstantBufferCount = 1; + + wcscpy_s(pipelineDescription.name, L"FSR3-PREPARE-INPUTS"); + FFX_VALIDATE(context->contextDescription.backendInterface.fpCreatePipeline(&context->contextDescription.backendInterface, FFX_EFFECT_FSR3UPSCALER, FFX_FSR3UPSCALER_PASS_PREPARE_INPUTS, + getPipelinePermutationFlags(contextFlags, FFX_FSR3UPSCALER_PASS_PREPARE_INPUTS, supportedFP16, canForceWave64, useLut), + &pipelineDescription, context->effectContextId, &context->pipelinePrepareInputs)); + + wcscpy_s(pipelineDescription.name, L"FSR3-PREPARE-REACTIVITY"); + FFX_VALIDATE(context->contextDescription.backendInterface.fpCreatePipeline(&context->contextDescription.backendInterface, FFX_EFFECT_FSR3UPSCALER, FFX_FSR3UPSCALER_PASS_PREPARE_REACTIVITY, + getPipelinePermutationFlags(contextFlags, FFX_FSR3UPSCALER_PASS_PREPARE_REACTIVITY, supportedFP16, canForceWave64, useLut), + &pipelineDescription, context->effectContextId, &context->pipelinePrepareReactivity)); + + wcscpy_s(pipelineDescription.name, L"FSR3-SHADING-CHANGE"); + FFX_VALIDATE(context->contextDescription.backendInterface.fpCreatePipeline(&context->contextDescription.backendInterface, FFX_EFFECT_FSR3UPSCALER, FFX_FSR3UPSCALER_PASS_SHADING_CHANGE, + getPipelinePermutationFlags(contextFlags, FFX_FSR3UPSCALER_PASS_SHADING_CHANGE, supportedFP16, canForceWave64, useLut), + &pipelineDescription, context->effectContextId, &context->pipelineShadingChange)); + + wcscpy_s(pipelineDescription.name, L"FSR3-ACCUMULATE"); + FFX_VALIDATE(context->contextDescription.backendInterface.fpCreatePipeline(&context->contextDescription.backendInterface, FFX_EFFECT_FSR3UPSCALER, FFX_FSR3UPSCALER_PASS_ACCUMULATE, + getPipelinePermutationFlags(contextFlags, FFX_FSR3UPSCALER_PASS_ACCUMULATE, supportedFP16, canForceWave64, useLut), + &pipelineDescription, context->effectContextId, &context->pipelineAccumulate)); + + wcscpy_s(pipelineDescription.name, L"FSR3-ACCUM_SHARP"); + FFX_VALIDATE(context->contextDescription.backendInterface.fpCreatePipeline(&context->contextDescription.backendInterface, FFX_EFFECT_FSR3UPSCALER, FFX_FSR3UPSCALER_PASS_ACCUMULATE_SHARPEN, + getPipelinePermutationFlags(contextFlags, FFX_FSR3UPSCALER_PASS_ACCUMULATE_SHARPEN, supportedFP16, canForceWave64, useLut), + &pipelineDescription, context->effectContextId, &context->pipelineAccumulateSharpen)); + + wcscpy_s(pipelineDescription.name, L"FSR3-SHADING-CHANGE-PYRAMID"); + FFX_VALIDATE(context->contextDescription.backendInterface.fpCreatePipeline(&context->contextDescription.backendInterface, FFX_EFFECT_FSR3UPSCALER, FFX_FSR3UPSCALER_PASS_SHADING_CHANGE_PYRAMID, + getPipelinePermutationFlags(contextFlags, FFX_FSR3UPSCALER_PASS_SHADING_CHANGE_PYRAMID, supportedFP16, canForceWave64, useLut), + &pipelineDescription, context->effectContextId, &context->pipelineShadingChangePyramid)); + + wcscpy_s(pipelineDescription.name, L"FSR3-LUMA-INSTABILITY"); + FFX_VALIDATE(context->contextDescription.backendInterface.fpCreatePipeline(&context->contextDescription.backendInterface, FFX_EFFECT_FSR3UPSCALER, FFX_FSR3UPSCALER_PASS_LUMA_INSTABILITY, + getPipelinePermutationFlags(contextFlags, FFX_FSR3UPSCALER_PASS_LUMA_INSTABILITY, supportedFP16, canForceWave64, useLut), + &pipelineDescription, context->effectContextId, &context->pipelineLumaInstability)); + + wcscpy_s(pipelineDescription.name, L"FSR3-DEBUG-VIEW"); + FFX_VALIDATE(context->contextDescription.backendInterface.fpCreatePipeline(&context->contextDescription.backendInterface, FFX_EFFECT_FSR3UPSCALER, FFX_FSR3UPSCALER_PASS_DEBUG_VIEW, + getPipelinePermutationFlags(contextFlags, FFX_FSR3UPSCALER_PASS_DEBUG_VIEW, supportedFP16, canForceWave64, useLut), + &pipelineDescription, context->effectContextId, &context->pipelineDebugView)); + + // for each pipeline: re-route/fix-up IDs based on names + FFX_VALIDATE(patchResourceBindings(&context->pipelinePrepareInputs)); + FFX_VALIDATE(patchResourceBindings(&context->pipelinePrepareReactivity)); + FFX_VALIDATE(patchResourceBindings(&context->pipelineShadingChange)); + FFX_VALIDATE(patchResourceBindings(&context->pipelineAccumulate)); + FFX_VALIDATE(patchResourceBindings(&context->pipelineLumaPyramid)); + FFX_VALIDATE(patchResourceBindings(&context->pipelineAccumulateSharpen)); + FFX_VALIDATE(patchResourceBindings(&context->pipelineRCAS)); + FFX_VALIDATE(patchResourceBindings(&context->pipelineGenerateReactive)); + FFX_VALIDATE(patchResourceBindings(&context->pipelineTcrAutogenerate)); + FFX_VALIDATE(patchResourceBindings(&context->pipelineShadingChangePyramid)); + FFX_VALIDATE(patchResourceBindings(&context->pipelineLumaInstability)); + FFX_VALIDATE(patchResourceBindings(&context->pipelineDebugView)); + + return FFX_OK; +} + +static FfxErrorCode generateReactiveMaskInternal(FfxFsr3UpscalerContext_Private* contextPrivate, const FfxFsr3UpscalerDispatchDescription* params); + +static FfxErrorCode fsr3upscalerCreate(FfxFsr3UpscalerContext_Private* context, const FfxFsr3UpscalerContextDescription* contextDescription) +{ + FFX_ASSERT(context); + FFX_ASSERT(contextDescription); + + // Setup the data for implementation. + memset(context, 0, sizeof(FfxFsr3UpscalerContext_Private)); + context->device = contextDescription->backendInterface.device; + + memcpy(&context->contextDescription, contextDescription, sizeof(FfxFsr3UpscalerContextDescription)); + + // Check version info - make sure we are linked with the right backend version + FfxVersionNumber version = context->contextDescription.backendInterface.fpGetSDKVersion(&context->contextDescription.backendInterface); + FFX_RETURN_ON_ERROR(version == FFX_SDK_MAKE_VERSION(1, 1, 4), FFX_ERROR_INVALID_VERSION); + + // Create the context. + FfxErrorCode errorCode = context->contextDescription.backendInterface.fpCreateBackendContext(&context->contextDescription.backendInterface, FFX_EFFECT_FSR3UPSCALER, nullptr, &context->effectContextId); + FFX_RETURN_ON_ERROR(errorCode == FFX_OK, errorCode); + + // call out for device caps. + errorCode = context->contextDescription.backendInterface.fpGetDeviceCapabilities(&context->contextDescription.backendInterface, &context->deviceCapabilities); + FFX_RETURN_ON_ERROR(errorCode == FFX_OK, errorCode); + + // set defaults + context->firstExecution = true; + context->resourceFrameIndex = 0; + + context->constants.maxUpscaleSize[0] = contextDescription->maxUpscaleSize.width; + context->constants.maxUpscaleSize[1] = contextDescription->maxUpscaleSize.height; + context->constants.velocityFactor = 1.0f; + context->constants.reactivenessScale = 1.0f; + context->constants.shadingChangeScale = 1.0f; + context->constants.accumulationAddedPerFrame = 1.0f/3.0f; + context->constants.minDisocclusionAccumulation = -1.0f/3.0f; + + // generate the data for the LUT. + const uint32_t lanczos2LutWidth = 128; + int16_t lanczos2Weights[lanczos2LutWidth] = { }; + + for (uint32_t currentLanczosWidthIndex = 0; currentLanczosWidthIndex < lanczos2LutWidth; currentLanczosWidthIndex++) { + + const float x = 2.0f * currentLanczosWidthIndex / float(lanczos2LutWidth - 1); + const float y = lanczos2(x); + lanczos2Weights[currentLanczosWidthIndex] = int16_t(roundf(y * 32767.0f)); + } + + uint8_t defaultReactiveMaskData = 0U; + uint32_t atomicInitData = 0U; + float defaultExposure[] = { 0.0f, 0.0f }; + + const FfxDimensions2D maxRenderSizeDiv2 = { contextDescription->maxRenderSize.width / 2, contextDescription->maxRenderSize.height / 2 }; + + // declare internal resources needed + const FfxInternalResourceDescription internalSurfaceDesc[] = { + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION_1, L"FSR3UPSCALER_Accumulation1", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV), + FFX_SURFACE_FORMAT_R8_UNORM, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION_2, L"FSR3UPSCALER_Accumulation2", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV), + FFX_SURFACE_FORMAT_R8_UNORM, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_1, L"FSR3UPSCALER_Luma1", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV), + FFX_SURFACE_FORMAT_R16_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_2, L"FSR3UPSCALER_Luma2", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV), + FFX_SURFACE_FORMAT_R16_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERMEDIATE_FP16x1, L"FSR3UPSCALER_IntermediateFp16x1", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_UAV | FFX_RESOURCE_USAGE_DCC_RENDERTARGET), + FFX_SURFACE_FORMAT_R16_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_ALIASABLE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SHADING_CHANGE, L"FSR3UPSCALER_ShadingChange", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_UAV | FFX_RESOURCE_USAGE_DCC_RENDERTARGET), + FFX_SURFACE_FORMAT_R8_UNORM, maxRenderSizeDiv2.width, maxRenderSizeDiv2.height, 1, FFX_RESOURCE_FLAGS_ALIASABLE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NEW_LOCKS, L"FSR3UPSCALER_NewLocks", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_UAV), + FFX_SURFACE_FORMAT_R8_UNORM, contextDescription->maxUpscaleSize.width, contextDescription->maxUpscaleSize.height, 1, FFX_RESOURCE_FLAGS_ALIASABLE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_1, L"FSR3UPSCALER_InternalUpscaled1", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV | FFX_RESOURCE_USAGE_DCC_RENDERTARGET), + FFX_SURFACE_FORMAT_R16G16B16A16_FLOAT, contextDescription->maxUpscaleSize.width, contextDescription->maxUpscaleSize.height, 1, FFX_RESOURCE_FLAGS_NONE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_2, L"FSR3UPSCALER_InternalUpscaled2", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV | FFX_RESOURCE_USAGE_DCC_RENDERTARGET), + FFX_SURFACE_FORMAT_R16G16B16A16_FLOAT, contextDescription->maxUpscaleSize.width, contextDescription->maxUpscaleSize.height, 1, FFX_RESOURCE_FLAGS_NONE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS, L"FSR3UPSCALER_SpdMips", FFX_RESOURCE_TYPE_TEXTURE2D, FFX_RESOURCE_USAGE_UAV, + FFX_SURFACE_FORMAT_R16G16_FLOAT, maxRenderSizeDiv2.width, maxRenderSizeDiv2.height, 0, FFX_RESOURCE_FLAGS_ALIASABLE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH_MIP1, L"FSR3UPSCALER_FarthestDepthMip1", FFX_RESOURCE_TYPE_TEXTURE2D, FFX_RESOURCE_USAGE_UAV, + FFX_SURFACE_FORMAT_R16_FLOAT, maxRenderSizeDiv2.width, maxRenderSizeDiv2.height, 1, FFX_RESOURCE_FLAGS_ALIASABLE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY_1, L"FSR3UPSCALER_LumaHistory1", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV), + FFX_SURFACE_FORMAT_R16G16B16A16_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY_2, L"FSR3UPSCALER_LumaHistory2", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV), + FFX_SURFACE_FORMAT_R16G16B16A16_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_ATOMIC_COUNT, L"FSR3UPSCALER_SpdAtomicCounter", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_UAV), + FFX_SURFACE_FORMAT_R32_UINT, 1, 1, 1, FFX_RESOURCE_FLAGS_NONE, FfxResourceInitData::FfxResourceInitValue(sizeof(atomicInitData), 0) }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_REACTIVE_MASKS, L"FSR3UPSCALER_DilatedReactiveMasks", FFX_RESOURCE_TYPE_TEXTURE2D, (FfxResourceUsage)(FFX_RESOURCE_USAGE_UAV | FFX_RESOURCE_USAGE_DCC_RENDERTARGET), + FFX_SURFACE_FORMAT_R8G8B8A8_UNORM, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_ALIASABLE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LANCZOS_LUT, L"FSR3UPSCALER_LanczosLutData", FFX_RESOURCE_TYPE_TEXTURE2D, FFX_RESOURCE_USAGE_READ_ONLY, + FFX_SURFACE_FORMAT_R16_SNORM, lanczos2LutWidth, 1, 1, FFX_RESOURCE_FLAGS_NONE, {FFX_RESOURCE_INIT_DATA_TYPE_BUFFER, sizeof(lanczos2Weights), lanczos2Weights} }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_REACTIVITY, L"FSR3UPSCALER_DefaultReactivityMask", FFX_RESOURCE_TYPE_TEXTURE2D, FFX_RESOURCE_USAGE_READ_ONLY, + FFX_SURFACE_FORMAT_R8_UNORM, 1, 1, 1, FFX_RESOURCE_FLAGS_NONE, FfxResourceInitData::FfxResourceInitValue(sizeof(defaultReactiveMaskData), defaultReactiveMaskData) }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_EXPOSURE, L"FSR3UPSCALER_DefaultExposure", FFX_RESOURCE_TYPE_TEXTURE2D, FFX_RESOURCE_USAGE_READ_ONLY, + FFX_SURFACE_FORMAT_R32G32_FLOAT, 1, 1, 1, FFX_RESOURCE_FLAGS_NONE, FfxResourceInitData::FfxResourceInitBuffer(sizeof(defaultExposure), defaultExposure) }, + + { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FRAME_INFO, L"FSR3UPSCALER_FrameInfo", FFX_RESOURCE_TYPE_TEXTURE2D, FFX_RESOURCE_USAGE_UAV, + FFX_SURFACE_FORMAT_R32G32B32A32_FLOAT, 1, 1, 1, FFX_RESOURCE_FLAGS_NONE, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }, + + }; + + // clear the SRV resources to NULL. + memset(context->srvResources, 0, sizeof(context->srvResources)); + + for (int32_t currentSurfaceIndex = 0; currentSurfaceIndex < FFX_ARRAY_ELEMENTS(internalSurfaceDesc); ++currentSurfaceIndex) { + + const FfxInternalResourceDescription* currentSurfaceDescription = &internalSurfaceDesc[currentSurfaceIndex]; + const FfxResourceType resourceType = internalSurfaceDesc[currentSurfaceIndex].type; + const FfxResourceDescription resourceDescription = {resourceType, + currentSurfaceDescription->format, + currentSurfaceDescription->width, + currentSurfaceDescription->height, + 1, + currentSurfaceDescription->mipCount, + currentSurfaceDescription->flags, + currentSurfaceDescription->usage}; + const FfxResourceStates initialState = (currentSurfaceDescription->usage == FFX_RESOURCE_USAGE_READ_ONLY) ? FFX_RESOURCE_STATE_COMPUTE_READ : FFX_RESOURCE_STATE_UNORDERED_ACCESS; + const FfxCreateResourceDescription createResourceDescription = { FFX_HEAP_TYPE_DEFAULT, resourceDescription, initialState, currentSurfaceDescription->name, currentSurfaceDescription->id, currentSurfaceDescription->initData }; + + FFX_VALIDATE(context->contextDescription.backendInterface.fpCreateResource(&context->contextDescription.backendInterface, &createResourceDescription, context->effectContextId, &context->srvResources[currentSurfaceDescription->id])); + } + + // copy resources to uavResrouces list + memcpy(context->uavResources, context->srvResources, sizeof(context->srvResources)); + + // avoid compiling pipelines on first render + { + errorCode = createPipelineStates(context); + FFX_RETURN_ON_ERROR(errorCode == FFX_OK, errorCode); + } + + return FFX_OK; +} + +static FfxErrorCode fsr3upscalerRelease(FfxFsr3UpscalerContext_Private* context) +{ + FFX_ASSERT(context); + + ffxSafeReleasePipeline(&context->contextDescription.backendInterface, &context->pipelinePrepareInputs, context->effectContextId); + ffxSafeReleasePipeline(&context->contextDescription.backendInterface, &context->pipelinePrepareReactivity, context->effectContextId); + ffxSafeReleasePipeline(&context->contextDescription.backendInterface, &context->pipelineShadingChange, context->effectContextId); + ffxSafeReleasePipeline(&context->contextDescription.backendInterface, &context->pipelineAccumulate, context->effectContextId); + ffxSafeReleasePipeline(&context->contextDescription.backendInterface, &context->pipelineAccumulateSharpen, context->effectContextId); + ffxSafeReleasePipeline(&context->contextDescription.backendInterface, &context->pipelineRCAS, context->effectContextId); + ffxSafeReleasePipeline(&context->contextDescription.backendInterface, &context->pipelineLumaPyramid, context->effectContextId); + ffxSafeReleasePipeline(&context->contextDescription.backendInterface, &context->pipelineGenerateReactive, context->effectContextId); + ffxSafeReleasePipeline(&context->contextDescription.backendInterface, &context->pipelineTcrAutogenerate, context->effectContextId); + ffxSafeReleasePipeline(&context->contextDescription.backendInterface, &context->pipelineShadingChangePyramid, context->effectContextId); + ffxSafeReleasePipeline(&context->contextDescription.backendInterface, &context->pipelineLumaInstability, context->effectContextId); + ffxSafeReleasePipeline(&context->contextDescription.backendInterface, &context->pipelineDebugView, context->effectContextId); + + // Unregister external resources + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_DEPTH] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_OPAQUE_ONLY] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_COLOR] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_DEPTH] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_MOTION_VECTORS] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_EXPOSURE] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + + // Unregister references + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RCAS_INPUT] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_UPSCALED_OUTPUT] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_CURRENT_LUMA] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_PREVIOUS_LUMA] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_INSTABILITY] = { FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL }; + + // Release the copy resources for those that had init data + ffxSafeReleaseCopyResource(&context->contextDescription.backendInterface, context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_ATOMIC_COUNT], context->effectContextId); + ffxSafeReleaseCopyResource(&context->contextDescription.backendInterface, context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LANCZOS_LUT], context->effectContextId); + ffxSafeReleaseCopyResource(&context->contextDescription.backendInterface, context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_REACTIVITY], context->effectContextId); + ffxSafeReleaseCopyResource(&context->contextDescription.backendInterface, context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_EXPOSURE], context->effectContextId); + + // release internal resources + for (int32_t currentResourceIndex = 0; currentResourceIndex < FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_COUNT; ++currentResourceIndex) { + + ffxSafeReleaseResource(&context->contextDescription.backendInterface, context->srvResources[currentResourceIndex], context->effectContextId); + } + + // Destroy the context + context->contextDescription.backendInterface.fpDestroyBackendContext(&context->contextDescription.backendInterface, context->effectContextId); + + return FFX_OK; +} + +static void setupDeviceDepthToViewSpaceDepthParams(FfxFsr3UpscalerContext_Private* context, const FfxFsr3UpscalerDispatchDescription* params) +{ + const bool bInverted = (context->contextDescription.flags & FFX_FSR3UPSCALER_ENABLE_DEPTH_INVERTED) == FFX_FSR3UPSCALER_ENABLE_DEPTH_INVERTED; + const bool bInfinite = (context->contextDescription.flags & FFX_FSR3UPSCALER_ENABLE_DEPTH_INFINITE) == FFX_FSR3UPSCALER_ENABLE_DEPTH_INFINITE; + + // make sure it has no impact if near and far plane values are swapped in dispatch params + // the flags "inverted" and "infinite" will decide what transform to use + float fMin = FFX_MINIMUM(params->cameraNear, params->cameraFar); + float fMax = FFX_MAXIMUM(params->cameraNear, params->cameraFar); + + if (bInverted) { + float tmp = fMin; + fMin = fMax; + fMax = tmp; + } + + // a 0 0 0 x + // 0 b 0 0 y + // 0 0 c d z + // 0 0 e 0 1 + + const float fQ = fMax / (fMin - fMax); + const float d = -1.0f; // for clarity + + const float matrix_elem_c[2][2] = { + fQ, // non reversed, non infinite + -1.0f - FLT_EPSILON, // non reversed, infinite + fQ, // reversed, non infinite + 0.0f + FLT_EPSILON // reversed, infinite + }; + + const float matrix_elem_e[2][2] = { + fQ * fMin, // non reversed, non infinite + -fMin - FLT_EPSILON, // non reversed, infinite + fQ * fMin, // reversed, non infinite + fMax, // reversed, infinite + }; + + context->constants.deviceToViewDepth[0] = d * matrix_elem_c[bInverted][bInfinite]; + context->constants.deviceToViewDepth[1] = matrix_elem_e[bInverted][bInfinite]; + + // revert x and y coords + const float aspect = params->renderSize.width / float(params->renderSize.height); + const float cotHalfFovY = cosf(0.5f * params->cameraFovAngleVertical) / sinf(0.5f * params->cameraFovAngleVertical); + const float a = cotHalfFovY / aspect; + const float b = cotHalfFovY; + + context->constants.deviceToViewDepth[2] = (1.0f / a); + context->constants.deviceToViewDepth[3] = (1.0f / b); +} + +static void scheduleDispatch(FfxFsr3UpscalerContext_Private* context, const FfxFsr3UpscalerDispatchDescription*, const FfxPipelineState* pipeline, uint32_t dispatchX, uint32_t dispatchY) +{ + FfxComputeJobDescription jobDescriptor = {}; + + for (uint32_t currentShaderResourceViewIndex = 0; currentShaderResourceViewIndex < pipeline->srvTextureCount; ++currentShaderResourceViewIndex) { + + const uint32_t currentResourceId = pipeline->srvTextureBindings[currentShaderResourceViewIndex].resourceIdentifier; + const FfxResourceInternal currentResource = context->srvResources[currentResourceId]; + jobDescriptor.srvTextures[currentShaderResourceViewIndex].resource = currentResource; +#ifdef FFX_DEBUG + wcscpy_s(jobDescriptor.srvTextures[currentShaderResourceViewIndex].name, pipeline->srvTextureBindings[currentShaderResourceViewIndex].name); +#endif + } + + for (uint32_t currentUnorderedAccessViewIndex = 0; currentUnorderedAccessViewIndex < pipeline->uavTextureCount; ++currentUnorderedAccessViewIndex) { + + const uint32_t currentResourceId = pipeline->uavTextureBindings[currentUnorderedAccessViewIndex].resourceIdentifier; +#ifdef FFX_DEBUG + wcscpy_s(jobDescriptor.uavTextures[currentUnorderedAccessViewIndex].name, pipeline->uavTextureBindings[currentUnorderedAccessViewIndex].name); +#endif + + if (currentResourceId >= FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_0 && currentResourceId <= FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_5) + { + const FfxResourceInternal currentResource = context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS]; + jobDescriptor.uavTextures[currentUnorderedAccessViewIndex].resource = currentResource; + jobDescriptor.uavTextures[currentUnorderedAccessViewIndex].mip = currentResourceId - FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_0; + } + else + { + const FfxResourceInternal currentResource = context->uavResources[currentResourceId]; + jobDescriptor.uavTextures[currentUnorderedAccessViewIndex].resource = currentResource; + jobDescriptor.uavTextures[currentUnorderedAccessViewIndex].mip = 0; + } + } + + jobDescriptor.dimensions[0] = dispatchX; + jobDescriptor.dimensions[1] = dispatchY; + jobDescriptor.dimensions[2] = 1; + jobDescriptor.pipeline = *pipeline; + + for (uint32_t currentRootConstantIndex = 0; currentRootConstantIndex < pipeline->constCount; ++currentRootConstantIndex) { +#ifdef FFX_DEBUG + wcscpy_s( jobDescriptor.cbNames[currentRootConstantIndex], pipeline->constantBufferBindings[currentRootConstantIndex].name); +#endif + jobDescriptor.cbs[currentRootConstantIndex] = context->constantBuffers[pipeline->constantBufferBindings[currentRootConstantIndex].resourceIdentifier]; + } + + FfxGpuJobDescription dispatchJob = { FFX_GPU_JOB_COMPUTE }; + wcscpy_s(dispatchJob.jobLabel, pipeline->name); + dispatchJob.computeJobDescriptor = jobDescriptor; + + context->contextDescription.backendInterface.fpScheduleGpuJob(&context->contextDescription.backendInterface, &dispatchJob); +} + +FFX_API FfxErrorCode ffxFsr3UpscalerGetSharedResourceDescriptions(FfxFsr3UpscalerContext* context, FfxFsr3UpscalerSharedResourceDescriptions* SharedResources) +{ + FFX_RETURN_ON_ERROR( + context, + FFX_ERROR_INVALID_POINTER); + FFX_RETURN_ON_ERROR( + SharedResources, + FFX_ERROR_INVALID_POINTER); + + FfxFsr3UpscalerContext_Private* contextPrivate = (FfxFsr3UpscalerContext_Private*)(context); + SharedResources->dilatedDepth = { FFX_HEAP_TYPE_DEFAULT, { FFX_RESOURCE_TYPE_TEXTURE2D, FFX_SURFACE_FORMAT_R32_FLOAT, contextPrivate->contextDescription.maxRenderSize.width, contextPrivate->contextDescription.maxRenderSize.height, 1, 1, FFX_RESOURCE_FLAGS_NONE, (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV | FFX_RESOURCE_USAGE_DCC_RENDERTARGET) }, + FFX_RESOURCE_STATE_UNORDERED_ACCESS, L"FSR3UPSCALER_DilatedDepth", FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_DEPTH, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }; + SharedResources->dilatedMotionVectors = { FFX_HEAP_TYPE_DEFAULT, { FFX_RESOURCE_TYPE_TEXTURE2D, FFX_SURFACE_FORMAT_R16G16_FLOAT, contextPrivate->contextDescription.maxRenderSize.width, contextPrivate->contextDescription.maxRenderSize.height, 1, 1, FFX_RESOURCE_FLAGS_NONE, (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV | FFX_RESOURCE_USAGE_DCC_RENDERTARGET) }, + FFX_RESOURCE_STATE_UNORDERED_ACCESS, L"FSR3UPSCALER_DilatedVelocity", FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }; + SharedResources->reconstructedPrevNearestDepth = { FFX_HEAP_TYPE_DEFAULT, { FFX_RESOURCE_TYPE_TEXTURE2D, FFX_SURFACE_FORMAT_R32_UINT, contextPrivate->contextDescription.maxRenderSize.width, contextPrivate->contextDescription.maxRenderSize.height, 1, 1, FFX_RESOURCE_FLAGS_NONE, (FfxResourceUsage)(FFX_RESOURCE_USAGE_UAV) }, + FFX_RESOURCE_STATE_UNORDERED_ACCESS, L"FSR3UPSCALER_ReconstructedPrevNearestDepth", FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH, {FFX_RESOURCE_INIT_DATA_TYPE_UNINITIALIZED} }; + + return FFX_OK; +} + +static FfxErrorCode fsr3upscalerDispatch(FfxFsr3UpscalerContext_Private* context, const FfxFsr3UpscalerDispatchDescription* params) +{ + + if ((context->contextDescription.flags & FFX_FSR3UPSCALER_ENABLE_DEBUG_CHECKING) == FFX_FSR3UPSCALER_ENABLE_DEBUG_CHECKING) + { + fsr3upscalerDebugCheckDispatch(context, params); + } + + // take a short cut to the command list + FfxCommandList commandList = params->commandList; + + if (context->firstExecution) + { + FfxGpuJobDescription clearJob = { FFX_GPU_JOB_CLEAR_FLOAT }; + + const float clearValuesToZeroFloat[]{ 0.f, 0.f, 0.f, 0.f }; + memcpy(clearJob.clearJobDescriptor.color, clearValuesToZeroFloat, 4 * sizeof(float)); + + wcscpy_s(clearJob.jobLabel, L"Clear Accumulation 1"); + clearJob.clearJobDescriptor.target = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION_1]; + context->contextDescription.backendInterface.fpScheduleGpuJob(&context->contextDescription.backendInterface, &clearJob); + wcscpy_s(clearJob.jobLabel, L"Clear Accumulation 2"); + clearJob.clearJobDescriptor.target = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION_2]; + context->contextDescription.backendInterface.fpScheduleGpuJob(&context->contextDescription.backendInterface, &clearJob); + + wcscpy_s(clearJob.jobLabel, L"Clear Temporal Luma 1"); + clearJob.clearJobDescriptor.target = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_1]; + context->contextDescription.backendInterface.fpScheduleGpuJob(&context->contextDescription.backendInterface, &clearJob); + wcscpy_s(clearJob.jobLabel, L"Clear Temporal Luma 2"); + clearJob.clearJobDescriptor.target = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_2]; + context->contextDescription.backendInterface.fpScheduleGpuJob(&context->contextDescription.backendInterface, &clearJob); + } + + // Prepare per frame descriptor tables + const bool isOddFrame = !!(context->resourceFrameIndex & 1); + const uint32_t currentCpuOnlyTableBase = isOddFrame ? FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_COUNT : 0; + const uint32_t currentGpuTableBase = 2 * FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_COUNT * context->resourceFrameIndex; + const uint32_t accumulationSrvResourceIndex = isOddFrame ? FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION_2 : FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION_1; + const uint32_t accumulationUavResourceIndex = isOddFrame ? FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION_1 : FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION_2; + const uint32_t upscaledColorSrvResourceIndex = isOddFrame ? FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_2 : FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_1; + const uint32_t upscaledColorUavResourceIndex = isOddFrame ? FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_1 : FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_2; + const uint32_t lumaHistorySrvResourceIndex = isOddFrame ? FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY_2 : FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY_1; + const uint32_t lumaHistoryUavResourceIndex = isOddFrame ? FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY_1 : FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY_2; + const uint32_t currentLumaSrvResourceIndex = isOddFrame ? FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_2 : FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_1; + const uint32_t currentLumaUavResourceIndex = currentLumaSrvResourceIndex; + const uint32_t previousLumaSrvResourceIndex = isOddFrame ? FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_1 : FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_2; + + const bool resetAccumulation = params->reset || context->firstExecution; + context->firstExecution = false; + + context->contextDescription.backendInterface.fpRegisterResource(&context->contextDescription.backendInterface, ¶ms->color, context->effectContextId, &context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_COLOR]); + context->contextDescription.backendInterface.fpRegisterResource(&context->contextDescription.backendInterface, ¶ms->depth, context->effectContextId, &context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_DEPTH]); + context->contextDescription.backendInterface.fpRegisterResource(&context->contextDescription.backendInterface, ¶ms->motionVectors, context->effectContextId, &context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_MOTION_VECTORS]); + + context->contextDescription.backendInterface.fpRegisterResource(&context->contextDescription.backendInterface, ¶ms->dilatedMotionVectors, context->effectContextId, &context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS]); + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS] = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS]; + context->contextDescription.backendInterface.fpRegisterResource(&context->contextDescription.backendInterface, ¶ms->dilatedDepth, context->effectContextId, &context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_DEPTH]); + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_DEPTH] = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_DEPTH]; + context->contextDescription.backendInterface.fpRegisterResource(&context->contextDescription.backendInterface, ¶ms->reconstructedPrevNearestDepth, context->effectContextId, &context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH]); + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH] = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH]; + + // if auto exposure is enabled use the auto exposure SRV, otherwise what the app sends. + if (context->contextDescription.flags & FFX_FSR3UPSCALER_ENABLE_AUTO_EXPOSURE) { + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_EXPOSURE] = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FRAME_INFO]; + } else { + if (ffxFsr3UpscalerResourceIsNull(params->exposure)) { + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_EXPOSURE] = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_EXPOSURE]; + } else { + context->contextDescription.backendInterface.fpRegisterResource(&context->contextDescription.backendInterface, ¶ms->exposure, context->effectContextId, &context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_EXPOSURE]); + } + } + + if (ffxFsr3UpscalerResourceIsNull(params->reactive)) { + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK] = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_REACTIVITY]; + } + else { + context->contextDescription.backendInterface.fpRegisterResource(&context->contextDescription.backendInterface, ¶ms->reactive, context->effectContextId, &context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK]); + } + + if (ffxFsr3UpscalerResourceIsNull(params->transparencyAndComposition)) { + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK] = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_REACTIVITY]; + } else { + context->contextDescription.backendInterface.fpRegisterResource(&context->contextDescription.backendInterface, ¶ms->transparencyAndComposition, context->effectContextId, &context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK]); + } + + context->contextDescription.backendInterface.fpRegisterResource(&context->contextDescription.backendInterface, ¶ms->output, context->effectContextId, &context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_UPSCALED_OUTPUT]); + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION] = context->srvResources[accumulationSrvResourceIndex]; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR] = context->srvResources[upscaledColorSrvResourceIndex]; + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION] = context->uavResources[accumulationUavResourceIndex]; + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR] = context->uavResources[upscaledColorUavResourceIndex]; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RCAS_INPUT] = context->uavResources[upscaledColorUavResourceIndex]; + + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_CURRENT_LUMA] = context->srvResources[currentLumaSrvResourceIndex]; + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_CURRENT_LUMA] = context->uavResources[currentLumaUavResourceIndex]; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_PREVIOUS_LUMA] = context->srvResources[previousLumaSrvResourceIndex]; + + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY] = context->uavResources[lumaHistoryUavResourceIndex]; + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY] = context->srvResources[lumaHistorySrvResourceIndex]; + + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH] = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERMEDIATE_FP16x1]; + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH] = context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERMEDIATE_FP16x1]; + + context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_INSTABILITY] = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERMEDIATE_FP16x1]; + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_INSTABILITY] = context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERMEDIATE_FP16x1]; + + // actual resource size may differ from render/display resolution (e.g. due to Hw/API restrictions), so query the descriptor for UVs adjustment + const FfxResourceDescription resourceDescInputColor = context->contextDescription.backendInterface.fpGetResourceDescription(&context->contextDescription.backendInterface, context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_COLOR]); + const FfxResourceDescription resourceDescReactiveMask = context->contextDescription.backendInterface.fpGetResourceDescription(&context->contextDescription.backendInterface, context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK]); + FFX_ASSERT(resourceDescInputColor.type == FFX_RESOURCE_TYPE_TEXTURE2D); + + context->constants.previousFrameJitterOffset[0] = context->constants.jitterOffset[0]; + context->constants.previousFrameJitterOffset[1] = context->constants.jitterOffset[1]; + context->constants.jitterOffset[0] = params->jitterOffset.x; + context->constants.jitterOffset[1] = params->jitterOffset.y; + + context->constants.previousFrameRenderSize[0] = context->constants.renderSize[0]; + context->constants.previousFrameRenderSize[1] = context->constants.renderSize[1]; + context->constants.renderSize[0] = int32_t(params->renderSize.width ? params->renderSize.width : resourceDescInputColor.width); + context->constants.renderSize[1] = int32_t(params->renderSize.height ? params->renderSize.height : resourceDescInputColor.height); + context->constants.maxRenderSize[0] = int32_t(context->contextDescription.maxRenderSize.width); + context->constants.maxRenderSize[1] = int32_t(context->contextDescription.maxRenderSize.height); + + // compute the horizontal FOV for the shader from the vertical one. + const float aspectRatio = (float)params->renderSize.width / (float)params->renderSize.height; + const float cameraAngleHorizontal = atan(tan(params->cameraFovAngleVertical / 2) * aspectRatio) * 2; + context->constants.tanHalfFOV = tanf(cameraAngleHorizontal * 0.5f); + context->constants.viewSpaceToMetersFactor = (params->viewSpaceToMetersFactor > 0.0f) ? params->viewSpaceToMetersFactor : 1.0f; + + // compute params to enable device depth to view space depth computation in shader + setupDeviceDepthToViewSpaceDepthParams(context, params); + + context->constants.previousFrameUpscaleSize[0] = context->constants.upscaleSize[0]; + context->constants.previousFrameUpscaleSize[1] = context->constants.upscaleSize[1]; + + if (params->upscaleSize.height == 0 && params->upscaleSize.width == 0) + { + context->constants.upscaleSize[0] = context->contextDescription.maxUpscaleSize.width; + context->constants.upscaleSize[1] = context->contextDescription.maxUpscaleSize.height; + } + else + { + context->constants.upscaleSize[0] = params->upscaleSize.width; + context->constants.upscaleSize[1] = params->upscaleSize.height; + } + + // To be updated if resource is larger than the actual image size + context->constants.downscaleFactor[0] = float(context->constants.renderSize[0]) / context->constants.upscaleSize[0]; + context->constants.downscaleFactor[1] = float(context->constants.renderSize[1]) / context->constants.upscaleSize[1]; + + // calculate pre-exposure relevant factors + context->constants.deltaPreExposure = 1.0f; + context->previousFramePreExposure = context->preExposure; + context->preExposure = (params->preExposure != 0.0f) ? params->preExposure : 1.0f; + + if (context->previousFramePreExposure > 0.0f) { + context->constants.deltaPreExposure = context->preExposure / context->previousFramePreExposure; + } + + // motion vector data + const int32_t* motionVectorsTargetSize = (context->contextDescription.flags & FFX_FSR3UPSCALER_ENABLE_DISPLAY_RESOLUTION_MOTION_VECTORS) + ? context->constants.upscaleSize + : context->constants.renderSize; + + context->constants.motionVectorScale[0] = (params->motionVectorScale.x / motionVectorsTargetSize[0]); + context->constants.motionVectorScale[1] = (params->motionVectorScale.y / motionVectorsTargetSize[1]); + + // compute jitter cancellation + if (context->contextDescription.flags & FFX_FSR3UPSCALER_ENABLE_MOTION_VECTORS_JITTER_CANCELLATION) { + + context->constants.motionVectorJitterCancellation[0] = (context->previousJitterOffset[0] - context->constants.jitterOffset[0]) / motionVectorsTargetSize[0]; + context->constants.motionVectorJitterCancellation[1] = (context->previousJitterOffset[1] - context->constants.jitterOffset[1]) / motionVectorsTargetSize[1]; + + context->previousJitterOffset[0] = context->constants.jitterOffset[0]; + context->previousJitterOffset[1] = context->constants.jitterOffset[1]; + } + + // lock data, assuming jitter sequence length computation for now + const int32_t jitterPhaseCount = ffxFsr3UpscalerGetJitterPhaseCount(params->renderSize.width, context->constants.upscaleSize[0]); + + // init on first frame + if (resetAccumulation || context->constants.jitterPhaseCount == 0) { + context->constants.jitterPhaseCount = (float)jitterPhaseCount; + } else { + const int32_t jitterPhaseCountDelta = (int32_t)(jitterPhaseCount - context->constants.jitterPhaseCount); + if (jitterPhaseCountDelta > 0) { + context->constants.jitterPhaseCount++; + } else if (jitterPhaseCountDelta < 0) { + context->constants.jitterPhaseCount--; + } + } + + // convert delta time to seconds and clamp to [0, 1]. + context->constants.deltaTime = FFX_MAXIMUM(0.0f, FFX_MINIMUM(1.0f, params->frameTimeDelta / 1000.0f)); + + if (resetAccumulation) { + context->constants.frameIndex = 0.0f; + } else { + context->constants.frameIndex += 1.0f; + } + + // reactive mask bias + const int32_t threadGroupWorkRegionDim = 8; + const int32_t dispatchSrcX = (context->constants.renderSize[0] + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim; + const int32_t dispatchSrcY = (context->constants.renderSize[1] + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim; + const int32_t dispatchDstX = (context->constants.upscaleSize[0] + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim; + const int32_t dispatchDstY = (context->constants.upscaleSize[1] + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim; + const int32_t dispatchShadingChangePassX = (int32_t(context->constants.renderSize[0] * 0.5f) + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim; + const int32_t dispatchShadingChangePassY = (int32_t(context->constants.renderSize[1] * 0.5f) + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim; + + // Clear reconstructed depth for max depth store. + if (resetAccumulation) { + + FfxGpuJobDescription clearJob = { FFX_GPU_JOB_CLEAR_FLOAT }; + wcscpy_s(clearJob.jobLabel, L"Clear Resource"); + + const float clearValuesToZeroFloat[]{ 0.f, 0.f, 0.f, 0.f }; + memcpy(clearJob.clearJobDescriptor.color, clearValuesToZeroFloat, 4 * sizeof(float)); + clearJob.clearJobDescriptor.target = context->srvResources[accumulationSrvResourceIndex]; + context->contextDescription.backendInterface.fpScheduleGpuJob(&context->contextDescription.backendInterface, &clearJob); + + wcscpy_s(clearJob.jobLabel, L"Clear Scene Luminance"); + clearJob.clearJobDescriptor.target = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS]; + context->contextDescription.backendInterface.fpScheduleGpuJob(&context->contextDescription.backendInterface, &clearJob); + + // Auto exposure always used to track luma changes in locking logic + { + const float clearValuesExposure[]{ -1.f, 1.f, 0.f, 0.f }; + memcpy(clearJob.clearJobDescriptor.color, clearValuesExposure, 4 * sizeof(float)); + wcscpy_s(clearJob.jobLabel, L"Clear Frame Info"); + clearJob.clearJobDescriptor.target = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FRAME_INFO]; + context->contextDescription.backendInterface.fpScheduleGpuJob(&context->contextDescription.backendInterface, &clearJob); + } + } + + { + FfxGpuJobDescription clearJob = {FFX_GPU_JOB_CLEAR_FLOAT}; + // FSR3: need to clear here since we need the content of this surface for frameinterpolation + // so clearing in the lock pass is not an option + const bool bInverted = (context->contextDescription.flags & FFX_FSR3UPSCALER_ENABLE_DEPTH_INVERTED) == FFX_FSR3UPSCALER_ENABLE_DEPTH_INVERTED; + const float clearDepthValue[]{bInverted ? 0.f : 1.f, bInverted ? 0.f : 1.f, bInverted ? 0.f : 1.f, bInverted ? 0.f : 1.f}; + memcpy(clearJob.clearJobDescriptor.color, clearDepthValue, 4 * sizeof(float)); + wcscpy_s(clearJob.jobLabel, L"Clear Reconstructed Previous Nearest Depth"); + clearJob.clearJobDescriptor.target = context->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH]; + context->contextDescription.backendInterface.fpScheduleGpuJob(&context->contextDescription.backendInterface, &clearJob); + } + + // Suggested by Enduring to resolve issues with running FSR3 on console via the RHI backend in the plugin as this resource won't be cleared to 0 by default. + { + FfxGpuJobDescription clearJob = { FFX_GPU_JOB_CLEAR_FLOAT }; + wcscpy_s(clearJob.jobLabel, L"Clear Spd Atomic Count"); + const float clearValuesToZeroFloat[]{ 0.f, 0.f, 0.f, 0.f }; + memcpy(clearJob.clearJobDescriptor.color, clearValuesToZeroFloat, 4 * sizeof(float)); + clearJob.clearJobDescriptor.target = context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_ATOMIC_COUNT]; + context->contextDescription.backendInterface.fpScheduleGpuJob(&context->contextDescription.backendInterface, &clearJob); + } + + // Auto exposure + uint32_t dispatchThreadGroupCountXY[2]; + uint32_t workGroupOffset[2]; + uint32_t numWorkGroupsAndMips[2]; + uint32_t rectInfo[4] = { 0, 0, params->renderSize.width, params->renderSize.height }; + ffxSpdSetup(dispatchThreadGroupCountXY, workGroupOffset, numWorkGroupsAndMips, rectInfo); + + // downsample + Fsr3UpscalerSpdConstants luminancePyramidConstants; + luminancePyramidConstants.numworkGroups = numWorkGroupsAndMips[0]; + luminancePyramidConstants.mips = numWorkGroupsAndMips[1]; + luminancePyramidConstants.workGroupOffset[0] = workGroupOffset[0]; + luminancePyramidConstants.workGroupOffset[1] = workGroupOffset[1]; + luminancePyramidConstants.renderSize[0] = params->renderSize.width; + luminancePyramidConstants.renderSize[1] = params->renderSize.height; + + // compute the constants. + Fsr3UpscalerRcasConstants rcasConsts = {}; + const float sharpenessRemapped = (-2.0f * params->sharpness) + 2.0f; + FsrRcasCon(rcasConsts.rcasConfig, sharpenessRemapped); + + // initialize constantBuffers data + context->contextDescription.backendInterface.fpStageConstantBufferDataFunc(&context->contextDescription.backendInterface, &context->constants, sizeof(context->constants), &context->constantBuffers[FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_FSR3UPSCALER]); + context->contextDescription.backendInterface.fpStageConstantBufferDataFunc(&context->contextDescription.backendInterface, &luminancePyramidConstants, sizeof(luminancePyramidConstants), &context->constantBuffers[FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_SPD]); + context->contextDescription.backendInterface.fpStageConstantBufferDataFunc(&context->contextDescription.backendInterface, &rcasConsts, sizeof(rcasConsts), &context->constantBuffers[FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_RCAS]); + + { + FfxResourceInternal aliasableResources[] = { + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERMEDIATE_FP16x1], + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SHADING_CHANGE], + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NEW_LOCKS], + // SPD_MIPS are an aliasable resource, but need to be cleared to prevent reading pixels that have never been written + //context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS], + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH_MIP1], + context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_REACTIVE_MASKS], + }; + for(int i = 0; i<_countof(aliasableResources); ++i) + { + FfxGpuJobDescription discardJob = { FFX_GPU_JOB_DISCARD }; + discardJob.discardJobDescriptor.target = aliasableResources[i]; + context->contextDescription.backendInterface.fpScheduleGpuJob(&context->contextDescription.backendInterface, &discardJob); + } + // SPD counter needs to be cleared + { + FfxGpuJobDescription clearJob = { FFX_GPU_JOB_CLEAR_FLOAT }; + wcscpy_s(clearJob.jobLabel, L"Clear Spd Atomic Count"); + const float clearValuesToZeroFloat[]{ 0.f, 0.f, 0.f, 0.f }; + memcpy(clearJob.clearJobDescriptor.color, clearValuesToZeroFloat, 4 * sizeof(float)); + clearJob.clearJobDescriptor.target = context->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS]; + context->contextDescription.backendInterface.fpScheduleGpuJob(&context->contextDescription.backendInterface, &clearJob); + } + } + + scheduleDispatch(context, params, &context->pipelinePrepareInputs, dispatchSrcX, dispatchSrcY); + scheduleDispatch(context, params, &context->pipelineLumaPyramid, dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1]); + scheduleDispatch(context, params, &context->pipelineShadingChangePyramid, dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1]); + scheduleDispatch(context, params, &context->pipelineShadingChange, dispatchShadingChangePassX, dispatchShadingChangePassY); + scheduleDispatch(context, params, &context->pipelinePrepareReactivity, dispatchSrcX, dispatchSrcY); + scheduleDispatch(context, params, &context->pipelineLumaInstability, dispatchSrcX, dispatchSrcY); + + scheduleDispatch(context, params, params->enableSharpening ? &context->pipelineAccumulateSharpen : &context->pipelineAccumulate, dispatchDstX, dispatchDstY); + + // RCAS + if (params->enableSharpening) + { + + // dispatch RCAS + const int32_t threadGroupWorkRegionDimRCAS = 16; + const int32_t dispatchX = (context->constants.upscaleSize[0] + (threadGroupWorkRegionDimRCAS - 1)) / threadGroupWorkRegionDimRCAS; + const int32_t dispatchY = (context->constants.upscaleSize[1] + (threadGroupWorkRegionDimRCAS - 1)) / threadGroupWorkRegionDimRCAS; + scheduleDispatch(context, params, &context->pipelineRCAS, dispatchX, dispatchY); + } + + if (params->flags & FFX_FSR3UPSCALER_DISPATCH_DRAW_DEBUG_VIEW) { + scheduleDispatch(context, params, &context->pipelineDebugView, dispatchDstX, dispatchDstY); + } + + context->resourceFrameIndex = (context->resourceFrameIndex + 1) % FSR3UPSCALER_MAX_QUEUED_FRAMES; + + // Fsr3UpscalerMaxQueuedFrames must be an even number. + FFX_STATIC_ASSERT((FSR3UPSCALER_MAX_QUEUED_FRAMES & 1) == 0); + + context->contextDescription.backendInterface.fpExecuteGpuJobs(&context->contextDescription.backendInterface, commandList, context->effectContextId); + + // release dynamic resources + context->contextDescription.backendInterface.fpUnregisterResources(&context->contextDescription.backendInterface, commandList, context->effectContextId); + + return FFX_OK; +} + +FFX_API FfxErrorCode ffxFsr3UpscalerContextCreate(FfxFsr3UpscalerContext* context, const FfxFsr3UpscalerContextDescription* contextDescription) +{ + // zero context memory + memset(context, 0, sizeof(FfxFsr3UpscalerContext)); + + // check pointers are valid. + FFX_RETURN_ON_ERROR( + context, + FFX_ERROR_INVALID_POINTER); + FFX_RETURN_ON_ERROR( + contextDescription, + FFX_ERROR_INVALID_POINTER); + + // validate that all callbacks are set for the interface + FFX_RETURN_ON_ERROR(contextDescription->backendInterface.fpGetSDKVersion, FFX_ERROR_INCOMPLETE_INTERFACE); + FFX_RETURN_ON_ERROR(contextDescription->backendInterface.fpGetDeviceCapabilities, FFX_ERROR_INCOMPLETE_INTERFACE); + FFX_RETURN_ON_ERROR(contextDescription->backendInterface.fpCreateBackendContext, FFX_ERROR_INCOMPLETE_INTERFACE); + FFX_RETURN_ON_ERROR(contextDescription->backendInterface.fpDestroyBackendContext, FFX_ERROR_INCOMPLETE_INTERFACE); + + // if a scratch buffer is declared, then we must have a size + if (contextDescription->backendInterface.scratchBuffer) { + + FFX_RETURN_ON_ERROR(contextDescription->backendInterface.scratchBufferSize, FFX_ERROR_INCOMPLETE_INTERFACE); + } + + // ensure the context is large enough for the internal context. + FFX_STATIC_ASSERT(sizeof(FfxFsr3UpscalerContext) >= sizeof(FfxFsr3UpscalerContext_Private)); + + // create the context. + FfxFsr3UpscalerContext_Private* contextPrivate = (FfxFsr3UpscalerContext_Private*)(context); + const FfxErrorCode errorCode = fsr3upscalerCreate(contextPrivate, contextDescription); + + return errorCode; +} + +FFX_API FfxErrorCode ffxFsr3UpscalerContextGetGpuMemoryUsage(FfxFsr3UpscalerContext* context, FfxEffectMemoryUsage* vramUsage) +{ + FFX_RETURN_ON_ERROR(context, FFX_ERROR_INVALID_POINTER); + FFX_RETURN_ON_ERROR(vramUsage, FFX_ERROR_INVALID_POINTER); + FfxFsr3UpscalerContext_Private* contextPrivate = (FfxFsr3UpscalerContext_Private*)(context); + + FFX_RETURN_ON_ERROR(contextPrivate->device, FFX_ERROR_NULL_DEVICE); + + FfxErrorCode errorCode = contextPrivate->contextDescription.backendInterface.fpGetEffectGpuMemoryUsage( + &contextPrivate->contextDescription.backendInterface, contextPrivate->effectContextId, vramUsage); + FFX_RETURN_ON_ERROR(errorCode == FFX_OK, errorCode); + + return FFX_OK; +} + +FfxErrorCode ffxFsr3UpscalerContextDestroy(FfxFsr3UpscalerContext* context) +{ + FFX_RETURN_ON_ERROR( + context, + FFX_ERROR_INVALID_POINTER); + + // destroy the context. + FfxFsr3UpscalerContext_Private* contextPrivate = (FfxFsr3UpscalerContext_Private*)(context); + const FfxErrorCode errorCode = fsr3upscalerRelease(contextPrivate); + return errorCode; +} + +FfxErrorCode ffxFsr3UpscalerContextDispatch(FfxFsr3UpscalerContext* context, const FfxFsr3UpscalerDispatchDescription* dispatchParams) +{ + FFX_RETURN_ON_ERROR( + context, + FFX_ERROR_INVALID_POINTER); + FFX_RETURN_ON_ERROR( + dispatchParams, + FFX_ERROR_INVALID_POINTER); + + FfxFsr3UpscalerContext_Private* contextPrivate = (FfxFsr3UpscalerContext_Private*)(context); + + // validate that renderSize is within the maximum. + FFX_RETURN_ON_ERROR( + dispatchParams->renderSize.width <= contextPrivate->contextDescription.maxRenderSize.width, + FFX_ERROR_OUT_OF_RANGE); + FFX_RETURN_ON_ERROR( + dispatchParams->renderSize.height <= contextPrivate->contextDescription.maxRenderSize.height, + FFX_ERROR_OUT_OF_RANGE); + FFX_RETURN_ON_ERROR( + dispatchParams->upscaleSize.width <= contextPrivate->contextDescription.maxUpscaleSize.width, + FFX_ERROR_OUT_OF_RANGE); + FFX_RETURN_ON_ERROR( + dispatchParams->upscaleSize.height <= contextPrivate->contextDescription.maxUpscaleSize.height, + FFX_ERROR_OUT_OF_RANGE); + FFX_RETURN_ON_ERROR( + contextPrivate->device, + FFX_ERROR_NULL_DEVICE); + + // dispatch the FSR3 passes. + const FfxErrorCode errorCode = fsr3upscalerDispatch(contextPrivate, dispatchParams); + return errorCode; +} + +FFX_API float ffxFsr3UpscalerGetUpscaleRatioFromQualityMode(FfxFsr3UpscalerQualityMode qualityMode) +{ + switch (qualityMode) { + case FFX_FSR3UPSCALER_QUALITY_MODE_NATIVEAA: + return 1.0f; + case FFX_FSR3UPSCALER_QUALITY_MODE_QUALITY: + return 1.5f; + case FFX_FSR3UPSCALER_QUALITY_MODE_BALANCED: + return 1.7f; + case FFX_FSR3UPSCALER_QUALITY_MODE_PERFORMANCE: + return 2.0f; + case FFX_FSR3UPSCALER_QUALITY_MODE_ULTRA_PERFORMANCE: + return 3.0f; + default: + return 0.0f; + } +} + +FFX_API FfxErrorCode ffxFsr3UpscalerGetRenderResolutionFromQualityMode( + uint32_t* renderWidth, + uint32_t* renderHeight, + uint32_t displayWidth, + uint32_t displayHeight, + FfxFsr3UpscalerQualityMode qualityMode) +{ + FFX_RETURN_ON_ERROR( + renderWidth, + FFX_ERROR_INVALID_POINTER); + FFX_RETURN_ON_ERROR( + renderHeight, + FFX_ERROR_INVALID_POINTER); + FFX_RETURN_ON_ERROR( + FFX_FSR3UPSCALER_QUALITY_MODE_NATIVEAA <= qualityMode && qualityMode <= FFX_FSR3UPSCALER_QUALITY_MODE_ULTRA_PERFORMANCE, + FFX_ERROR_INVALID_ENUM); + + // scale by the predefined ratios in each dimension. + const float ratio = ffxFsr3UpscalerGetUpscaleRatioFromQualityMode(qualityMode); + const uint32_t scaledDisplayWidth = (uint32_t)((float)displayWidth / ratio); + const uint32_t scaledDisplayHeight = (uint32_t)((float)displayHeight / ratio); + *renderWidth = scaledDisplayWidth; + *renderHeight = scaledDisplayHeight; + + return FFX_OK; +} + +int32_t ffxFsr3UpscalerGetJitterPhaseCount(int32_t renderWidth, int32_t displayWidth) +{ + const float basePhaseCount = 8.0f; + const int32_t jitterPhaseCount = int32_t(basePhaseCount * pow((float(displayWidth) / renderWidth), 2.0f)); + return jitterPhaseCount; +} + +FfxErrorCode ffxFsr3UpscalerGetJitterOffset(float* outX, float* outY, int32_t index, int32_t phaseCount) +{ + FFX_RETURN_ON_ERROR( + outX, + FFX_ERROR_INVALID_POINTER); + FFX_RETURN_ON_ERROR( + outY, + FFX_ERROR_INVALID_POINTER); + FFX_RETURN_ON_ERROR( + phaseCount > 0, + FFX_ERROR_INVALID_ARGUMENT); + + const float x = halton((index % phaseCount) + 1, 2) - 0.5f; + const float y = halton((index % phaseCount) + 1, 3) - 0.5f; + + *outX = x; + *outY = y; + return FFX_OK; +} + +FFX_API bool ffxFsr3UpscalerResourceIsNull(FfxResource resource) +{ + return resource.resource == NULL; +} + +FfxErrorCode ffxFsr3UpscalerContextGenerateReactiveMask(FfxFsr3UpscalerContext* context, const FfxFsr3UpscalerGenerateReactiveDescription* params) +{ + FFX_RETURN_ON_ERROR( + context, + FFX_ERROR_INVALID_POINTER); + FFX_RETURN_ON_ERROR( + params, + FFX_ERROR_INVALID_POINTER); + FFX_RETURN_ON_ERROR( + params->commandList, + FFX_ERROR_INVALID_POINTER); + + FfxFsr3UpscalerContext_Private* contextPrivate = (FfxFsr3UpscalerContext_Private*)(context); + + FFX_RETURN_ON_ERROR( + contextPrivate->device, + FFX_ERROR_NULL_DEVICE); + + // take a short cut to the command list + FfxCommandList commandList = params->commandList; + + FfxPipelineState* pipeline = &contextPrivate->pipelineGenerateReactive; + + const int32_t threadGroupWorkRegionDim = 8; + const int32_t dispatchSrcX = (params->renderSize.width + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim; + const int32_t dispatchSrcY = (params->renderSize.height + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim; + + FfxComputeJobDescription jobDescriptor = {}; + contextPrivate->contextDescription.backendInterface.fpRegisterResource(&contextPrivate->contextDescription.backendInterface, ¶ms->colorOpaqueOnly, contextPrivate->effectContextId, &contextPrivate->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_OPAQUE_ONLY]); + contextPrivate->contextDescription.backendInterface.fpRegisterResource(&contextPrivate->contextDescription.backendInterface, ¶ms->colorPreUpscale, contextPrivate->effectContextId, &contextPrivate->srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_COLOR]); + contextPrivate->contextDescription.backendInterface.fpRegisterResource(&contextPrivate->contextDescription.backendInterface, ¶ms->outReactive, contextPrivate->effectContextId, &contextPrivate->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_AUTOREACTIVE]); + + jobDescriptor.uavTextures[0].resource = contextPrivate->uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_AUTOREACTIVE]; + +#ifdef FFX_DEBUG + wcscpy_s(jobDescriptor.srvTextures[0].name, pipeline->srvTextureBindings[0].name); + wcscpy_s(jobDescriptor.srvTextures[1].name, pipeline->srvTextureBindings[1].name); + wcscpy_s(jobDescriptor.uavTextures[0].name, pipeline->uavTextureBindings[0].name); +#endif + + jobDescriptor.dimensions[0] = dispatchSrcX; + jobDescriptor.dimensions[1] = dispatchSrcY; + jobDescriptor.dimensions[2] = 1; + jobDescriptor.pipeline = *pipeline; + + for (uint32_t currentShaderResourceViewIndex = 0; currentShaderResourceViewIndex < pipeline->srvTextureCount; ++currentShaderResourceViewIndex) { + + const uint32_t currentResourceId = pipeline->srvTextureBindings[currentShaderResourceViewIndex].resourceIdentifier; + const FfxResourceInternal currentResource = contextPrivate->srvResources[currentResourceId]; + jobDescriptor.srvTextures[currentShaderResourceViewIndex].resource = currentResource; +#ifdef FFX_DEBUG + wcscpy_s(jobDescriptor.srvTextures[currentShaderResourceViewIndex].name, pipeline->srvTextureBindings[currentShaderResourceViewIndex].name); +#endif + } + + Fsr3UpscalerGenerateReactiveConstants genReactiveConsts = {}; + genReactiveConsts.scale = params->scale; + genReactiveConsts.threshold = params->cutoffThreshold; + genReactiveConsts.binaryValue = params->binaryValue; + genReactiveConsts.flags = params->flags; + + contextPrivate->contextDescription.backendInterface.fpStageConstantBufferDataFunc(&contextPrivate->contextDescription.backendInterface, &genReactiveConsts, sizeof(genReactiveConsts), &contextPrivate->constantBuffers[FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_GENREACTIVE]); + + for (uint32_t currentRootConstantIndex = 0; currentRootConstantIndex < pipeline->constCount; ++currentRootConstantIndex) + { +#ifdef FFX_DEBUG + wcscpy_s(jobDescriptor.cbNames[currentRootConstantIndex], pipeline->constantBufferBindings[currentRootConstantIndex].name); +#endif + jobDescriptor.cbs[currentRootConstantIndex] = contextPrivate->constantBuffers[pipeline->constantBufferBindings[currentRootConstantIndex].resourceIdentifier]; + } + + FfxGpuJobDescription dispatchJob = { FFX_GPU_JOB_COMPUTE }; + dispatchJob.computeJobDescriptor = jobDescriptor; + + contextPrivate->contextDescription.backendInterface.fpScheduleGpuJob(&contextPrivate->contextDescription.backendInterface, &dispatchJob); + + contextPrivate->contextDescription.backendInterface.fpExecuteGpuJobs(&contextPrivate->contextDescription.backendInterface, commandList, contextPrivate->effectContextId); + + // release dynamic resources + contextPrivate->contextDescription.backendInterface.fpUnregisterResources(&contextPrivate->contextDescription.backendInterface, commandList, contextPrivate->effectContextId); + + return FFX_OK; +} + +FFX_API FfxVersionNumber ffxFsr3UpscalerGetEffectVersion() +{ + return FFX_SDK_MAKE_VERSION(FFX_FSR3UPSCALER_VERSION_MAJOR, FFX_FSR3UPSCALER_VERSION_MINOR, FFX_FSR3UPSCALER_VERSION_PATCH); +} + +FFX_API FfxErrorCode ffxFsr3UpscalerSetConstant(FfxFsr3UpscalerContext* context, FfxFsr3UpscalerConfigureKey key, void* valuePtr) +{ + FFX_RETURN_ON_ERROR( + context, + FFX_ERROR_INVALID_POINTER); + + FfxFsr3UpscalerContext_Private* contextPrivate = (FfxFsr3UpscalerContext_Private*)(context); + switch (key) + { + case FFX_FSR3UPSCALER_CONFIGURE_UPSCALE_KEY_FVELOCITYFACTOR: + { + float fValue = 1.0f; + if (valuePtr != nullptr) + { + fValue = *(static_cast(valuePtr)); + } + contextPrivate->constants.velocityFactor = ffxSaturate(fValue); + break; + } + case FFX_FSR3UPSCALER_CONFIGURE_UPSCALE_KEY_FREACTIVENESSSCALE: + { + float fValue = 1.0f; + if (valuePtr != nullptr) + { + fValue = *(static_cast(valuePtr)); + } + contextPrivate->constants.reactivenessScale = ffxMax(0.f,fValue); + break; + } + case FFX_FSR3UPSCALER_CONFIGURE_UPSCALE_KEY_FSHADINGCHANGESCALE: + { + float fValue = 1.0f; + if (valuePtr != nullptr) + { + fValue = *(static_cast(valuePtr)); + } + contextPrivate->constants.shadingChangeScale = ffxMax(0.f,fValue); + break; + } + case FFX_FSR3UPSCALER_CONFIGURE_UPSCALE_KEY_FACCUMULATIONADDEDPERFRAME: + { + float fValue = 1.0f/3.0f; + if (valuePtr != nullptr) + { + fValue = *(static_cast(valuePtr)); + } + contextPrivate->constants.accumulationAddedPerFrame = ffxSaturate(fValue); + break; + } + case FFX_FSR3UPSCALER_CONFIGURE_UPSCALE_KEY_FMINDISOCCLUSIONACCUMULATION: + { + float fValue = -1.0f/3.0f; + if (valuePtr != nullptr) + { + fValue = *(static_cast(valuePtr)); + } + contextPrivate->constants.minDisocclusionAccumulation = ffxMin(1.0f, ffxMax(-1.0f, fValue)); + break; + } + default: + return FFX_ERROR_INVALID_ENUM; + } + return FFX_OK; +} + +FFX_API FfxErrorCode ffxFsr3UpscalerSetGlobalDebugMessage(ffxMessageCallback fpMessage, uint32_t debugLevel) +{ + ffxSetPrintMessageCallback(fpMessage, debugLevel); + return FFX_OK; +} diff --git a/runtime/third_party/FidelityFX/sdk/src/components/fsr3upscaler/ffx_fsr3upscaler_private.h b/runtime/third_party/FidelityFX/sdk/src/components/fsr3upscaler/ffx_fsr3upscaler_private.h new file mode 100644 index 00000000..79d25a74 --- /dev/null +++ b/runtime/third_party/FidelityFX/sdk/src/components/fsr3upscaler/ffx_fsr3upscaler_private.h @@ -0,0 +1,122 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#pragma once +#include + +/// An enumeration of all the permutations that can be passed to the FSR3 Upscaler algorithm. +/// +/// FSR3 Upscaler features are organized through a set of pre-defined compile +/// permutation options that need to be specified. Which shader blob +/// is returned for pipeline creation will be determined by what combination +/// of shader permutations are enabled. +/// +/// @ingroup FSR3Upscaler +typedef enum Fs3UpscalerShaderPermutationOptions +{ + FSR3UPSCALER_SHADER_PERMUTATION_USE_LANCZOS_TYPE = (1 << 0), ///< Off means reference, On means LUT + FSR3UPSCALER_SHADER_PERMUTATION_HDR_COLOR_INPUT = (1 << 1), ///< Enables the HDR code path + FSR3UPSCALER_SHADER_PERMUTATION_LOW_RES_MOTION_VECTORS = (1 << 2), ///< Indicates low resolution motion vectors provided + FSR3UPSCALER_SHADER_PERMUTATION_JITTER_MOTION_VECTORS = (1 << 3), ///< Indicates motion vectors were generated with jitter + FSR3UPSCALER_SHADER_PERMUTATION_DEPTH_INVERTED = (1 << 4), ///< Indicates input resources were generated with inverted depth + FSR3UPSCALER_SHADER_PERMUTATION_ENABLE_SHARPENING = (1 << 5), ///< Enables a supplementary sharpening pass + FSR3UPSCALER_SHADER_PERMUTATION_FORCE_WAVE64 = (1 << 6), ///< doesn't map to a define, selects different table + FSR3UPSCALER_SHADER_PERMUTATION_ALLOW_FP16 = (1 << 7), ///< Enables fast math computations where possible +} Fs3UpscalerShaderPermutationOptions; + +// Constants for FSR3 Upscaler dispatches. Must be kept in sync with cbFSR3Upscaler in ffx_fsr2_callbacks_hlsl.h +typedef struct Fsr3UpscalerConstants { + + int32_t renderSize[2]; + int32_t previousFrameRenderSize[2]; + + int32_t upscaleSize[2]; + int32_t previousFrameUpscaleSize[2]; + + int32_t maxRenderSize[2]; + int32_t maxUpscaleSize[2]; + + float deviceToViewDepth[4]; + + float jitterOffset[2]; + float previousFrameJitterOffset[2]; + + float motionVectorScale[2]; + float downscaleFactor[2]; + + float motionVectorJitterCancellation[2]; + float tanHalfFOV; + float jitterPhaseCount; + + float deltaTime; + float deltaPreExposure; + float viewSpaceToMetersFactor; + float frameIndex; + + float velocityFactor; + float reactivenessScale; + float shadingChangeScale; + float accumulationAddedPerFrame; + float minDisocclusionAccumulation; +} Fsr3UpscalerConstants; + +struct FfxFsr3UpscalerContextDescription; +struct FfxDeviceCapabilities; +struct FfxPipelineState; + +// FfxFsr3UpscalerContext_Private +// The private implementation of the FSR3 Upscaler context. +typedef struct FfxFsr3UpscalerContext_Private { + + FfxFsr3UpscalerContextDescription contextDescription; + FfxUInt32 effectContextId; + Fsr3UpscalerConstants constants; + FfxDevice device; + FfxDeviceCapabilities deviceCapabilities; + FfxPipelineState pipelinePrepareInputs; + FfxPipelineState pipelinePrepareReactivity; + FfxPipelineState pipelineShadingChange; + FfxPipelineState pipelineAccumulate; + FfxPipelineState pipelineAccumulateSharpen; + FfxPipelineState pipelineRCAS; + FfxPipelineState pipelineLumaPyramid; + FfxPipelineState pipelineGenerateReactive; + FfxPipelineState pipelineTcrAutogenerate; + FfxPipelineState pipelineShadingChangePyramid; + FfxPipelineState pipelineLumaInstability; + FfxPipelineState pipelineDebugView; + FfxConstantBuffer constantBuffers[FFX_FSR3UPSCALER_CONSTANTBUFFER_COUNT]; + + // 2 arrays of resources, as e.g. FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LOCK_STATUS will use different resources when bound as SRV vs when bound as UAV + FfxResourceInternal srvResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_COUNT]; + FfxResourceInternal uavResources[FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_COUNT]; + + bool firstExecution; + uint32_t resourceFrameIndex; + float previousJitterOffset[2]; + float preExposure; + float previousFramePreExposure; + +} FfxFsr3UpscalerContext_Private; + +// declare fsr3UpscalerCreate so it can be used from fsr3 +FFX_API FfxErrorCode fsr3UpscalerCreate(FfxFsr3UpscalerContext_Private* context, const FfxFsr3UpscalerContextDescription* contextDescription); diff --git a/runtime/third_party/FidelityFX/spirv/ffx_fsr3upscaler_vk.h b/runtime/third_party/FidelityFX/spirv/ffx_fsr3upscaler_vk.h new file mode 100644 index 00000000..4eb85648 --- /dev/null +++ b/runtime/third_party/FidelityFX/spirv/ffx_fsr3upscaler_vk.h @@ -0,0 +1,8158 @@ +// Generated by tools/ffx_shaders.py from the AMD FidelityFX SDK (MIT, see runtime/third_party/FidelityFX/LICENSE.txt). +// Do not edit. +#pragma once +#include + +static const uint32_t fu0_prepare_inputs_pass_0_spv[1555] = { + 0x7230203,0x10500,0x8000b,0x51e,0x0,0x20011,0x1,0x20011,0x31,0x6000b,0x1,0x4c534c47, + 0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0xf000f,0x5,0x4,0x6e69616d,0x0,0xb3, + 0xce,0xd6,0xde,0xec,0xf1,0xfc,0x105,0x10c,0x283,0x60010,0x4,0x11, + 0x8,0x8,0x1,0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373, + 0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0,0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469, + 0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f, + 0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669,0x40005,0x4, + 0x6e69616d,0x0,0x70005,0xb1,0x53466263,0x50553352,0x4c414353,0x745f5245,0x0,0x60006,0xb1,0x0, + 0x6e655269,0x53726564,0x657a69,0x80006,0xb1,0x1,0x76654466,0x54656369,0x6569566f,0x70654477,0x6874,0x80006, + 0xb1,0x2,0x746f4d66,0x566e6f69,0x6f746365,0x61635372,0x656c,0xa0006,0xb1,0x3,0x65695666,0x61705377, + 0x6f546563,0x6574654d,0x61467372,0x726f7463,0x0,0x60005,0xb3,0x53466263,0x70553352,0x6c616373,0x7265,0x60005, + 0xce,0x6e695f72,0x5f747570,0x74706564,0x68,0x80005,0xd6,0x6e695f72,0x5f747570,0x6f6c6f63,0x696a5f72,0x72657474, + 0x6465,0x80005,0xde,0x6e695f72,0x5f747570,0x69746f6d,0x765f6e6f,0x6f746365,0x7372,0x70005,0xec,0x665f7772, + 0x68747261,0x5f747365,0x74706564,0x68,0x60005,0xf1,0x635f7772,0x65727275,0x6c5f746e,0x616d75,0xc0005,0xfc, + 0x725f7772,0x6e6f6365,0x75727473,0x64657463,0x6572705f,0x756f6976,0x656e5f73,0x73657261,0x65645f74,0x687470,0x70005,0x105, + 0x645f7772,0x74616c69,0x645f6465,0x68747065,0x0,0x90005,0x10c,0x645f7772,0x74616c69,0x6d5f6465,0x6f69746f,0x65765f6e, + 0x726f7463,0x73,0x80005,0x283,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x44,0x30047,0xb1, + 0x2,0x50048,0xb1,0x0,0x23,0x0,0x50048,0xb1,0x1,0x23,0x30,0x50048, + 0xb1,0x2,0x23,0x50,0x50048,0xb1,0x3,0x23,0x78,0x40047,0xb3,0x21, + 0x8,0x40047,0xb3,0x22,0x0,0x40047,0xce,0x21,0x1,0x40047,0xce,0x22, + 0x0,0x40047,0xd6,0x21,0x2,0x40047,0xd6,0x22,0x0,0x40047,0xde,0x21, + 0x0,0x40047,0xde,0x22,0x0,0x40047,0xec,0x21,0x6,0x40047,0xec,0x22, + 0x0,0x40047,0xf1,0x21,0x7,0x40047,0xf1,0x22,0x0,0x40047,0xfc,0x21, + 0x5,0x40047,0xfc,0x22,0x0,0x30047,0x105,0x19,0x40047,0x105,0x21,0x4, + 0x40047,0x105,0x22,0x0,0x30047,0x10c,0x19,0x40047,0x10c,0x21,0x3,0x40047, + 0x10c,0x22,0x0,0x40047,0x283,0xb,0x1c,0x40047,0x297,0xb,0x19,0x30047, + 0x2cd,0x18,0x30047,0x2d2,0x18,0x20013,0x2,0x30021,0x3,0x2,0x30016,0x6, + 0x20,0x40020,0x7,0x7,0x6,0x40017,0x12,0x6,0x2,0x40017,0x21,0x6, + 0x3,0x40015,0x28,0x20,0x1,0x40017,0x29,0x28,0x2,0x40017,0x2d,0x6, + 0x4,0x40020,0x37,0x7,0x29,0x20014,0x65,0x40015,0x71,0x20,0x0,0x4002b, + 0x71,0x72,0x4,0x4001c,0x73,0x29,0x72,0x4001c,0x74,0x6,0x72,0x4002b, + 0x6,0x99,0x0,0x4002b,0x6,0x9a,0x3f800000,0x6001e,0xb1,0x29,0x2d,0x12, + 0x6,0x40020,0xb2,0x2,0xb1,0x4003b,0xb2,0xb3,0x2,0x4002b,0x28,0xb4, + 0x0,0x40020,0xb5,0x2,0x29,0x40020,0xbb,0x2,0x2d,0x4002b,0x28,0xc0, + 0x9,0x40020,0xc1,0x2,0x12,0x40020,0xc7,0x2,0x6,0x90019,0xcc,0x6, + 0x1,0x0,0x0,0x0,0x1,0x0,0x40020,0xcd,0x0,0xcc,0x4003b,0xcd, + 0xce,0x0,0x4002b,0x71,0xd2,0x0,0x4003b,0xcd,0xd6,0x0,0x4003b,0xcd, + 0xde,0x0,0x90019,0xea,0x6,0x1,0x0,0x0,0x0,0x2,0x9,0x40020, + 0xeb,0x0,0xea,0x4003b,0xeb,0xec,0x0,0x4003b,0xeb,0xf1,0x0,0x90019, + 0xfa,0x71,0x1,0x0,0x0,0x0,0x2,0x21,0x40020,0xfb,0x0,0xfa, + 0x4003b,0xfb,0xfc,0x0,0x40020,0xff,0xb,0x71,0x4002b,0x71,0x101,0x1, + 0x90019,0x103,0x6,0x1,0x0,0x0,0x0,0x2,0x3,0x40020,0x104,0x0, + 0x103,0x4003b,0x104,0x105,0x0,0x90019,0x10a,0x6,0x1,0x0,0x0,0x0, + 0x2,0x7,0x40020,0x10b,0x0,0x10a,0x4003b,0x10b,0x10c,0x0,0x4002b,0x6, + 0x113,0x3e800000,0x4002b,0x6,0x114,0x3f400000,0x4002b,0x6,0x121,0x45700000,0x4002b,0x6, + 0x122,0x45070000,0x5002c,0x12,0x123,0x121,0x122,0x4002b,0x6,0x129,0x3e59b3d0,0x4002b, + 0x6,0x12a,0x3f371759,0x4002b,0x6,0x12b,0x3d93dd98,0x6002c,0x21,0x12c,0x129,0x12a, + 0x12b,0x40017,0x131,0x71,0x2,0x40017,0x135,0x65,0x2,0x4002b,0x6,0x152, + 0x3f000000,0x5002c,0x12,0x153,0x152,0x152,0x5002c,0x29,0x160,0xb4,0xb4,0x4002b, + 0x28,0x162,0x1,0x5002c,0x29,0x163,0x162,0xb4,0x5002c,0x29,0x165,0xb4, + 0x162,0x5002c,0x29,0x168,0x162,0x162,0x4002b,0x6,0x18d,0x477fe000,0x4002b,0x28, + 0x1b7,0x4,0x4002b,0x6,0x1c2,0x3a1fe868,0x4002b,0x71,0x1e3,0x9,0x4001c,0x1e4, + 0x29,0x1e3,0x4002b,0x28,0x1e5,0xffffffff,0x5002c,0x29,0x1e6,0xb4,0x1e5,0x5002c, + 0x29,0x1e7,0x1e5,0xb4,0x5002c,0x29,0x1e8,0x1e5,0x162,0x5002c,0x29,0x1e9, + 0x1e5,0x1e5,0x5002c,0x29,0x1ea,0x162,0x1e5,0xc002c,0x1e4,0x1eb,0x160,0x163, + 0x165,0x1e6,0x1e7,0x1e8,0x168,0x1e9,0x1ea,0x40020,0x1ed,0x7,0x1e4,0x4001c, + 0x1f2,0x6,0x1e3,0x40020,0x1f3,0x7,0x1f2,0x6002c,0x21,0x241,0x99,0x99, + 0x99,0x40017,0x281,0x71,0x3,0x40020,0x282,0x1,0x281,0x4003b,0x282,0x283, + 0x1,0x4002b,0x71,0x296,0x8,0x6002c,0x281,0x297,0x296,0x296,0x101,0x40020, + 0x476,0x7,0x73,0x40020,0x478,0x7,0x74,0x7002c,0x73,0x50b,0x160,0x163, + 0x165,0x168,0x4002b,0x6,0x50c,0x3c23d70a,0x4002b,0x71,0x51c,0x2,0x4002b,0x71, + 0x51d,0x3,0x50036,0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003b,0x478,0x492, + 0x7,0x4003b,0x476,0x491,0x7,0x5003b,0x1ed,0x2cd,0x7,0x1eb,0x4003b,0x1f3, + 0x2ce,0x7,0x5003b,0x1ed,0x2d2,0x7,0x1eb,0x4003d,0x281,0x284,0x283,0x7004f, + 0x131,0x285,0x284,0x284,0x0,0x1,0x4007c,0x29,0x286,0x285,0x3003e,0x2cd, + 0x1eb,0x3003e,0x2d2,0x1eb,0x200f9,0x2da,0x200f8,0x2da,0x700f5,0x28,0x4e0,0xb4, + 0x5,0x2ea,0x2de,0x500b1,0x65,0x2dd,0x4e0,0xc0,0x400f6,0x2eb,0x2de,0x0, + 0x400fa,0x2dd,0x2de,0x2eb,0x200f8,0x2de,0x50041,0x37,0x2e1,0x2cd,0x4e0,0x4003d, + 0x29,0x2e2,0x2e1,0x50080,0x29,0x2e3,0x286,0x2e2,0x4003d,0xcc,0x31c,0xce, + 0x7005f,0x2d,0x31e,0x31c,0x2e3,0x2,0xb4,0x50051,0x6,0x31f,0x31e,0x0, + 0x50041,0x7,0x2e7,0x2ce,0x4e0,0x3003e,0x2e7,0x31f,0x50080,0x28,0x2ea,0x4e0, + 0x162,0x200f9,0x2da,0x200f8,0x2eb,0x50041,0x7,0x2ee,0x2ce,0xb4,0x4003d,0x6, + 0x2ef,0x2ee,0x4003d,0x6,0x2f2,0x2ee,0x200f9,0x2f4,0x200f8,0x2f4,0x700f5,0x6, + 0x4e5,0x2ef,0x2eb,0x4f8,0x315,0x700f5,0x29,0x4e4,0x286,0x2eb,0x4f6,0x315, + 0x700f5,0x6,0x4e3,0x2f2,0x2eb,0x4f4,0x315,0x700f5,0x28,0x4e2,0x162,0x2eb, + 0x317,0x315,0x500b1,0x65,0x2f7,0x4e2,0xc0,0x400f6,0x318,0x315,0x0,0x400fa, + 0x2f7,0x2f8,0x318,0x200f8,0x2f8,0x50041,0x37,0x2fb,0x2d2,0x4e2,0x4003d,0x29, + 0x2fc,0x2fb,0x50080,0x29,0x2fd,0x286,0x2fc,0x50041,0xb5,0x322,0xb3,0xb4, + 0x4003d,0x29,0x323,0x322,0x4007c,0x131,0x328,0x2fd,0x4007c,0x131,0x32a,0x323, + 0x500b0,0x135,0x32b,0x328,0x32a,0x4009b,0x65,0x32c,0x32b,0x300f7,0x314,0x0, + 0x400fa,0x32c,0x301,0x314,0x200f8,0x301,0x50041,0x7,0x303,0x2ce,0x4e2,0x4003d, + 0x6,0x304,0x303,0x500b8,0x65,0x308,0x304,0x4e5,0x300f7,0x313,0x0,0x400fa, + 0x308,0x309,0x313,0x200f8,0x309,0x7000c,0x6,0x331,0x1,0x28,0x4e3,0x304, + 0x200f9,0x313,0x200f8,0x313,0x700f5,0x6,0x4f5,0x4e3,0x301,0x331,0x309,0x600a9, + 0x6,0x50d,0x308,0x304,0x4e5,0x50050,0x135,0x50e,0x308,0x308,0x600a9,0x29, + 0x50f,0x50e,0x2fd,0x4e4,0x200f9,0x314,0x200f8,0x314,0x700f5,0x6,0x4f8,0x4e5, + 0x2f8,0x50d,0x313,0x700f5,0x29,0x4f6,0x4e4,0x2f8,0x50f,0x313,0x700f5,0x6, + 0x4f4,0x4e3,0x2f8,0x4f5,0x313,0x200f9,0x315,0x200f8,0x315,0x50080,0x28,0x317, + 0x4e2,0x162,0x200f9,0x2f4,0x200f8,0x318,0x4003d,0xcc,0x341,0xde,0x7005f,0x2d, + 0x343,0x341,0x4e4,0x2,0xb4,0x7004f,0x12,0x344,0x343,0x343,0x0,0x1, + 0x50041,0xc1,0x34b,0xb3,0x51c,0x4003d,0x12,0x34c,0x34b,0x50085,0x12,0x347, + 0x344,0x34c,0x50041,0xbb,0x3ae,0xb3,0x101,0x4003d,0x2d,0x3af,0x3ae,0x50051, + 0x6,0x3a6,0x3af,0x1,0x50051,0x6,0x3a9,0x3af,0x0,0x50083,0x6,0x3aa, + 0x4e5,0x3a9,0x50088,0x6,0x3ab,0x3a6,0x3aa,0x50041,0xc7,0x3b2,0xb3,0x51d, + 0x4003d,0x6,0x3b3,0x3b2,0x50085,0x6,0x3a0,0x3ab,0x3b3,0x7000c,0x6,0x3b8, + 0x1,0x25,0x3a0,0x18d,0x50085,0x6,0x3c0,0x3b8,0x50c,0x8000c,0x6,0x3c6, + 0x1,0x2b,0x3c0,0x99,0x9a,0x8000c,0x6,0x3cc,0x1,0x2e,0x113,0x114, + 0x3c6,0x50085,0x12,0x3d0,0x347,0x123,0x6000c,0x6,0x3d1,0x1,0x42,0x3d0, + 0x500ba,0x65,0x36a,0x3d1,0x3cc,0x600a9,0x6,0x36b,0x36a,0x9a,0x99,0x5008e, + 0x12,0x36d,0x347,0x36b,0x4006f,0x12,0x36f,0x286,0x50081,0x12,0x371,0x36f, + 0x153,0x50041,0xb5,0x3d4,0xb3,0xb4,0x4003d,0x29,0x3d5,0x3d4,0x4006f,0x12, + 0x373,0x3d5,0x50088,0x12,0x374,0x371,0x373,0x50081,0x12,0x377,0x374,0x36d, + 0x50085,0x12,0x3e3,0x377,0x373,0x50083,0x12,0x3e4,0x3e3,0x153,0x6000c,0x12, + 0x3e6,0x1,0x8,0x3e4,0x4006e,0x29,0x3e7,0x3e6,0x6000c,0x12,0x40f,0x1, + 0xa,0x3e4,0x50051,0x6,0x3f0,0x40f,0x0,0x50083,0x6,0x3f1,0x9a,0x3f0, + 0x50051,0x6,0x3f3,0x40f,0x1,0x50083,0x6,0x3f4,0x9a,0x3f3,0x50085,0x6, + 0x3f5,0x3f1,0x3f4,0x50085,0x6,0x3fc,0x3f0,0x3f4,0x50085,0x6,0x403,0x3f1, + 0x3f3,0x50085,0x6,0x409,0x3f0,0x3f3,0x70050,0x74,0x4df,0x3f5,0x3fc,0x403, + 0x409,0x3003e,0x491,0x50b,0x3003e,0x492,0x4df,0x200f9,0x37b,0x200f8,0x37b,0x700f5, + 0x28,0x4e8,0xb4,0x318,0x398,0x396,0x500b1,0x65,0x37e,0x4e8,0x1b7,0x400f6, + 0x399,0x396,0x0,0x400fa,0x37e,0x37f,0x399,0x200f8,0x37f,0x50041,0x37,0x497, + 0x491,0x4e8,0x4003d,0x29,0x382,0x497,0x50041,0x7,0x498,0x492,0x4e8,0x4003d, + 0x6,0x385,0x498,0x500ba,0x65,0x387,0x385,0x1c2,0x300f7,0x395,0x0,0x400fa, + 0x387,0x388,0x395,0x200f8,0x388,0x50080,0x29,0x38c,0x3e7,0x382,0x4007c,0x131, + 0x417,0x38c,0x4007c,0x131,0x419,0x3d5,0x500b0,0x135,0x41a,0x417,0x419,0x4009b, + 0x65,0x41b,0x41a,0x300f7,0x394,0x0,0x400fa,0x41b,0x390,0x394,0x200f8,0x390, + 0x4007c,0x71,0x41f,0x4e5,0x6003c,0xff,0x422,0xfc,0x38c,0xd2,0x700ed,0x71, + 0x423,0x422,0x101,0xd2,0x41f,0x200f9,0x394,0x200f8,0x394,0x200f9,0x395,0x200f8, + 0x395,0x200f9,0x396,0x200f8,0x396,0x50080,0x28,0x398,0x4e8,0x162,0x200f9,0x37b, + 0x200f8,0x399,0x4003d,0x10a,0x425,0x10c,0x50051,0x6,0x428,0x347,0x0,0x50051, + 0x6,0x429,0x347,0x1,0x70050,0x2d,0x42a,0x428,0x429,0x99,0x99,0x40063, + 0x425,0x286,0x42a,0x4003d,0x103,0x42c,0x105,0x70050,0x2d,0x42f,0x4e5,0x99, + 0x99,0x99,0x40063,0x42c,0x286,0x42f,0x50083,0x6,0x440,0x4e3,0x3a9,0x50088, + 0x6,0x441,0x3a6,0x440,0x50085,0x6,0x436,0x441,0x3b3,0x7000c,0x6,0x44e, + 0x1,0x25,0x436,0x18d,0x4003d,0xea,0x450,0xec,0x70050,0x2d,0x453,0x44e, + 0x99,0x99,0x99,0x40063,0x450,0x286,0x453,0x4003d,0xcc,0x464,0xd6,0x7005f, + 0x2d,0x466,0x464,0x286,0x2,0xb4,0x8004f,0x21,0x467,0x466,0x466,0x0, + 0x1,0x2,0x7000c,0x21,0x46c,0x1,0x28,0x241,0x467,0x50094,0x6,0x470, + 0x46c,0x12c,0x4003d,0xea,0x472,0xf1,0x70050,0x2d,0x475,0x470,0x99,0x99, + 0x99,0x40063,0x472,0x286,0x475,0x100fd,0x10038, +}; +static const char *fu0_prepare_inputs_pass_0_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu0_prepare_inputs_pass_0_cb_bind[] = {8}; +static const uint32_t fu0_prepare_inputs_pass_0_cb_count[] = {1}; +static const uint32_t fu0_prepare_inputs_pass_0_cb_space[] = {0}; +static const char *fu0_prepare_inputs_pass_0_srv_tex_names[] = {"r_input_motion_vectors", "r_input_depth", "r_input_color_jittered"}; +static const uint32_t fu0_prepare_inputs_pass_0_srv_tex_bind[] = {0, 1, 2}; +static const uint32_t fu0_prepare_inputs_pass_0_srv_tex_count[] = {1, 1, 1}; +static const uint32_t fu0_prepare_inputs_pass_0_srv_tex_space[] = {0, 0, 0}; +static const char *fu0_prepare_inputs_pass_0_uav_tex_names[] = {"rw_dilated_motion_vectors", "rw_dilated_depth", "rw_reconstructed_previous_nearest_depth", "rw_farthest_depth", "rw_current_luma"}; +static const uint32_t fu0_prepare_inputs_pass_0_uav_tex_bind[] = {3, 4, 5, 6, 7}; +static const uint32_t fu0_prepare_inputs_pass_0_uav_tex_count[] = {1, 1, 1, 1, 1}; +static const uint32_t fu0_prepare_inputs_pass_0_uav_tex_space[] = {0, 0, 0, 0, 0}; + +static const uint32_t fu0_luma_pyramid_pass_0_spv[10363] = { + 0x7230203,0x10500,0x8000b,0x3beb,0x0,0x20011,0x1,0x20011,0x31,0x20011,0x3d,0x20011, + 0x44,0x6000b,0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0x14000f,0x5, + 0x4,0x6e69616d,0x0,0x15e,0x16c,0x17f,0x189,0x18f,0x198,0x1da,0x221,0x25e, + 0x2ed,0x2f3,0x2f8,0x2fd,0x731,0x733,0x60010,0x4,0x11,0x100,0x1,0x1, + 0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75, + 0x736e6f69,0x0,0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63, + 0x736570,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004, + 0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669,0x90004,0x4b5f4c47,0x735f5248,0x65646168,0x75735f72, + 0x6f726762,0x625f7075,0x63697361,0x0,0x80004,0x4b5f4c47,0x735f5248,0x65646168,0x75735f72,0x6f726762,0x715f7075,0x646175, + 0x40005,0x4,0x6e69616d,0x0,0x70005,0x15c,0x53466263,0x50553352,0x4c414353,0x745f5245,0x0,0x60006, + 0x15c,0x0,0x6e655269,0x53726564,0x657a69,0x60006,0x15c,0x1,0x6c654466,0x69546174,0x656d,0x60005, + 0x15e,0x53466263,0x70553352,0x6c616373,0x7265,0x40005,0x16a,0x50536263,0x745f44,0x50006,0x16a,0x0, + 0x7370696d,0x0,0x70006,0x16a,0x1,0x576d756e,0x476b726f,0x70756f72,0x73,0x70006,0x16a,0x2, + 0x6b726f77,0x756f7247,0x66664f70,0x746573,0x40005,0x16c,0x50536263,0x44,0x70005,0x17f,0x61665f72,0x65687472, + 0x645f7473,0x68747065,0x0,0x80005,0x189,0x665f7772,0x68747261,0x5f747365,0x74706564,0x696d5f68,0x3170,0x60005, + 0x18f,0x75635f72,0x6e657272,0x756c5f74,0x616d,0x60005,0x198,0x665f7772,0x656d6172,0x666e695f,0x6f,0x50005, + 0x1da,0x735f7772,0x6d5f6470,0x357069,0x80005,0x221,0x735f7772,0x675f6470,0x61626f6c,0x74615f6c,0x63696d6f,0x0, + 0x50005,0x25e,0x43647073,0x746e756f,0x7265,0x70005,0x2ed,0x49647073,0x7265746e,0x6964656d,0x52657461,0x0, + 0x70005,0x2f3,0x49647073,0x7265746e,0x6964656d,0x47657461,0x0,0x70005,0x2f8,0x49647073,0x7265746e,0x6964656d, + 0x42657461,0x0,0x70005,0x2fd,0x49647073,0x7265746e,0x6964656d,0x41657461,0x0,0x60005,0x731,0x575f6c67, + 0x476b726f,0x70756f72,0x4449,0x80005,0x733,0x4c5f6c67,0x6c61636f,0x6f766e49,0x69746163,0x6e496e6f,0x786564,0x30047, + 0x15c,0x2,0x50048,0x15c,0x0,0x23,0x0,0x50048,0x15c,0x1,0x23,0x70, + 0x40047,0x15e,0x21,0xb,0x40047,0x15e,0x22,0x0,0x30047,0x16a,0x2,0x50048, + 0x16a,0x0,0x23,0x0,0x50048,0x16a,0x1,0x23,0x4,0x50048,0x16a,0x2, + 0x23,0x8,0x40047,0x16c,0x21,0xc,0x40047,0x16c,0x22,0x0,0x40047,0x17f, + 0x21,0x1,0x40047,0x17f,0x22,0x0,0x40047,0x189,0x21,0xa,0x40047,0x189, + 0x22,0x0,0x40047,0x18f,0x21,0x0,0x40047,0x18f,0x22,0x0,0x40047,0x198, + 0x21,0x3,0x40047,0x198,0x22,0x0,0x30047,0x1da,0x17,0x40047,0x1da,0x21, + 0x9,0x40047,0x1da,0x22,0x0,0x30047,0x221,0x17,0x40047,0x221,0x21,0x2, + 0x40047,0x221,0x22,0x0,0x40047,0x731,0xb,0x1a,0x40047,0x733,0xb,0x1d, + 0x40047,0x746,0xb,0x19,0x20013,0x2,0x30021,0x3,0x2,0x40015,0x6,0x20, + 0x0,0x40015,0x13,0x20,0x1,0x30016,0x1a,0x20,0x40017,0x29,0x6,0x2, + 0x40017,0x2e,0x13,0x2,0x40017,0x4a,0x1a,0x4,0x40017,0x53,0x1a,0x2, + 0x20014,0x9d,0x40017,0x113,0x6,0x3,0x4002b,0x13,0x124,0x0,0x4002b,0x6, + 0x13e,0x2,0x4002b,0x6,0x13f,0x3,0x4002b,0x6,0x145,0x1,0x4001e,0x15c, + 0x2e,0x1a,0x40020,0x15d,0x2,0x15c,0x4003b,0x15d,0x15e,0x2,0x40020,0x15f, + 0x2,0x2e,0x40020,0x165,0x2,0x1a,0x5001e,0x16a,0x6,0x6,0x29,0x40020, + 0x16b,0x2,0x16a,0x4003b,0x16b,0x16c,0x2,0x40020,0x16d,0x2,0x6,0x4002b, + 0x13,0x172,0x1,0x4002b,0x13,0x177,0x2,0x40020,0x178,0x2,0x29,0x90019, + 0x17d,0x1a,0x1,0x0,0x0,0x0,0x1,0x0,0x40020,0x17e,0x0,0x17d, + 0x4003b,0x17e,0x17f,0x0,0x4002b,0x6,0x183,0x0,0x90019,0x187,0x1a,0x1, + 0x0,0x0,0x0,0x2,0x9,0x40020,0x188,0x0,0x187,0x4003b,0x188,0x189, + 0x0,0x4002b,0x1a,0x18d,0x0,0x4003b,0x17e,0x18f,0x0,0x90019,0x196,0x1a, + 0x1,0x0,0x0,0x0,0x2,0x1,0x40020,0x197,0x0,0x196,0x4003b,0x197, + 0x198,0x0,0x5002c,0x2e,0x19a,0x124,0x124,0x90019,0x1a4,0x1a,0x1,0x0, + 0x0,0x0,0x2,0x7,0x40020,0x1a5,0x0,0x1a4,0x4002b,0x6,0x1cb,0x4, + 0x4002b,0x6,0x1d6,0x5,0x4003b,0x1a5,0x1da,0x0,0x90019,0x21f,0x6,0x1, + 0x0,0x0,0x0,0x2,0x21,0x40020,0x220,0x0,0x21f,0x4003b,0x220,0x221, + 0x0,0x40020,0x222,0xb,0x6,0x40017,0x226,0x6,0x4,0x7002c,0x226,0x227, + 0x183,0x183,0x183,0x183,0x4002b,0x1a,0x252,0x40000000,0x4002b,0x1a,0x258,0x3f800000, + 0x40020,0x25d,0x4,0x6,0x4003b,0x25d,0x25e,0x4,0x4002b,0x1a,0x274,0x387fda40, + 0x7002c,0x4a,0x27f,0x18d,0x18d,0x18d,0x18d,0x4002b,0x1a,0x299,0x3e800000,0x40017, + 0x2bb,0x9d,0x2,0x4002b,0x1a,0x2cc,0x461c4000,0x4002b,0x6,0x2e9,0x10,0x4001c, + 0x2ea,0x1a,0x2e9,0x4001c,0x2eb,0x2ea,0x2e9,0x40020,0x2ec,0x4,0x2eb,0x4003b, + 0x2ec,0x2ed,0x4,0x40020,0x2f0,0x4,0x1a,0x4003b,0x2ec,0x2f3,0x4,0x4003b, + 0x2ec,0x2f8,0x4,0x4003b,0x2ec,0x2fd,0x4,0x4002b,0x6,0x319,0xd48,0x4002b, + 0x6,0x31a,0x108,0x5002c,0x29,0x36c,0x183,0x145,0x5002c,0x29,0x36f,0x145, + 0x183,0x5002c,0x29,0x372,0x145,0x145,0x4002b,0x6,0x3bb,0x40,0x4002b,0x6, + 0x3c9,0x20,0x4002b,0x13,0x450,0x3,0x4002b,0x6,0x4a3,0x8,0x4002b,0x6, + 0x5da,0x6,0x4002b,0x6,0x647,0x7,0x4002b,0x13,0x6c4,0x6,0x4002b,0x13, + 0x6cd,0x7,0x40020,0x730,0x1,0x113,0x4003b,0x730,0x731,0x1,0x40020,0x732, + 0x1,0x6,0x4003b,0x732,0x733,0x1,0x4002b,0x6,0x745,0x100,0x6002c,0x113, + 0x746,0x745,0x145,0x145,0x30029,0x9d,0x74c,0x5002c,0x29,0x39ea,0x3bb,0x3bb, + 0x5002c,0x29,0x39eb,0x3c9,0x3c9,0x5002c,0x29,0x39ec,0x2e9,0x2e9,0x5002c,0x29, + 0x39ed,0x4a3,0x4a3,0x5002c,0x29,0x39ee,0x1cb,0x1cb,0x5002c,0x29,0x39ef,0x13e, + 0x13e,0x4002b,0x6,0x39f0,0x9,0x4002b,0x6,0x39f1,0xa,0x4002b,0x6,0x39f2, + 0xb,0x4002b,0x1a,0x39f4,0x41000000,0x4002b,0x1a,0x39f5,0x3f555555,0x5002c,0x2bb,0x39f6, + 0x74c,0x74c,0x50036,0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003d,0x113,0x735, + 0x731,0x4003d,0x6,0x737,0x733,0x7004f,0x29,0x763,0x735,0x735,0x0,0x1, + 0x50041,0x16d,0x76d,0x16c,0x124,0x4003d,0x6,0x76e,0x76d,0x50041,0x16d,0x771, + 0x16c,0x172,0x4003d,0x6,0x772,0x771,0x50041,0x178,0x775,0x16c,0x177,0x4003d, + 0x29,0x776,0x775,0x50080,0x29,0x77f,0x763,0x776,0x300f7,0x7dd,0x0,0x300fb, + 0x183,0x7a7,0x200f8,0x7a7,0x50089,0x6,0x7a9,0x737,0x3bb,0x600cb,0x6,0x800, + 0x7a9,0x177,0x450,0x700c9,0x6,0x807,0x800,0x7a9,0x124,0x172,0x600cb,0x6, + 0x80f,0x7a9,0x450,0x450,0x600cb,0x6,0x817,0x7a9,0x172,0x177,0x700c9,0x6, + 0x81e,0x80f,0x817,0x124,0x177,0x500c2,0x6,0x7ae,0x737,0x6c4,0x50089,0x6, + 0x7af,0x7ae,0x13e,0x50084,0x6,0x7b0,0x4a3,0x7af,0x50080,0x6,0x7b1,0x807, + 0x7b0,0x500c2,0x6,0x7b5,0x737,0x6cd,0x50084,0x6,0x7b6,0x4a3,0x7b5,0x50080, + 0x6,0x7b7,0x81e,0x7b6,0x300f7,0x970,0x0,0x300fb,0x183,0x86a,0x200f8,0x86a, + 0x50084,0x29,0x86d,0x77f,0x39ea,0x4007c,0x2e,0x86e,0x86d,0x50084,0x6,0x870, + 0x7b1,0x13e,0x4007c,0x13,0x871,0x870,0x50084,0x6,0x873,0x7b7,0x13e,0x4007c, + 0x13,0x874,0x873,0x50050,0x2e,0x875,0x871,0x874,0x50080,0x2e,0x876,0x86e, + 0x875,0x50084,0x29,0x879,0x77f,0x39eb,0x4007c,0x2e,0x87a,0x879,0x4007c,0x13, + 0x87c,0x7b1,0x4007c,0x13,0x87e,0x7b7,0x50050,0x2e,0x87f,0x87c,0x87e,0x50080, + 0x2e,0x880,0x87a,0x87f,0x4007c,0x29,0x882,0x876,0x50080,0x29,0x97b,0x882, + 0x36c,0x50080,0x29,0x97d,0x882,0x36f,0x50080,0x29,0x97f,0x882,0x372,0x4006f, + 0x53,0x996,0x876,0x4006e,0x2e,0x9bc,0x996,0x50041,0x15f,0x9cf,0x15e,0x124, + 0x4003d,0x2e,0x9d0,0x9cf,0x50051,0x13,0x9e0,0x9d0,0x0,0x50082,0x13,0x9e1, + 0x9e0,0x172,0x50051,0x13,0x9e3,0x9bc,0x0,0x7000c,0x13,0x9f4,0x1,0x27, + 0x9e3,0x9e1,0x7000c,0x13,0x9f9,0x1,0x2a,0x124,0x9f4,0x50051,0x13,0x9e8, + 0x9d0,0x1,0x50082,0x13,0x9e9,0x9e8,0x172,0x50051,0x13,0x9eb,0x9bc,0x1, + 0x7000c,0x13,0x9fe,0x1,0x27,0x9eb,0x9e9,0x7000c,0x13,0xa03,0x1,0x2a, + 0x124,0x9fe,0x50050,0x2e,0x3bdb,0x9f9,0xa03,0x4003d,0x17d,0xa06,0x18f,0x7005f, + 0x4a,0xa08,0xa06,0x3bdb,0x2,0x124,0x50051,0x1a,0xa09,0xa08,0x0,0x6000c, + 0x1a,0x9c2,0x1,0x1c,0xa09,0x7000c,0x1a,0xa0e,0x1,0x28,0x274,0x9c2, + 0x4003d,0x17d,0xa11,0x17f,0x7005f,0x4a,0xa13,0xa11,0x3bdb,0x2,0x124,0x50051, + 0x1a,0xa14,0xa13,0x0,0x60052,0x4a,0x3a02,0xa0e,0x27f,0x0,0x60052,0x4a, + 0x3a04,0xa09,0x3a02,0x1,0x60052,0x4a,0x3a06,0xa14,0x3a04,0x2,0x4007c,0x2e, + 0x99a,0x97b,0x4006f,0x53,0x99b,0x99a,0x4006e,0x2e,0xa24,0x99b,0x50051,0x13, + 0xa4b,0xa24,0x0,0x7000c,0x13,0xa5c,0x1,0x27,0xa4b,0x9e1,0x7000c,0x13, + 0xa61,0x1,0x2a,0x124,0xa5c,0x50051,0x13,0xa53,0xa24,0x1,0x7000c,0x13, + 0xa66,0x1,0x27,0xa53,0x9e9,0x7000c,0x13,0xa6b,0x1,0x2a,0x124,0xa66, + 0x50050,0x2e,0x3bdc,0xa61,0xa6b,0x4003d,0x17d,0xa6e,0x18f,0x7005f,0x4a,0xa70, + 0xa6e,0x3bdc,0x2,0x124,0x50051,0x1a,0xa71,0xa70,0x0,0x6000c,0x1a,0xa2a, + 0x1,0x1c,0xa71,0x7000c,0x1a,0xa76,0x1,0x28,0x274,0xa2a,0x4003d,0x17d, + 0xa79,0x17f,0x7005f,0x4a,0xa7b,0xa79,0x3bdc,0x2,0x124,0x50051,0x1a,0xa7c, + 0xa7b,0x0,0x60052,0x4a,0x3a10,0xa76,0x27f,0x0,0x60052,0x4a,0x3a12,0xa71, + 0x3a10,0x1,0x60052,0x4a,0x3a14,0xa7c,0x3a12,0x2,0x4007c,0x2e,0x99f,0x97d, + 0x4006f,0x53,0x9a0,0x99f,0x4006e,0x2e,0xa8c,0x9a0,0x50051,0x13,0xab3,0xa8c, + 0x0,0x7000c,0x13,0xac4,0x1,0x27,0xab3,0x9e1,0x7000c,0x13,0xac9,0x1, + 0x2a,0x124,0xac4,0x50051,0x13,0xabb,0xa8c,0x1,0x7000c,0x13,0xace,0x1, + 0x27,0xabb,0x9e9,0x7000c,0x13,0xad3,0x1,0x2a,0x124,0xace,0x50050,0x2e, + 0x3bdd,0xac9,0xad3,0x4003d,0x17d,0xad6,0x18f,0x7005f,0x4a,0xad8,0xad6,0x3bdd, + 0x2,0x124,0x50051,0x1a,0xad9,0xad8,0x0,0x6000c,0x1a,0xa92,0x1,0x1c, + 0xad9,0x7000c,0x1a,0xade,0x1,0x28,0x274,0xa92,0x4003d,0x17d,0xae1,0x17f, + 0x7005f,0x4a,0xae3,0xae1,0x3bdd,0x2,0x124,0x50051,0x1a,0xae4,0xae3,0x0, + 0x60052,0x4a,0x3a1e,0xade,0x27f,0x0,0x60052,0x4a,0x3a20,0xad9,0x3a1e,0x1, + 0x60052,0x4a,0x3a22,0xae4,0x3a20,0x2,0x4007c,0x2e,0x9a4,0x97f,0x4006f,0x53, + 0x9a5,0x9a4,0x4006e,0x2e,0xaf4,0x9a5,0x50051,0x13,0xb1b,0xaf4,0x0,0x7000c, + 0x13,0xb2c,0x1,0x27,0xb1b,0x9e1,0x7000c,0x13,0xb31,0x1,0x2a,0x124, + 0xb2c,0x50051,0x13,0xb23,0xaf4,0x1,0x7000c,0x13,0xb36,0x1,0x27,0xb23, + 0x9e9,0x7000c,0x13,0xb3b,0x1,0x2a,0x124,0xb36,0x50050,0x2e,0x3bde,0xb31, + 0xb3b,0x4003d,0x17d,0xb3e,0x18f,0x7005f,0x4a,0xb40,0xb3e,0x3bde,0x2,0x124, + 0x50051,0x1a,0xb41,0xb40,0x0,0x6000c,0x1a,0xafa,0x1,0x1c,0xb41,0x7000c, + 0x1a,0xb46,0x1,0x28,0x274,0xafa,0x4003d,0x17d,0xb49,0x17f,0x7005f,0x4a, + 0xb4b,0xb49,0x3bde,0x2,0x124,0x50051,0x1a,0xb4c,0xb4b,0x0,0x60052,0x4a, + 0x3a2c,0xb46,0x27f,0x0,0x60052,0x4a,0x3a2e,0xb41,0x3a2c,0x1,0x60052,0x4a, + 0x3a30,0xb4c,0x3a2e,0x2,0x50081,0x4a,0xb51,0x3a06,0x3a14,0x50081,0x4a,0xb53, + 0xb51,0x3a22,0x50081,0x4a,0xb55,0xb53,0x3a30,0x5008e,0x4a,0xb56,0xb55,0x299, + 0x50051,0x1a,0xb73,0xb56,0x2,0x4003d,0x187,0xbe0,0x189,0x70050,0x4a,0xbe3, + 0xb73,0x18d,0x18d,0x18d,0x40063,0xbe0,0x880,0xbe3,0x50082,0x6,0xb79,0x76e, + 0x145,0x500aa,0x9d,0xb7a,0x183,0xb79,0x300f7,0xba1,0x0,0x400fa,0xb7a,0xb7b, + 0xba1,0x200f8,0xb7b,0x500aa,0x2bb,0xb7d,0x880,0x19a,0x4009b,0x9d,0xb7e,0xb7d, + 0x300f7,0xba0,0x0,0x400fa,0xb7e,0xb7f,0xba0,0x200f8,0xb7f,0x4003d,0x196,0xbea, + 0x198,0x50062,0x4a,0xbeb,0xbea,0x19a,0x50051,0x1a,0xb82,0xb56,0x1,0x50051, + 0x1a,0xb84,0xbeb,0x1,0x50051,0x1a,0xb86,0xb56,0x0,0x500b8,0x9d,0xb88, + 0xb84,0x2cc,0x300f7,0xb96,0x0,0x400fa,0xb88,0xb89,0xb96,0x200f8,0xb89,0x50083, + 0x1a,0xb8d,0xb86,0xb84,0x50041,0x165,0xbee,0x15e,0x145,0x4003d,0x1a,0xbef, + 0xbee,0x4007f,0x1a,0xb8f,0xbef,0x6000c,0x1a,0xb90,0x1,0x1b,0xb8f,0x50083, + 0x1a,0xb91,0x258,0xb90,0x50085,0x1a,0xb92,0xb8d,0xb91,0x50081,0x1a,0xb93, + 0xb84,0xb92,0x7000c,0x1a,0xbf4,0x1,0x28,0x18d,0xb93,0x200f9,0xb96,0x200f8, + 0xb96,0x700f5,0x1a,0x2b21,0xb86,0xb7f,0xbf4,0xb89,0x6000c,0x1a,0xbfc,0x1, + 0x1b,0x2b21,0x50085,0x1a,0xbff,0xbfc,0x39f4,0x6000c,0x1a,0xc00,0x1,0x1e, + 0xbff,0x7000c,0x1a,0xc0a,0x1,0x1a,0x252,0xc00,0x50088,0x1a,0xc05,0x39f5, + 0xc0a,0x60052,0x4a,0x3a36,0xc05,0xbeb,0x0,0x60052,0x4a,0x3a38,0x2b21,0x3a36, + 0x1,0x60052,0x4a,0x3a3a,0xb82,0x3a38,0x2,0x4003d,0x196,0xc0c,0x198,0x40063, + 0xc0c,0x19a,0x3a3a,0x200f9,0xba0,0x200f8,0xba0,0x200f9,0xba1,0x200f8,0xba1,0x50080, + 0x6,0x891,0x870,0x3c9,0x4007c,0x13,0x892,0x891,0x50050,0x2e,0x896,0x892, + 0x874,0x50080,0x2e,0x897,0x86e,0x896,0x50080,0x6,0x89d,0x7b1,0x2e9,0x4007c, + 0x13,0x89e,0x89d,0x50050,0x2e,0x8a1,0x89e,0x87e,0x50080,0x2e,0x8a2,0x87a, + 0x8a1,0x4007c,0x29,0x8a4,0x897,0x50080,0x29,0xc18,0x8a4,0x36c,0x50080,0x29, + 0xc1a,0x8a4,0x36f,0x50080,0x29,0xc1c,0x8a4,0x372,0x4006f,0x53,0xc33,0x897, + 0x4006e,0x2e,0xc59,0xc33,0x50051,0x13,0xc80,0xc59,0x0,0x7000c,0x13,0xc91, + 0x1,0x27,0xc80,0x9e1,0x7000c,0x13,0xc96,0x1,0x2a,0x124,0xc91,0x50051, + 0x13,0xc88,0xc59,0x1,0x7000c,0x13,0xc9b,0x1,0x27,0xc88,0x9e9,0x7000c, + 0x13,0xca0,0x1,0x2a,0x124,0xc9b,0x50050,0x2e,0x3bdf,0xc96,0xca0,0x4003d, + 0x17d,0xca3,0x18f,0x7005f,0x4a,0xca5,0xca3,0x3bdf,0x2,0x124,0x50051,0x1a, + 0xca6,0xca5,0x0,0x6000c,0x1a,0xc5f,0x1,0x1c,0xca6,0x7000c,0x1a,0xcab, + 0x1,0x28,0x274,0xc5f,0x4003d,0x17d,0xcae,0x17f,0x7005f,0x4a,0xcb0,0xcae, + 0x3bdf,0x2,0x124,0x50051,0x1a,0xcb1,0xcb0,0x0,0x60052,0x4a,0x3a44,0xcab, + 0x27f,0x0,0x60052,0x4a,0x3a46,0xca6,0x3a44,0x1,0x60052,0x4a,0x3a48,0xcb1, + 0x3a46,0x2,0x4007c,0x2e,0xc37,0xc18,0x4006f,0x53,0xc38,0xc37,0x4006e,0x2e, + 0xcc1,0xc38,0x50051,0x13,0xce8,0xcc1,0x0,0x7000c,0x13,0xcf9,0x1,0x27, + 0xce8,0x9e1,0x7000c,0x13,0xcfe,0x1,0x2a,0x124,0xcf9,0x50051,0x13,0xcf0, + 0xcc1,0x1,0x7000c,0x13,0xd03,0x1,0x27,0xcf0,0x9e9,0x7000c,0x13,0xd08, + 0x1,0x2a,0x124,0xd03,0x50050,0x2e,0x3be0,0xcfe,0xd08,0x4003d,0x17d,0xd0b, + 0x18f,0x7005f,0x4a,0xd0d,0xd0b,0x3be0,0x2,0x124,0x50051,0x1a,0xd0e,0xd0d, + 0x0,0x6000c,0x1a,0xcc7,0x1,0x1c,0xd0e,0x7000c,0x1a,0xd13,0x1,0x28, + 0x274,0xcc7,0x4003d,0x17d,0xd16,0x17f,0x7005f,0x4a,0xd18,0xd16,0x3be0,0x2, + 0x124,0x50051,0x1a,0xd19,0xd18,0x0,0x60052,0x4a,0x3a52,0xd13,0x27f,0x0, + 0x60052,0x4a,0x3a54,0xd0e,0x3a52,0x1,0x60052,0x4a,0x3a56,0xd19,0x3a54,0x2, + 0x4007c,0x2e,0xc3c,0xc1a,0x4006f,0x53,0xc3d,0xc3c,0x4006e,0x2e,0xd29,0xc3d, + 0x50051,0x13,0xd50,0xd29,0x0,0x7000c,0x13,0xd61,0x1,0x27,0xd50,0x9e1, + 0x7000c,0x13,0xd66,0x1,0x2a,0x124,0xd61,0x50051,0x13,0xd58,0xd29,0x1, + 0x7000c,0x13,0xd6b,0x1,0x27,0xd58,0x9e9,0x7000c,0x13,0xd70,0x1,0x2a, + 0x124,0xd6b,0x50050,0x2e,0x3be1,0xd66,0xd70,0x4003d,0x17d,0xd73,0x18f,0x7005f, + 0x4a,0xd75,0xd73,0x3be1,0x2,0x124,0x50051,0x1a,0xd76,0xd75,0x0,0x6000c, + 0x1a,0xd2f,0x1,0x1c,0xd76,0x7000c,0x1a,0xd7b,0x1,0x28,0x274,0xd2f, + 0x4003d,0x17d,0xd7e,0x17f,0x7005f,0x4a,0xd80,0xd7e,0x3be1,0x2,0x124,0x50051, + 0x1a,0xd81,0xd80,0x0,0x60052,0x4a,0x3a60,0xd7b,0x27f,0x0,0x60052,0x4a, + 0x3a62,0xd76,0x3a60,0x1,0x60052,0x4a,0x3a64,0xd81,0x3a62,0x2,0x4007c,0x2e, + 0xc41,0xc1c,0x4006f,0x53,0xc42,0xc41,0x4006e,0x2e,0xd91,0xc42,0x50051,0x13, + 0xdb8,0xd91,0x0,0x7000c,0x13,0xdc9,0x1,0x27,0xdb8,0x9e1,0x7000c,0x13, + 0xdce,0x1,0x2a,0x124,0xdc9,0x50051,0x13,0xdc0,0xd91,0x1,0x7000c,0x13, + 0xdd3,0x1,0x27,0xdc0,0x9e9,0x7000c,0x13,0xdd8,0x1,0x2a,0x124,0xdd3, + 0x50050,0x2e,0x3be2,0xdce,0xdd8,0x4003d,0x17d,0xddb,0x18f,0x7005f,0x4a,0xddd, + 0xddb,0x3be2,0x2,0x124,0x50051,0x1a,0xdde,0xddd,0x0,0x6000c,0x1a,0xd97, + 0x1,0x1c,0xdde,0x7000c,0x1a,0xde3,0x1,0x28,0x274,0xd97,0x4003d,0x17d, + 0xde6,0x17f,0x7005f,0x4a,0xde8,0xde6,0x3be2,0x2,0x124,0x50051,0x1a,0xde9, + 0xde8,0x0,0x60052,0x4a,0x3a6e,0xde3,0x27f,0x0,0x60052,0x4a,0x3a70,0xdde, + 0x3a6e,0x1,0x60052,0x4a,0x3a72,0xde9,0x3a70,0x2,0x50081,0x4a,0xdee,0x3a48, + 0x3a56,0x50081,0x4a,0xdf0,0xdee,0x3a64,0x50081,0x4a,0xdf2,0xdf0,0x3a72,0x5008e, + 0x4a,0xdf3,0xdf2,0x299,0x50051,0x1a,0xe10,0xdf3,0x2,0x4003d,0x187,0xe7d, + 0x189,0x70050,0x4a,0xe80,0xe10,0x18d,0x18d,0x18d,0x40063,0xe7d,0x8a2,0xe80, + 0x300f7,0xe3e,0x0,0x400fa,0xb7a,0xe18,0xe3e,0x200f8,0xe18,0x500aa,0x2bb,0xe1a, + 0x8a2,0x19a,0x4009b,0x9d,0xe1b,0xe1a,0x300f7,0xe3d,0x0,0x400fa,0xe1b,0xe1c, + 0xe3d,0x200f8,0xe1c,0x4003d,0x196,0xe87,0x198,0x50062,0x4a,0xe88,0xe87,0x19a, + 0x50051,0x1a,0xe1f,0xdf3,0x1,0x50051,0x1a,0xe21,0xe88,0x1,0x50051,0x1a, + 0xe23,0xdf3,0x0,0x500b8,0x9d,0xe25,0xe21,0x2cc,0x300f7,0xe33,0x0,0x400fa, + 0xe25,0xe26,0xe33,0x200f8,0xe26,0x50083,0x1a,0xe2a,0xe23,0xe21,0x50041,0x165, + 0xe8b,0x15e,0x145,0x4003d,0x1a,0xe8c,0xe8b,0x4007f,0x1a,0xe2c,0xe8c,0x6000c, + 0x1a,0xe2d,0x1,0x1b,0xe2c,0x50083,0x1a,0xe2e,0x258,0xe2d,0x50085,0x1a, + 0xe2f,0xe2a,0xe2e,0x50081,0x1a,0xe30,0xe21,0xe2f,0x7000c,0x1a,0xe91,0x1, + 0x28,0x18d,0xe30,0x200f9,0xe33,0x200f8,0xe33,0x700f5,0x1a,0x2b6e,0xe23,0xe1c, + 0xe91,0xe26,0x6000c,0x1a,0xe99,0x1,0x1b,0x2b6e,0x50085,0x1a,0xe9c,0xe99, + 0x39f4,0x6000c,0x1a,0xe9d,0x1,0x1e,0xe9c,0x7000c,0x1a,0xea7,0x1,0x1a, + 0x252,0xe9d,0x50088,0x1a,0xea2,0x39f5,0xea7,0x60052,0x4a,0x3a78,0xea2,0xe88, + 0x0,0x60052,0x4a,0x3a7a,0x2b6e,0x3a78,0x1,0x60052,0x4a,0x3a7c,0xe1f,0x3a7a, + 0x2,0x4003d,0x196,0xea9,0x198,0x40063,0xea9,0x19a,0x3a7c,0x200f9,0xe3d,0x200f8, + 0xe3d,0x200f9,0xe3e,0x200f8,0xe3e,0x50080,0x6,0x8b6,0x873,0x3c9,0x4007c,0x13, + 0x8b7,0x8b6,0x50050,0x2e,0x8b8,0x871,0x8b7,0x50080,0x2e,0x8b9,0x86e,0x8b8, + 0x50080,0x6,0x8c1,0x7b7,0x2e9,0x4007c,0x13,0x8c2,0x8c1,0x50050,0x2e,0x8c3, + 0x87c,0x8c2,0x50080,0x2e,0x8c4,0x87a,0x8c3,0x4007c,0x29,0x8c6,0x8b9,0x50080, + 0x29,0xeb5,0x8c6,0x36c,0x50080,0x29,0xeb7,0x8c6,0x36f,0x50080,0x29,0xeb9, + 0x8c6,0x372,0x4006f,0x53,0xed0,0x8b9,0x4006e,0x2e,0xef6,0xed0,0x50051,0x13, + 0xf1d,0xef6,0x0,0x7000c,0x13,0xf2e,0x1,0x27,0xf1d,0x9e1,0x7000c,0x13, + 0xf33,0x1,0x2a,0x124,0xf2e,0x50051,0x13,0xf25,0xef6,0x1,0x7000c,0x13, + 0xf38,0x1,0x27,0xf25,0x9e9,0x7000c,0x13,0xf3d,0x1,0x2a,0x124,0xf38, + 0x50050,0x2e,0x3be3,0xf33,0xf3d,0x4003d,0x17d,0xf40,0x18f,0x7005f,0x4a,0xf42, + 0xf40,0x3be3,0x2,0x124,0x50051,0x1a,0xf43,0xf42,0x0,0x6000c,0x1a,0xefc, + 0x1,0x1c,0xf43,0x7000c,0x1a,0xf48,0x1,0x28,0x274,0xefc,0x4003d,0x17d, + 0xf4b,0x17f,0x7005f,0x4a,0xf4d,0xf4b,0x3be3,0x2,0x124,0x50051,0x1a,0xf4e, + 0xf4d,0x0,0x60052,0x4a,0x3a86,0xf48,0x27f,0x0,0x60052,0x4a,0x3a88,0xf43, + 0x3a86,0x1,0x60052,0x4a,0x3a8a,0xf4e,0x3a88,0x2,0x4007c,0x2e,0xed4,0xeb5, + 0x4006f,0x53,0xed5,0xed4,0x4006e,0x2e,0xf5e,0xed5,0x50051,0x13,0xf85,0xf5e, + 0x0,0x7000c,0x13,0xf96,0x1,0x27,0xf85,0x9e1,0x7000c,0x13,0xf9b,0x1, + 0x2a,0x124,0xf96,0x50051,0x13,0xf8d,0xf5e,0x1,0x7000c,0x13,0xfa0,0x1, + 0x27,0xf8d,0x9e9,0x7000c,0x13,0xfa5,0x1,0x2a,0x124,0xfa0,0x50050,0x2e, + 0x3be4,0xf9b,0xfa5,0x4003d,0x17d,0xfa8,0x18f,0x7005f,0x4a,0xfaa,0xfa8,0x3be4, + 0x2,0x124,0x50051,0x1a,0xfab,0xfaa,0x0,0x6000c,0x1a,0xf64,0x1,0x1c, + 0xfab,0x7000c,0x1a,0xfb0,0x1,0x28,0x274,0xf64,0x4003d,0x17d,0xfb3,0x17f, + 0x7005f,0x4a,0xfb5,0xfb3,0x3be4,0x2,0x124,0x50051,0x1a,0xfb6,0xfb5,0x0, + 0x60052,0x4a,0x3a94,0xfb0,0x27f,0x0,0x60052,0x4a,0x3a96,0xfab,0x3a94,0x1, + 0x60052,0x4a,0x3a98,0xfb6,0x3a96,0x2,0x4007c,0x2e,0xed9,0xeb7,0x4006f,0x53, + 0xeda,0xed9,0x4006e,0x2e,0xfc6,0xeda,0x50051,0x13,0xfed,0xfc6,0x0,0x7000c, + 0x13,0xffe,0x1,0x27,0xfed,0x9e1,0x7000c,0x13,0x1003,0x1,0x2a,0x124, + 0xffe,0x50051,0x13,0xff5,0xfc6,0x1,0x7000c,0x13,0x1008,0x1,0x27,0xff5, + 0x9e9,0x7000c,0x13,0x100d,0x1,0x2a,0x124,0x1008,0x50050,0x2e,0x3be5,0x1003, + 0x100d,0x4003d,0x17d,0x1010,0x18f,0x7005f,0x4a,0x1012,0x1010,0x3be5,0x2,0x124, + 0x50051,0x1a,0x1013,0x1012,0x0,0x6000c,0x1a,0xfcc,0x1,0x1c,0x1013,0x7000c, + 0x1a,0x1018,0x1,0x28,0x274,0xfcc,0x4003d,0x17d,0x101b,0x17f,0x7005f,0x4a, + 0x101d,0x101b,0x3be5,0x2,0x124,0x50051,0x1a,0x101e,0x101d,0x0,0x60052,0x4a, + 0x3aa2,0x1018,0x27f,0x0,0x60052,0x4a,0x3aa4,0x1013,0x3aa2,0x1,0x60052,0x4a, + 0x3aa6,0x101e,0x3aa4,0x2,0x4007c,0x2e,0xede,0xeb9,0x4006f,0x53,0xedf,0xede, + 0x4006e,0x2e,0x102e,0xedf,0x50051,0x13,0x1055,0x102e,0x0,0x7000c,0x13,0x1066, + 0x1,0x27,0x1055,0x9e1,0x7000c,0x13,0x106b,0x1,0x2a,0x124,0x1066,0x50051, + 0x13,0x105d,0x102e,0x1,0x7000c,0x13,0x1070,0x1,0x27,0x105d,0x9e9,0x7000c, + 0x13,0x1075,0x1,0x2a,0x124,0x1070,0x50050,0x2e,0x3be6,0x106b,0x1075,0x4003d, + 0x17d,0x1078,0x18f,0x7005f,0x4a,0x107a,0x1078,0x3be6,0x2,0x124,0x50051,0x1a, + 0x107b,0x107a,0x0,0x6000c,0x1a,0x1034,0x1,0x1c,0x107b,0x7000c,0x1a,0x1080, + 0x1,0x28,0x274,0x1034,0x4003d,0x17d,0x1083,0x17f,0x7005f,0x4a,0x1085,0x1083, + 0x3be6,0x2,0x124,0x50051,0x1a,0x1086,0x1085,0x0,0x60052,0x4a,0x3ab0,0x1080, + 0x27f,0x0,0x60052,0x4a,0x3ab2,0x107b,0x3ab0,0x1,0x60052,0x4a,0x3ab4,0x1086, + 0x3ab2,0x2,0x50081,0x4a,0x108b,0x3a8a,0x3a98,0x50081,0x4a,0x108d,0x108b,0x3aa6, + 0x50081,0x4a,0x108f,0x108d,0x3ab4,0x5008e,0x4a,0x1090,0x108f,0x299,0x50051,0x1a, + 0x10ad,0x1090,0x2,0x4003d,0x187,0x111a,0x189,0x70050,0x4a,0x111d,0x10ad,0x18d, + 0x18d,0x18d,0x40063,0x111a,0x8c4,0x111d,0x300f7,0x10db,0x0,0x400fa,0xb7a,0x10b5, + 0x10db,0x200f8,0x10b5,0x500aa,0x2bb,0x10b7,0x8c4,0x19a,0x4009b,0x9d,0x10b8,0x10b7, + 0x300f7,0x10da,0x0,0x400fa,0x10b8,0x10b9,0x10da,0x200f8,0x10b9,0x4003d,0x196,0x1124, + 0x198,0x50062,0x4a,0x1125,0x1124,0x19a,0x50051,0x1a,0x10bc,0x1090,0x1,0x50051, + 0x1a,0x10be,0x1125,0x1,0x50051,0x1a,0x10c0,0x1090,0x0,0x500b8,0x9d,0x10c2, + 0x10be,0x2cc,0x300f7,0x10d0,0x0,0x400fa,0x10c2,0x10c3,0x10d0,0x200f8,0x10c3,0x50083, + 0x1a,0x10c7,0x10c0,0x10be,0x50041,0x165,0x1128,0x15e,0x145,0x4003d,0x1a,0x1129, + 0x1128,0x4007f,0x1a,0x10c9,0x1129,0x6000c,0x1a,0x10ca,0x1,0x1b,0x10c9,0x50083, + 0x1a,0x10cb,0x258,0x10ca,0x50085,0x1a,0x10cc,0x10c7,0x10cb,0x50081,0x1a,0x10cd, + 0x10be,0x10cc,0x7000c,0x1a,0x112e,0x1,0x28,0x18d,0x10cd,0x200f9,0x10d0,0x200f8, + 0x10d0,0x700f5,0x1a,0x2bbb,0x10c0,0x10b9,0x112e,0x10c3,0x6000c,0x1a,0x1136,0x1, + 0x1b,0x2bbb,0x50085,0x1a,0x1139,0x1136,0x39f4,0x6000c,0x1a,0x113a,0x1,0x1e, + 0x1139,0x7000c,0x1a,0x1144,0x1,0x1a,0x252,0x113a,0x50088,0x1a,0x113f,0x39f5, + 0x1144,0x60052,0x4a,0x3aba,0x113f,0x1125,0x0,0x60052,0x4a,0x3abc,0x2bbb,0x3aba, + 0x1,0x60052,0x4a,0x3abe,0x10bc,0x3abc,0x2,0x4003d,0x196,0x1146,0x198,0x40063, + 0x1146,0x19a,0x3abe,0x200f9,0x10da,0x200f8,0x10da,0x200f9,0x10db,0x200f8,0x10db,0x50050, + 0x2e,0x8db,0x892,0x8b7,0x50080,0x2e,0x8dc,0x86e,0x8db,0x50050,0x2e,0x8e7, + 0x89e,0x8c2,0x50080,0x2e,0x8e8,0x87a,0x8e7,0x4007c,0x29,0x8ea,0x8dc,0x50080, + 0x29,0x1152,0x8ea,0x36c,0x50080,0x29,0x1154,0x8ea,0x36f,0x50080,0x29,0x1156, + 0x8ea,0x372,0x4006f,0x53,0x116d,0x8dc,0x4006e,0x2e,0x1193,0x116d,0x50051,0x13, + 0x11ba,0x1193,0x0,0x7000c,0x13,0x11cb,0x1,0x27,0x11ba,0x9e1,0x7000c,0x13, + 0x11d0,0x1,0x2a,0x124,0x11cb,0x50051,0x13,0x11c2,0x1193,0x1,0x7000c,0x13, + 0x11d5,0x1,0x27,0x11c2,0x9e9,0x7000c,0x13,0x11da,0x1,0x2a,0x124,0x11d5, + 0x50050,0x2e,0x3be7,0x11d0,0x11da,0x4003d,0x17d,0x11dd,0x18f,0x7005f,0x4a,0x11df, + 0x11dd,0x3be7,0x2,0x124,0x50051,0x1a,0x11e0,0x11df,0x0,0x6000c,0x1a,0x1199, + 0x1,0x1c,0x11e0,0x7000c,0x1a,0x11e5,0x1,0x28,0x274,0x1199,0x4003d,0x17d, + 0x11e8,0x17f,0x7005f,0x4a,0x11ea,0x11e8,0x3be7,0x2,0x124,0x50051,0x1a,0x11eb, + 0x11ea,0x0,0x60052,0x4a,0x3ac8,0x11e5,0x27f,0x0,0x60052,0x4a,0x3aca,0x11e0, + 0x3ac8,0x1,0x60052,0x4a,0x3acc,0x11eb,0x3aca,0x2,0x4007c,0x2e,0x1171,0x1152, + 0x4006f,0x53,0x1172,0x1171,0x4006e,0x2e,0x11fb,0x1172,0x50051,0x13,0x1222,0x11fb, + 0x0,0x7000c,0x13,0x1233,0x1,0x27,0x1222,0x9e1,0x7000c,0x13,0x1238,0x1, + 0x2a,0x124,0x1233,0x50051,0x13,0x122a,0x11fb,0x1,0x7000c,0x13,0x123d,0x1, + 0x27,0x122a,0x9e9,0x7000c,0x13,0x1242,0x1,0x2a,0x124,0x123d,0x50050,0x2e, + 0x3be8,0x1238,0x1242,0x4003d,0x17d,0x1245,0x18f,0x7005f,0x4a,0x1247,0x1245,0x3be8, + 0x2,0x124,0x50051,0x1a,0x1248,0x1247,0x0,0x6000c,0x1a,0x1201,0x1,0x1c, + 0x1248,0x7000c,0x1a,0x124d,0x1,0x28,0x274,0x1201,0x4003d,0x17d,0x1250,0x17f, + 0x7005f,0x4a,0x1252,0x1250,0x3be8,0x2,0x124,0x50051,0x1a,0x1253,0x1252,0x0, + 0x60052,0x4a,0x3ad6,0x124d,0x27f,0x0,0x60052,0x4a,0x3ad8,0x1248,0x3ad6,0x1, + 0x60052,0x4a,0x3ada,0x1253,0x3ad8,0x2,0x4007c,0x2e,0x1176,0x1154,0x4006f,0x53, + 0x1177,0x1176,0x4006e,0x2e,0x1263,0x1177,0x50051,0x13,0x128a,0x1263,0x0,0x7000c, + 0x13,0x129b,0x1,0x27,0x128a,0x9e1,0x7000c,0x13,0x12a0,0x1,0x2a,0x124, + 0x129b,0x50051,0x13,0x1292,0x1263,0x1,0x7000c,0x13,0x12a5,0x1,0x27,0x1292, + 0x9e9,0x7000c,0x13,0x12aa,0x1,0x2a,0x124,0x12a5,0x50050,0x2e,0x3be9,0x12a0, + 0x12aa,0x4003d,0x17d,0x12ad,0x18f,0x7005f,0x4a,0x12af,0x12ad,0x3be9,0x2,0x124, + 0x50051,0x1a,0x12b0,0x12af,0x0,0x6000c,0x1a,0x1269,0x1,0x1c,0x12b0,0x7000c, + 0x1a,0x12b5,0x1,0x28,0x274,0x1269,0x4003d,0x17d,0x12b8,0x17f,0x7005f,0x4a, + 0x12ba,0x12b8,0x3be9,0x2,0x124,0x50051,0x1a,0x12bb,0x12ba,0x0,0x60052,0x4a, + 0x3ae4,0x12b5,0x27f,0x0,0x60052,0x4a,0x3ae6,0x12b0,0x3ae4,0x1,0x60052,0x4a, + 0x3ae8,0x12bb,0x3ae6,0x2,0x4007c,0x2e,0x117b,0x1156,0x4006f,0x53,0x117c,0x117b, + 0x4006e,0x2e,0x12cb,0x117c,0x50051,0x13,0x12f2,0x12cb,0x0,0x7000c,0x13,0x1303, + 0x1,0x27,0x12f2,0x9e1,0x7000c,0x13,0x1308,0x1,0x2a,0x124,0x1303,0x50051, + 0x13,0x12fa,0x12cb,0x1,0x7000c,0x13,0x130d,0x1,0x27,0x12fa,0x9e9,0x7000c, + 0x13,0x1312,0x1,0x2a,0x124,0x130d,0x50050,0x2e,0x3bea,0x1308,0x1312,0x4003d, + 0x17d,0x1315,0x18f,0x7005f,0x4a,0x1317,0x1315,0x3bea,0x2,0x124,0x50051,0x1a, + 0x1318,0x1317,0x0,0x6000c,0x1a,0x12d1,0x1,0x1c,0x1318,0x7000c,0x1a,0x131d, + 0x1,0x28,0x274,0x12d1,0x4003d,0x17d,0x1320,0x17f,0x7005f,0x4a,0x1322,0x1320, + 0x3bea,0x2,0x124,0x50051,0x1a,0x1323,0x1322,0x0,0x60052,0x4a,0x3af2,0x131d, + 0x27f,0x0,0x60052,0x4a,0x3af4,0x1318,0x3af2,0x1,0x60052,0x4a,0x3af6,0x1323, + 0x3af4,0x2,0x50081,0x4a,0x1328,0x3acc,0x3ada,0x50081,0x4a,0x132a,0x1328,0x3ae8, + 0x50081,0x4a,0x132c,0x132a,0x3af6,0x5008e,0x4a,0x132d,0x132c,0x299,0x50051,0x1a, + 0x134a,0x132d,0x2,0x4003d,0x187,0x13b7,0x189,0x70050,0x4a,0x13ba,0x134a,0x18d, + 0x18d,0x18d,0x40063,0x13b7,0x8e8,0x13ba,0x300f7,0x1378,0x0,0x400fa,0xb7a,0x1352, + 0x1378,0x200f8,0x1352,0x500aa,0x2bb,0x1354,0x8e8,0x19a,0x4009b,0x9d,0x1355,0x1354, + 0x300f7,0x1377,0x0,0x400fa,0x1355,0x1356,0x1377,0x200f8,0x1356,0x4003d,0x196,0x13c1, + 0x198,0x50062,0x4a,0x13c2,0x13c1,0x19a,0x50051,0x1a,0x1359,0x132d,0x1,0x50051, + 0x1a,0x135b,0x13c2,0x1,0x50051,0x1a,0x135d,0x132d,0x0,0x500b8,0x9d,0x135f, + 0x135b,0x2cc,0x300f7,0x136d,0x0,0x400fa,0x135f,0x1360,0x136d,0x200f8,0x1360,0x50083, + 0x1a,0x1364,0x135d,0x135b,0x50041,0x165,0x13c5,0x15e,0x145,0x4003d,0x1a,0x13c6, + 0x13c5,0x4007f,0x1a,0x1366,0x13c6,0x6000c,0x1a,0x1367,0x1,0x1b,0x1366,0x50083, + 0x1a,0x1368,0x258,0x1367,0x50085,0x1a,0x1369,0x1364,0x1368,0x50081,0x1a,0x136a, + 0x135b,0x1369,0x7000c,0x1a,0x13cb,0x1,0x28,0x18d,0x136a,0x200f9,0x136d,0x200f8, + 0x136d,0x700f5,0x1a,0x2c08,0x135d,0x1356,0x13cb,0x1360,0x6000c,0x1a,0x13d3,0x1, + 0x1b,0x2c08,0x50085,0x1a,0x13d6,0x13d3,0x39f4,0x6000c,0x1a,0x13d7,0x1,0x1e, + 0x13d6,0x7000c,0x1a,0x13e1,0x1,0x1a,0x252,0x13d7,0x50088,0x1a,0x13dc,0x39f5, + 0x13e1,0x60052,0x4a,0x3afc,0x13dc,0x13c2,0x0,0x60052,0x4a,0x3afe,0x2c08,0x3afc, + 0x1,0x60052,0x4a,0x3b00,0x1359,0x3afe,0x2,0x4003d,0x196,0x13e3,0x198,0x40063, + 0x13e3,0x19a,0x3b00,0x200f9,0x1377,0x200f8,0x1377,0x200f9,0x1378,0x200f8,0x1378,0x500b2, + 0x9d,0x8f4,0x76e,0x145,0x300f7,0x8f6,0x0,0x400fa,0x8f4,0x8f5,0x8f6,0x200f8, + 0x8f5,0x200f9,0x970,0x200f8,0x8f6,0x6016e,0x4a,0x13f1,0x13f,0xb56,0x183,0x6016e, + 0x4a,0x13f3,0x13f,0xb56,0x145,0x6016e,0x4a,0x13f5,0x13f,0xb56,0x13e,0x50081, + 0x4a,0x13ff,0xb56,0x13f1,0x50081,0x4a,0x1401,0x13ff,0x13f3,0x50081,0x4a,0x1403, + 0x1401,0x13f5,0x5008e,0x4a,0x1404,0x1403,0x299,0x6016e,0x4a,0x1411,0x13f,0xdf3, + 0x183,0x6016e,0x4a,0x1413,0x13f,0xdf3,0x145,0x6016e,0x4a,0x1415,0x13f,0xdf3, + 0x13e,0x50081,0x4a,0x141f,0xdf3,0x1411,0x50081,0x4a,0x1421,0x141f,0x1413,0x50081, + 0x4a,0x1423,0x1421,0x1415,0x5008e,0x4a,0x1424,0x1423,0x299,0x6016e,0x4a,0x1431, + 0x13f,0x1090,0x183,0x6016e,0x4a,0x1433,0x13f,0x1090,0x145,0x6016e,0x4a,0x1435, + 0x13f,0x1090,0x13e,0x50081,0x4a,0x143f,0x1090,0x1431,0x50081,0x4a,0x1441,0x143f, + 0x1433,0x50081,0x4a,0x1443,0x1441,0x1435,0x5008e,0x4a,0x1444,0x1443,0x299,0x6016e, + 0x4a,0x1451,0x13f,0x132d,0x183,0x6016e,0x4a,0x1453,0x13f,0x132d,0x145,0x6016e, + 0x4a,0x1455,0x13f,0x132d,0x13e,0x50081,0x4a,0x145f,0x132d,0x1451,0x50081,0x4a, + 0x1461,0x145f,0x1453,0x50081,0x4a,0x1463,0x1461,0x1455,0x5008e,0x4a,0x1464,0x1463, + 0x299,0x50089,0x6,0x908,0x737,0x1cb,0x500aa,0x9d,0x909,0x908,0x183,0x300f7, + 0x96f,0x0,0x400fa,0x909,0x90a,0x96f,0x200f8,0x90a,0x50084,0x29,0x90d,0x77f, + 0x39ec,0x4007c,0x2e,0x90e,0x90d,0x50086,0x6,0x910,0x7b1,0x13e,0x4007c,0x13, + 0x911,0x910,0x50086,0x6,0x913,0x7b7,0x13e,0x4007c,0x13,0x914,0x913,0x50050, + 0x2e,0x915,0x911,0x914,0x50080,0x2e,0x916,0x90e,0x915,0x500aa,0x9d,0x1488, + 0x145,0xb79,0x300f7,0x14af,0x0,0x400fa,0x1488,0x1489,0x14af,0x200f8,0x1489,0x500aa, + 0x2bb,0x148b,0x916,0x19a,0x4009b,0x9d,0x148c,0x148b,0x300f7,0x14ae,0x0,0x400fa, + 0x148c,0x148d,0x14ae,0x200f8,0x148d,0x4003d,0x196,0x14f8,0x198,0x50062,0x4a,0x14f9, + 0x14f8,0x19a,0x50051,0x1a,0x1490,0x1404,0x1,0x50051,0x1a,0x1492,0x14f9,0x1, + 0x50051,0x1a,0x1494,0x1404,0x0,0x500b8,0x9d,0x1496,0x1492,0x2cc,0x300f7,0x14a4, + 0x0,0x400fa,0x1496,0x1497,0x14a4,0x200f8,0x1497,0x50083,0x1a,0x149b,0x1494,0x1492, + 0x50041,0x165,0x14fc,0x15e,0x145,0x4003d,0x1a,0x14fd,0x14fc,0x4007f,0x1a,0x149d, + 0x14fd,0x6000c,0x1a,0x149e,0x1,0x1b,0x149d,0x50083,0x1a,0x149f,0x258,0x149e, + 0x50085,0x1a,0x14a0,0x149b,0x149f,0x50081,0x1a,0x14a1,0x1492,0x14a0,0x7000c,0x1a, + 0x1502,0x1,0x28,0x18d,0x14a1,0x200f9,0x14a4,0x200f8,0x14a4,0x700f5,0x1a,0x2d1b, + 0x1494,0x148d,0x1502,0x1497,0x6000c,0x1a,0x150a,0x1,0x1b,0x2d1b,0x50085,0x1a, + 0x150d,0x150a,0x39f4,0x6000c,0x1a,0x150e,0x1,0x1e,0x150d,0x7000c,0x1a,0x1518, + 0x1,0x1a,0x252,0x150e,0x50088,0x1a,0x1513,0x39f5,0x1518,0x60052,0x4a,0x3b05, + 0x1513,0x14f9,0x0,0x60052,0x4a,0x3b07,0x2d1b,0x3b05,0x1,0x60052,0x4a,0x3b09, + 0x1490,0x3b07,0x2,0x4003d,0x196,0x151a,0x198,0x40063,0x151a,0x19a,0x3b09,0x200f9, + 0x14ae,0x200f8,0x14ae,0x200f9,0x14af,0x200f8,0x14af,0x50051,0x1a,0x1520,0x1404,0x0, + 0x60041,0x2f0,0x1521,0x2ed,0x910,0x913,0x3003e,0x1521,0x1520,0x50051,0x1a,0x1525, + 0x1404,0x1,0x60041,0x2f0,0x1526,0x2f3,0x910,0x913,0x3003e,0x1526,0x1525,0x50051, + 0x1a,0x152a,0x1404,0x2,0x60041,0x2f0,0x152b,0x2f8,0x910,0x913,0x3003e,0x152b, + 0x152a,0x50051,0x1a,0x152f,0x1404,0x3,0x60041,0x2f0,0x1530,0x2fd,0x910,0x913, + 0x3003e,0x1530,0x152f,0x50080,0x6,0x928,0x910,0x4a3,0x4007c,0x13,0x929,0x928, + 0x50050,0x2e,0x92d,0x929,0x914,0x50080,0x2e,0x92e,0x90e,0x92d,0x300f7,0x157b, + 0x0,0x400fa,0x1488,0x1555,0x157b,0x200f8,0x1555,0x500aa,0x2bb,0x1557,0x92e,0x19a, + 0x4009b,0x9d,0x1558,0x1557,0x300f7,0x157a,0x0,0x400fa,0x1558,0x1559,0x157a,0x200f8, + 0x1559,0x4003d,0x196,0x15c4,0x198,0x50062,0x4a,0x15c5,0x15c4,0x19a,0x50051,0x1a, + 0x155c,0x1424,0x1,0x50051,0x1a,0x155e,0x15c5,0x1,0x50051,0x1a,0x1560,0x1424, + 0x0,0x500b8,0x9d,0x1562,0x155e,0x2cc,0x300f7,0x1570,0x0,0x400fa,0x1562,0x1563, + 0x1570,0x200f8,0x1563,0x50083,0x1a,0x1567,0x1560,0x155e,0x50041,0x165,0x15c8,0x15e, + 0x145,0x4003d,0x1a,0x15c9,0x15c8,0x4007f,0x1a,0x1569,0x15c9,0x6000c,0x1a,0x156a, + 0x1,0x1b,0x1569,0x50083,0x1a,0x156b,0x258,0x156a,0x50085,0x1a,0x156c,0x1567, + 0x156b,0x50081,0x1a,0x156d,0x155e,0x156c,0x7000c,0x1a,0x15ce,0x1,0x28,0x18d, + 0x156d,0x200f9,0x1570,0x200f8,0x1570,0x700f5,0x1a,0x2d7e,0x1560,0x1559,0x15ce,0x1563, + 0x6000c,0x1a,0x15d6,0x1,0x1b,0x2d7e,0x50085,0x1a,0x15d9,0x15d6,0x39f4,0x6000c, + 0x1a,0x15da,0x1,0x1e,0x15d9,0x7000c,0x1a,0x15e4,0x1,0x1a,0x252,0x15da, + 0x50088,0x1a,0x15df,0x39f5,0x15e4,0x60052,0x4a,0x3b12,0x15df,0x15c5,0x0,0x60052, + 0x4a,0x3b14,0x2d7e,0x3b12,0x1,0x60052,0x4a,0x3b16,0x155c,0x3b14,0x2,0x4003d, + 0x196,0x15e6,0x198,0x40063,0x15e6,0x19a,0x3b16,0x200f9,0x157a,0x200f8,0x157a,0x200f9, + 0x157b,0x200f8,0x157b,0x50051,0x1a,0x15ec,0x1424,0x0,0x60041,0x2f0,0x15ed,0x2ed, + 0x928,0x913,0x3003e,0x15ed,0x15ec,0x50051,0x1a,0x15f1,0x1424,0x1,0x60041,0x2f0, + 0x15f2,0x2f3,0x928,0x913,0x3003e,0x15f2,0x15f1,0x50051,0x1a,0x15f6,0x1424,0x2, + 0x60041,0x2f0,0x15f7,0x2f8,0x928,0x913,0x3003e,0x15f7,0x15f6,0x50051,0x1a,0x15fb, + 0x1424,0x3,0x60041,0x2f0,0x15fc,0x2fd,0x928,0x913,0x3003e,0x15fc,0x15fb,0x50080, + 0x6,0x944,0x913,0x4a3,0x4007c,0x13,0x945,0x944,0x50050,0x2e,0x946,0x911, + 0x945,0x50080,0x2e,0x947,0x90e,0x946,0x300f7,0x1647,0x0,0x400fa,0x1488,0x1621, + 0x1647,0x200f8,0x1621,0x500aa,0x2bb,0x1623,0x947,0x19a,0x4009b,0x9d,0x1624,0x1623, + 0x300f7,0x1646,0x0,0x400fa,0x1624,0x1625,0x1646,0x200f8,0x1625,0x4003d,0x196,0x1690, + 0x198,0x50062,0x4a,0x1691,0x1690,0x19a,0x50051,0x1a,0x1628,0x1444,0x1,0x50051, + 0x1a,0x162a,0x1691,0x1,0x50051,0x1a,0x162c,0x1444,0x0,0x500b8,0x9d,0x162e, + 0x162a,0x2cc,0x300f7,0x163c,0x0,0x400fa,0x162e,0x162f,0x163c,0x200f8,0x162f,0x50083, + 0x1a,0x1633,0x162c,0x162a,0x50041,0x165,0x1694,0x15e,0x145,0x4003d,0x1a,0x1695, + 0x1694,0x4007f,0x1a,0x1635,0x1695,0x6000c,0x1a,0x1636,0x1,0x1b,0x1635,0x50083, + 0x1a,0x1637,0x258,0x1636,0x50085,0x1a,0x1638,0x1633,0x1637,0x50081,0x1a,0x1639, + 0x162a,0x1638,0x7000c,0x1a,0x169a,0x1,0x28,0x18d,0x1639,0x200f9,0x163c,0x200f8, + 0x163c,0x700f5,0x1a,0x2dec,0x162c,0x1625,0x169a,0x162f,0x6000c,0x1a,0x16a2,0x1, + 0x1b,0x2dec,0x50085,0x1a,0x16a5,0x16a2,0x39f4,0x6000c,0x1a,0x16a6,0x1,0x1e, + 0x16a5,0x7000c,0x1a,0x16b0,0x1,0x1a,0x252,0x16a6,0x50088,0x1a,0x16ab,0x39f5, + 0x16b0,0x60052,0x4a,0x3b1f,0x16ab,0x1691,0x0,0x60052,0x4a,0x3b21,0x2dec,0x3b1f, + 0x1,0x60052,0x4a,0x3b23,0x1628,0x3b21,0x2,0x4003d,0x196,0x16b2,0x198,0x40063, + 0x16b2,0x19a,0x3b23,0x200f9,0x1646,0x200f8,0x1646,0x200f9,0x1647,0x200f8,0x1647,0x50051, + 0x1a,0x16b8,0x1444,0x0,0x60041,0x2f0,0x16b9,0x2ed,0x910,0x944,0x3003e,0x16b9, + 0x16b8,0x50051,0x1a,0x16bd,0x1444,0x1,0x60041,0x2f0,0x16be,0x2f3,0x910,0x944, + 0x3003e,0x16be,0x16bd,0x50051,0x1a,0x16c2,0x1444,0x2,0x60041,0x2f0,0x16c3,0x2f8, + 0x910,0x944,0x3003e,0x16c3,0x16c2,0x50051,0x1a,0x16c7,0x1444,0x3,0x60041,0x2f0, + 0x16c8,0x2fd,0x910,0x944,0x3003e,0x16c8,0x16c7,0x50050,0x2e,0x960,0x929,0x945, + 0x50080,0x2e,0x961,0x90e,0x960,0x300f7,0x1713,0x0,0x400fa,0x1488,0x16ed,0x1713, + 0x200f8,0x16ed,0x500aa,0x2bb,0x16ef,0x961,0x19a,0x4009b,0x9d,0x16f0,0x16ef,0x300f7, + 0x1712,0x0,0x400fa,0x16f0,0x16f1,0x1712,0x200f8,0x16f1,0x4003d,0x196,0x175c,0x198, + 0x50062,0x4a,0x175d,0x175c,0x19a,0x50051,0x1a,0x16f4,0x1464,0x1,0x50051,0x1a, + 0x16f6,0x175d,0x1,0x50051,0x1a,0x16f8,0x1464,0x0,0x500b8,0x9d,0x16fa,0x16f6, + 0x2cc,0x300f7,0x1708,0x0,0x400fa,0x16fa,0x16fb,0x1708,0x200f8,0x16fb,0x50083,0x1a, + 0x16ff,0x16f8,0x16f6,0x50041,0x165,0x1760,0x15e,0x145,0x4003d,0x1a,0x1761,0x1760, + 0x4007f,0x1a,0x1701,0x1761,0x6000c,0x1a,0x1702,0x1,0x1b,0x1701,0x50083,0x1a, + 0x1703,0x258,0x1702,0x50085,0x1a,0x1704,0x16ff,0x1703,0x50081,0x1a,0x1705,0x16f6, + 0x1704,0x7000c,0x1a,0x1766,0x1,0x28,0x18d,0x1705,0x200f9,0x1708,0x200f8,0x1708, + 0x700f5,0x1a,0x2e65,0x16f8,0x16f1,0x1766,0x16fb,0x6000c,0x1a,0x176e,0x1,0x1b, + 0x2e65,0x50085,0x1a,0x1771,0x176e,0x39f4,0x6000c,0x1a,0x1772,0x1,0x1e,0x1771, + 0x7000c,0x1a,0x177c,0x1,0x1a,0x252,0x1772,0x50088,0x1a,0x1777,0x39f5,0x177c, + 0x60052,0x4a,0x3b2c,0x1777,0x175d,0x0,0x60052,0x4a,0x3b2e,0x2e65,0x3b2c,0x1, + 0x60052,0x4a,0x3b30,0x16f4,0x3b2e,0x2,0x4003d,0x196,0x177e,0x198,0x40063,0x177e, + 0x19a,0x3b30,0x200f9,0x1712,0x200f8,0x1712,0x200f9,0x1713,0x200f8,0x1713,0x50051,0x1a, + 0x1784,0x1464,0x0,0x60041,0x2f0,0x1785,0x2ed,0x928,0x944,0x3003e,0x1785,0x1784, + 0x50051,0x1a,0x1789,0x1464,0x1,0x60041,0x2f0,0x178a,0x2f3,0x928,0x944,0x3003e, + 0x178a,0x1789,0x50051,0x1a,0x178e,0x1464,0x2,0x60041,0x2f0,0x178f,0x2f8,0x928, + 0x944,0x3003e,0x178f,0x178e,0x50051,0x1a,0x1793,0x1464,0x3,0x60041,0x2f0,0x1794, + 0x2fd,0x928,0x944,0x3003e,0x1794,0x1793,0x200f9,0x96f,0x200f8,0x96f,0x200f9,0x970, + 0x200f8,0x970,0x300f7,0x17e6,0x0,0x300fb,0x183,0x17ad,0x200f8,0x17ad,0x500b2,0x9d, + 0x17b0,0x76e,0x13e,0x300f7,0x17b2,0x0,0x400fa,0x17b0,0x17b1,0x17b2,0x200f8,0x17b1, + 0x200f9,0x17e6,0x200f8,0x17b2,0x300e1,0x13e,0x319,0x400e0,0x13e,0x13e,0x31a,0x60041, + 0x2f0,0x181a,0x2ed,0x7b1,0x7b7,0x4003d,0x1a,0x181b,0x181a,0x60041,0x2f0,0x181e, + 0x2f3,0x7b1,0x7b7,0x4003d,0x1a,0x181f,0x181e,0x60041,0x2f0,0x1822,0x2f8,0x7b1, + 0x7b7,0x4003d,0x1a,0x1823,0x1822,0x60041,0x2f0,0x1826,0x2fd,0x7b1,0x7b7,0x4003d, + 0x1a,0x1827,0x1826,0x70050,0x4a,0x1828,0x181b,0x181f,0x1823,0x1827,0x6016e,0x4a, + 0x1835,0x13f,0x1828,0x183,0x6016e,0x4a,0x1837,0x13f,0x1828,0x145,0x6016e,0x4a, + 0x1839,0x13f,0x1828,0x13e,0x50081,0x4a,0x1843,0x1828,0x1835,0x50081,0x4a,0x1845, + 0x1843,0x1837,0x50081,0x4a,0x1847,0x1845,0x1839,0x5008e,0x4a,0x1848,0x1847,0x299, + 0x50089,0x6,0x17fa,0x737,0x1cb,0x500aa,0x9d,0x17fb,0x17fa,0x183,0x300f7,0x1815, + 0x0,0x400fa,0x17fb,0x17fc,0x1815,0x200f8,0x17fc,0x50084,0x29,0x17ff,0x77f,0x39ed, + 0x4007c,0x2e,0x1800,0x17ff,0x50086,0x6,0x1802,0x7b1,0x13e,0x4007c,0x13,0x1803, + 0x1802,0x50086,0x6,0x1805,0x7b7,0x13e,0x4007c,0x13,0x1806,0x1805,0x50050,0x2e, + 0x1807,0x1803,0x1806,0x50080,0x2e,0x1808,0x1800,0x1807,0x500aa,0x9d,0x186c,0x13e, + 0xb79,0x300f7,0x1893,0x0,0x400fa,0x186c,0x186d,0x1893,0x200f8,0x186d,0x500aa,0x2bb, + 0x186f,0x1808,0x19a,0x4009b,0x9d,0x1870,0x186f,0x300f7,0x1892,0x0,0x400fa,0x1870, + 0x1871,0x1892,0x200f8,0x1871,0x4003d,0x196,0x18dc,0x198,0x50062,0x4a,0x18dd,0x18dc, + 0x19a,0x50051,0x1a,0x1874,0x1848,0x1,0x50051,0x1a,0x1876,0x18dd,0x1,0x50051, + 0x1a,0x1878,0x1848,0x0,0x500b8,0x9d,0x187a,0x1876,0x2cc,0x300f7,0x1888,0x0, + 0x400fa,0x187a,0x187b,0x1888,0x200f8,0x187b,0x50083,0x1a,0x187f,0x1878,0x1876,0x50041, + 0x165,0x18e0,0x15e,0x145,0x4003d,0x1a,0x18e1,0x18e0,0x4007f,0x1a,0x1881,0x18e1, + 0x6000c,0x1a,0x1882,0x1,0x1b,0x1881,0x50083,0x1a,0x1883,0x258,0x1882,0x50085, + 0x1a,0x1884,0x187f,0x1883,0x50081,0x1a,0x1885,0x1876,0x1884,0x7000c,0x1a,0x18e6, + 0x1,0x28,0x18d,0x1885,0x200f9,0x1888,0x200f8,0x1888,0x700f5,0x1a,0x30c3,0x1878, + 0x1871,0x18e6,0x187b,0x6000c,0x1a,0x18ee,0x1,0x1b,0x30c3,0x50085,0x1a,0x18f1, + 0x18ee,0x39f4,0x6000c,0x1a,0x18f2,0x1,0x1e,0x18f1,0x7000c,0x1a,0x18fc,0x1, + 0x1a,0x252,0x18f2,0x50088,0x1a,0x18f7,0x39f5,0x18fc,0x60052,0x4a,0x3b39,0x18f7, + 0x18dd,0x0,0x60052,0x4a,0x3b3b,0x30c3,0x3b39,0x1,0x60052,0x4a,0x3b3d,0x1874, + 0x3b3b,0x2,0x4003d,0x196,0x18fe,0x198,0x40063,0x18fe,0x19a,0x3b3d,0x200f9,0x1892, + 0x200f8,0x1892,0x200f9,0x1893,0x200f8,0x1893,0x50089,0x6,0x1810,0x1805,0x13e,0x50080, + 0x6,0x1811,0x7b1,0x1810,0x50051,0x1a,0x1904,0x1848,0x0,0x60041,0x2f0,0x1905, + 0x2ed,0x1811,0x7b7,0x3003e,0x1905,0x1904,0x50051,0x1a,0x1909,0x1848,0x1,0x60041, + 0x2f0,0x190a,0x2f3,0x1811,0x7b7,0x3003e,0x190a,0x1909,0x50051,0x1a,0x190e,0x1848, + 0x2,0x60041,0x2f0,0x190f,0x2f8,0x1811,0x7b7,0x3003e,0x190f,0x190e,0x50051,0x1a, + 0x1913,0x1848,0x3,0x60041,0x2f0,0x1914,0x2fd,0x1811,0x7b7,0x3003e,0x1914,0x1913, + 0x200f9,0x1815,0x200f8,0x1815,0x500b2,0x9d,0x17be,0x76e,0x13f,0x300f7,0x17c0,0x0, + 0x400fa,0x17be,0x17bf,0x17c0,0x200f8,0x17bf,0x200f9,0x17e6,0x200f8,0x17c0,0x300e1,0x13e, + 0x319,0x400e0,0x13e,0x13e,0x31a,0x500b0,0x9d,0x1923,0x737,0x3bb,0x300f7,0x194d, + 0x0,0x400fa,0x1923,0x1924,0x194d,0x200f8,0x1924,0x50089,0x6,0x1928,0x7b7,0x13e, + 0x50080,0x6,0x1929,0x870,0x1928,0x60041,0x2f0,0x1952,0x2ed,0x1929,0x873,0x4003d, + 0x1a,0x1953,0x1952,0x60041,0x2f0,0x1956,0x2f3,0x1929,0x873,0x4003d,0x1a,0x1957, + 0x1956,0x60041,0x2f0,0x195a,0x2f8,0x1929,0x873,0x4003d,0x1a,0x195b,0x195a,0x60041, + 0x2f0,0x195e,0x2fd,0x1929,0x873,0x4003d,0x1a,0x195f,0x195e,0x70050,0x4a,0x1960, + 0x1953,0x1957,0x195b,0x195f,0x6016e,0x4a,0x196d,0x13f,0x1960,0x183,0x6016e,0x4a, + 0x196f,0x13f,0x1960,0x145,0x6016e,0x4a,0x1971,0x13f,0x1960,0x13e,0x50081,0x4a, + 0x197b,0x1960,0x196d,0x50081,0x4a,0x197d,0x197b,0x196f,0x50081,0x4a,0x197f,0x197d, + 0x1971,0x5008e,0x4a,0x1980,0x197f,0x299,0x300f7,0x194c,0x0,0x400fa,0x17fb,0x1932, + 0x194c,0x200f8,0x1932,0x50084,0x29,0x1935,0x77f,0x39ee,0x4007c,0x2e,0x1936,0x1935, + 0x50086,0x6,0x1938,0x7b1,0x13e,0x4007c,0x13,0x1939,0x1938,0x50086,0x6,0x193b, + 0x7b7,0x13e,0x4007c,0x13,0x193c,0x193b,0x50050,0x2e,0x193d,0x1939,0x193c,0x50080, + 0x2e,0x193e,0x1936,0x193d,0x500aa,0x9d,0x19a4,0x13f,0xb79,0x300f7,0x19cb,0x0, + 0x400fa,0x19a4,0x19a5,0x19cb,0x200f8,0x19a5,0x500aa,0x2bb,0x19a7,0x193e,0x19a,0x4009b, + 0x9d,0x19a8,0x19a7,0x300f7,0x19ca,0x0,0x400fa,0x19a8,0x19a9,0x19ca,0x200f8,0x19a9, + 0x4003d,0x196,0x1a14,0x198,0x50062,0x4a,0x1a15,0x1a14,0x19a,0x50051,0x1a,0x19ac, + 0x1980,0x1,0x50051,0x1a,0x19ae,0x1a15,0x1,0x50051,0x1a,0x19b0,0x1980,0x0, + 0x500b8,0x9d,0x19b2,0x19ae,0x2cc,0x300f7,0x19c0,0x0,0x400fa,0x19b2,0x19b3,0x19c0, + 0x200f8,0x19b3,0x50083,0x1a,0x19b7,0x19b0,0x19ae,0x50041,0x165,0x1a18,0x15e,0x145, + 0x4003d,0x1a,0x1a19,0x1a18,0x4007f,0x1a,0x19b9,0x1a19,0x6000c,0x1a,0x19ba,0x1, + 0x1b,0x19b9,0x50083,0x1a,0x19bb,0x258,0x19ba,0x50085,0x1a,0x19bc,0x19b7,0x19bb, + 0x50081,0x1a,0x19bd,0x19ae,0x19bc,0x7000c,0x1a,0x1a1e,0x1,0x28,0x18d,0x19bd, + 0x200f9,0x19c0,0x200f8,0x19c0,0x700f5,0x1a,0x3159,0x19b0,0x19a9,0x1a1e,0x19b3,0x6000c, + 0x1a,0x1a26,0x1,0x1b,0x3159,0x50085,0x1a,0x1a29,0x1a26,0x39f4,0x6000c,0x1a, + 0x1a2a,0x1,0x1e,0x1a29,0x7000c,0x1a,0x1a34,0x1,0x1a,0x252,0x1a2a,0x50088, + 0x1a,0x1a2f,0x39f5,0x1a34,0x60052,0x4a,0x3b46,0x1a2f,0x1a15,0x0,0x60052,0x4a, + 0x3b48,0x3159,0x3b46,0x1,0x60052,0x4a,0x3b4a,0x19ac,0x3b48,0x2,0x4003d,0x196, + 0x1a36,0x198,0x40063,0x1a36,0x19a,0x3b4a,0x200f9,0x19ca,0x200f8,0x19ca,0x200f9,0x19cb, + 0x200f8,0x19cb,0x50080,0x6,0x1947,0x870,0x193b,0x50051,0x1a,0x1a3c,0x1980,0x0, + 0x60041,0x2f0,0x1a3d,0x2ed,0x1947,0x873,0x3003e,0x1a3d,0x1a3c,0x50051,0x1a,0x1a41, + 0x1980,0x1,0x60041,0x2f0,0x1a42,0x2f3,0x1947,0x873,0x3003e,0x1a42,0x1a41,0x50051, + 0x1a,0x1a46,0x1980,0x2,0x60041,0x2f0,0x1a47,0x2f8,0x1947,0x873,0x3003e,0x1a47, + 0x1a46,0x50051,0x1a,0x1a4b,0x1980,0x3,0x60041,0x2f0,0x1a4c,0x2fd,0x1947,0x873, + 0x3003e,0x1a4c,0x1a4b,0x200f9,0x194c,0x200f8,0x194c,0x200f9,0x194d,0x200f8,0x194d,0x500b2, + 0x9d,0x17cd,0x76e,0x1cb,0x300f7,0x17cf,0x0,0x400fa,0x17cd,0x17ce,0x17cf,0x200f8, + 0x17ce,0x200f9,0x17e6,0x200f8,0x17cf,0x300e1,0x13e,0x319,0x400e0,0x13e,0x13e,0x31a, + 0x500b0,0x9d,0x1a5b,0x737,0x2e9,0x300f7,0x1a81,0x0,0x400fa,0x1a5b,0x1a5c,0x1a81, + 0x200f8,0x1a5c,0x50084,0x6,0x1a5e,0x7b1,0x1cb,0x50080,0x6,0x1a60,0x1a5e,0x7b7, + 0x50084,0x6,0x1a62,0x7b7,0x1cb,0x60041,0x2f0,0x1a86,0x2ed,0x1a60,0x1a62,0x4003d, + 0x1a,0x1a87,0x1a86,0x60041,0x2f0,0x1a8a,0x2f3,0x1a60,0x1a62,0x4003d,0x1a,0x1a8b, + 0x1a8a,0x60041,0x2f0,0x1a8e,0x2f8,0x1a60,0x1a62,0x4003d,0x1a,0x1a8f,0x1a8e,0x60041, + 0x2f0,0x1a92,0x2fd,0x1a60,0x1a62,0x4003d,0x1a,0x1a93,0x1a92,0x70050,0x4a,0x1a94, + 0x1a87,0x1a8b,0x1a8f,0x1a93,0x6016e,0x4a,0x1aa1,0x13f,0x1a94,0x183,0x6016e,0x4a, + 0x1aa3,0x13f,0x1a94,0x145,0x6016e,0x4a,0x1aa5,0x13f,0x1a94,0x13e,0x50081,0x4a, + 0x1aaf,0x1a94,0x1aa1,0x50081,0x4a,0x1ab1,0x1aaf,0x1aa3,0x50081,0x4a,0x1ab3,0x1ab1, + 0x1aa5,0x5008e,0x4a,0x1ab4,0x1ab3,0x299,0x300f7,0x1a80,0x0,0x400fa,0x17fb,0x1a69, + 0x1a80,0x200f8,0x1a69,0x50084,0x29,0x1a6c,0x77f,0x39ef,0x4007c,0x2e,0x1a6d,0x1a6c, + 0x50086,0x6,0x1a6f,0x7b1,0x13e,0x4007c,0x13,0x1a70,0x1a6f,0x50086,0x6,0x1a72, + 0x7b7,0x13e,0x4007c,0x13,0x1a73,0x1a72,0x50050,0x2e,0x1a74,0x1a70,0x1a73,0x50080, + 0x2e,0x1a75,0x1a6d,0x1a74,0x500aa,0x9d,0x1ad8,0x1cb,0xb79,0x300f7,0x1aff,0x0, + 0x400fa,0x1ad8,0x1ad9,0x1aff,0x200f8,0x1ad9,0x500aa,0x2bb,0x1adb,0x1a75,0x19a,0x4009b, + 0x9d,0x1adc,0x1adb,0x300f7,0x1afe,0x0,0x400fa,0x1adc,0x1add,0x1afe,0x200f8,0x1add, + 0x4003d,0x196,0x1b48,0x198,0x50062,0x4a,0x1b49,0x1b48,0x19a,0x50051,0x1a,0x1ae0, + 0x1ab4,0x1,0x50051,0x1a,0x1ae2,0x1b49,0x1,0x50051,0x1a,0x1ae4,0x1ab4,0x0, + 0x500b8,0x9d,0x1ae6,0x1ae2,0x2cc,0x300f7,0x1af4,0x0,0x400fa,0x1ae6,0x1ae7,0x1af4, + 0x200f8,0x1ae7,0x50083,0x1a,0x1aeb,0x1ae4,0x1ae2,0x50041,0x165,0x1b4c,0x15e,0x145, + 0x4003d,0x1a,0x1b4d,0x1b4c,0x4007f,0x1a,0x1aed,0x1b4d,0x6000c,0x1a,0x1aee,0x1, + 0x1b,0x1aed,0x50083,0x1a,0x1aef,0x258,0x1aee,0x50085,0x1a,0x1af0,0x1aeb,0x1aef, + 0x50081,0x1a,0x1af1,0x1ae2,0x1af0,0x7000c,0x1a,0x1b52,0x1,0x28,0x18d,0x1af1, + 0x200f9,0x1af4,0x200f8,0x1af4,0x700f5,0x1a,0x31f6,0x1ae4,0x1add,0x1b52,0x1ae7,0x6000c, + 0x1a,0x1b5a,0x1,0x1b,0x31f6,0x50085,0x1a,0x1b5d,0x1b5a,0x39f4,0x6000c,0x1a, + 0x1b5e,0x1,0x1e,0x1b5d,0x7000c,0x1a,0x1b68,0x1,0x1a,0x252,0x1b5e,0x50088, + 0x1a,0x1b63,0x39f5,0x1b68,0x60052,0x4a,0x3b53,0x1b63,0x1b49,0x0,0x60052,0x4a, + 0x3b55,0x31f6,0x3b53,0x1,0x60052,0x4a,0x3b57,0x1ae0,0x3b55,0x2,0x4003d,0x196, + 0x1b6a,0x198,0x40063,0x1b6a,0x19a,0x3b57,0x200f9,0x1afe,0x200f8,0x1afe,0x200f9,0x1aff, + 0x200f8,0x1aff,0x50080,0x6,0x1a7d,0x1a6f,0x7b7,0x50051,0x1a,0x1b70,0x1ab4,0x0, + 0x60041,0x2f0,0x1b71,0x2ed,0x1a7d,0x183,0x3003e,0x1b71,0x1b70,0x50051,0x1a,0x1b75, + 0x1ab4,0x1,0x60041,0x2f0,0x1b76,0x2f3,0x1a7d,0x183,0x3003e,0x1b76,0x1b75,0x50051, + 0x1a,0x1b7a,0x1ab4,0x2,0x60041,0x2f0,0x1b7b,0x2f8,0x1a7d,0x183,0x3003e,0x1b7b, + 0x1b7a,0x50051,0x1a,0x1b7f,0x1ab4,0x3,0x60041,0x2f0,0x1b80,0x2fd,0x1a7d,0x183, + 0x3003e,0x1b80,0x1b7f,0x200f9,0x1a80,0x200f8,0x1a80,0x200f9,0x1a81,0x200f8,0x1a81,0x500b2, + 0x9d,0x17dc,0x76e,0x1d6,0x300f7,0x17de,0x0,0x400fa,0x17dc,0x17dd,0x17de,0x200f8, + 0x17dd,0x200f9,0x17e6,0x200f8,0x17de,0x300e1,0x13e,0x319,0x400e0,0x13e,0x13e,0x31a, + 0x500b0,0x9d,0x1b8c,0x737,0x1cb,0x300f7,0x1b9d,0x0,0x400fa,0x1b8c,0x1b8d,0x1b9d, + 0x200f8,0x1b8d,0x60041,0x2f0,0x1ba2,0x2ed,0x737,0x183,0x4003d,0x1a,0x1ba3,0x1ba2, + 0x60041,0x2f0,0x1ba6,0x2f3,0x737,0x183,0x4003d,0x1a,0x1ba7,0x1ba6,0x60041,0x2f0, + 0x1baa,0x2f8,0x737,0x183,0x4003d,0x1a,0x1bab,0x1baa,0x60041,0x2f0,0x1bae,0x2fd, + 0x737,0x183,0x4003d,0x1a,0x1baf,0x1bae,0x70050,0x4a,0x1bb0,0x1ba3,0x1ba7,0x1bab, + 0x1baf,0x6016e,0x4a,0x1bbd,0x13f,0x1bb0,0x183,0x6016e,0x4a,0x1bbf,0x13f,0x1bb0, + 0x145,0x6016e,0x4a,0x1bc1,0x13f,0x1bb0,0x13e,0x50081,0x4a,0x1bcb,0x1bb0,0x1bbd, + 0x50081,0x4a,0x1bcd,0x1bcb,0x1bbf,0x50081,0x4a,0x1bcf,0x1bcd,0x1bc1,0x5008e,0x4a, + 0x1bd0,0x1bcf,0x299,0x300f7,0x1b9c,0x0,0x400fa,0x17fb,0x1b95,0x1b9c,0x200f8,0x1b95, + 0x4007c,0x2e,0x1b97,0x77f,0x4003d,0x1a4,0x1c52,0x1da,0x50051,0x1a,0x1c55,0x1bd0, + 0x0,0x50051,0x1a,0x1c56,0x1bd0,0x1,0x70050,0x4a,0x1c57,0x1c55,0x1c56,0x18d, + 0x18d,0x40063,0x1c52,0x1b97,0x1c57,0x500aa,0x9d,0x1bf4,0x1d6,0xb79,0x300f7,0x1c1b, + 0x0,0x400fa,0x1bf4,0x1bf5,0x1c1b,0x200f8,0x1bf5,0x500aa,0x2bb,0x1bf7,0x1b97,0x19a, + 0x4009b,0x9d,0x1bf8,0x1bf7,0x300f7,0x1c1a,0x0,0x400fa,0x1bf8,0x1bf9,0x1c1a,0x200f8, + 0x1bf9,0x4003d,0x196,0x1c64,0x198,0x50062,0x4a,0x1c65,0x1c64,0x19a,0x50051,0x1a, + 0x1bfe,0x1c65,0x1,0x500b8,0x9d,0x1c02,0x1bfe,0x2cc,0x300f7,0x1c10,0x0,0x400fa, + 0x1c02,0x1c03,0x1c10,0x200f8,0x1c03,0x50083,0x1a,0x1c07,0x1c55,0x1bfe,0x50041,0x165, + 0x1c68,0x15e,0x145,0x4003d,0x1a,0x1c69,0x1c68,0x4007f,0x1a,0x1c09,0x1c69,0x6000c, + 0x1a,0x1c0a,0x1,0x1b,0x1c09,0x50083,0x1a,0x1c0b,0x258,0x1c0a,0x50085,0x1a, + 0x1c0c,0x1c07,0x1c0b,0x50081,0x1a,0x1c0d,0x1bfe,0x1c0c,0x7000c,0x1a,0x1c6e,0x1, + 0x28,0x18d,0x1c0d,0x200f9,0x1c10,0x200f8,0x1c10,0x700f5,0x1a,0x3279,0x1c55,0x1bf9, + 0x1c6e,0x1c03,0x6000c,0x1a,0x1c76,0x1,0x1b,0x3279,0x50085,0x1a,0x1c79,0x1c76, + 0x39f4,0x6000c,0x1a,0x1c7a,0x1,0x1e,0x1c79,0x7000c,0x1a,0x1c84,0x1,0x1a, + 0x252,0x1c7a,0x50088,0x1a,0x1c7f,0x39f5,0x1c84,0x60052,0x4a,0x3b60,0x1c7f,0x1c65, + 0x0,0x60052,0x4a,0x3b62,0x3279,0x3b60,0x1,0x60052,0x4a,0x3b64,0x1c56,0x3b62, + 0x2,0x4003d,0x196,0x1c86,0x198,0x40063,0x1c86,0x19a,0x3b64,0x200f9,0x1c1a,0x200f8, + 0x1c1a,0x200f9,0x1c1b,0x200f8,0x1c1b,0x200f9,0x1b9c,0x200f8,0x1b9c,0x200f9,0x1b9d,0x200f8, + 0x1b9d,0x200f9,0x17e6,0x200f8,0x17e6,0x500b2,0x9d,0x7c7,0x76e,0x5da,0x300f7,0x7c9, + 0x0,0x400fa,0x7c7,0x7c8,0x7c9,0x200f8,0x7c8,0x200f9,0x7dd,0x200f8,0x7c9,0x500aa, + 0x9d,0x1c8c,0x737,0x183,0x300f7,0x1c90,0x0,0x400fa,0x1c8c,0x1c8d,0x1c90,0x200f8, + 0x1c8d,0x6003c,0x222,0x1c9c,0x221,0x19a,0x183,0x700ea,0x6,0x1c9d,0x1c9c,0x145, + 0x183,0x145,0x3003e,0x25e,0x1c9d,0x200f9,0x1c90,0x200f8,0x1c90,0x300e1,0x13e,0x319, + 0x400e0,0x13e,0x13e,0x31a,0x4003d,0x6,0x1ca1,0x25e,0x50082,0x6,0x1c94,0x772, + 0x145,0x500ab,0x9d,0x1c95,0x1ca1,0x1c94,0x300f7,0x7cf,0x0,0x400fa,0x1c95,0x7ce, + 0x7cf,0x200f8,0x7ce,0x200f9,0x7dd,0x200f8,0x7cf,0x4003d,0x21f,0x1ca5,0x221,0x50063, + 0x1ca5,0x19a,0x227,0x2000,0x300f7,0x1d50,0x0,0x300fb,0x183,0x1cd2,0x200f8,0x1cd2, + 0x50084,0x6,0x1cd4,0x7b1,0x1cb,0x4007c,0x13,0x1cd6,0x1cd4,0x50084,0x6,0x1cd8, + 0x7b7,0x1cb,0x4007c,0x13,0x1cda,0x1cd8,0x50050,0x2e,0x1cdb,0x1cd6,0x1cda,0x4007c, + 0x29,0x1ce6,0x1cdb,0x50080,0x29,0x1d5b,0x1ce6,0x36c,0x50080,0x29,0x1d5d,0x1ce6, + 0x36f,0x50080,0x29,0x1d5f,0x1ce6,0x372,0x4003d,0x1a4,0x1dc2,0x1da,0x50062,0x4a, + 0x1dc4,0x1dc2,0x1cdb,0x50051,0x1a,0x1d8f,0x1dc4,0x0,0x50051,0x1a,0x1d90,0x1dc4, + 0x1,0x70050,0x4a,0x1d91,0x1d8f,0x1d90,0x18d,0x18d,0x4007c,0x2e,0x1d79,0x1d5b, + 0x4003d,0x1a4,0x1e02,0x1da,0x50062,0x4a,0x1e04,0x1e02,0x1d79,0x50051,0x1a,0x1dcf, + 0x1e04,0x0,0x50051,0x1a,0x1dd0,0x1e04,0x1,0x70050,0x4a,0x1dd1,0x1dcf,0x1dd0, + 0x18d,0x18d,0x4007c,0x2e,0x1d7d,0x1d5d,0x4003d,0x1a4,0x1e42,0x1da,0x50062,0x4a, + 0x1e44,0x1e42,0x1d7d,0x50051,0x1a,0x1e0f,0x1e44,0x0,0x50051,0x1a,0x1e10,0x1e44, + 0x1,0x70050,0x4a,0x1e11,0x1e0f,0x1e10,0x18d,0x18d,0x4007c,0x2e,0x1d81,0x1d5f, + 0x4003d,0x1a4,0x1e82,0x1da,0x50062,0x4a,0x1e84,0x1e82,0x1d81,0x50051,0x1a,0x1e4f, + 0x1e84,0x0,0x50051,0x1a,0x1e50,0x1e84,0x1,0x70050,0x4a,0x1e51,0x1e4f,0x1e50, + 0x18d,0x18d,0x50081,0x4a,0x1e8d,0x1d91,0x1dd1,0x50081,0x4a,0x1e8f,0x1e8d,0x1e11, + 0x50081,0x4a,0x1e91,0x1e8f,0x1e51,0x5008e,0x4a,0x1e92,0x1e91,0x299,0x500aa,0x9d, + 0x1eb6,0x5da,0xb79,0x300f7,0x1edd,0x0,0x400fa,0x1eb6,0x1eb7,0x1edd,0x200f8,0x1eb7, + 0x500aa,0x2bb,0x1eb9,0x875,0x19a,0x4009b,0x9d,0x1eba,0x1eb9,0x300f7,0x1edc,0x0, + 0x400fa,0x1eba,0x1ebb,0x1edc,0x200f8,0x1ebb,0x4003d,0x196,0x1f26,0x198,0x50062,0x4a, + 0x1f27,0x1f26,0x19a,0x50051,0x1a,0x1ebe,0x1e92,0x1,0x50051,0x1a,0x1ec0,0x1f27, + 0x1,0x50051,0x1a,0x1ec2,0x1e92,0x0,0x500b8,0x9d,0x1ec4,0x1ec0,0x2cc,0x300f7, + 0x1ed2,0x0,0x400fa,0x1ec4,0x1ec5,0x1ed2,0x200f8,0x1ec5,0x50083,0x1a,0x1ec9,0x1ec2, + 0x1ec0,0x50041,0x165,0x1f2a,0x15e,0x145,0x4003d,0x1a,0x1f2b,0x1f2a,0x4007f,0x1a, + 0x1ecb,0x1f2b,0x6000c,0x1a,0x1ecc,0x1,0x1b,0x1ecb,0x50083,0x1a,0x1ecd,0x258, + 0x1ecc,0x50085,0x1a,0x1ece,0x1ec9,0x1ecd,0x50081,0x1a,0x1ecf,0x1ec0,0x1ece,0x7000c, + 0x1a,0x1f30,0x1,0x28,0x18d,0x1ecf,0x200f9,0x1ed2,0x200f8,0x1ed2,0x700f5,0x1a, + 0x344c,0x1ec2,0x1ebb,0x1f30,0x1ec5,0x6000c,0x1a,0x1f38,0x1,0x1b,0x344c,0x50085, + 0x1a,0x1f3b,0x1f38,0x39f4,0x6000c,0x1a,0x1f3c,0x1,0x1e,0x1f3b,0x7000c,0x1a, + 0x1f46,0x1,0x1a,0x252,0x1f3c,0x50088,0x1a,0x1f41,0x39f5,0x1f46,0x60052,0x4a, + 0x3b69,0x1f41,0x1f27,0x0,0x60052,0x4a,0x3b6b,0x344c,0x3b69,0x1,0x60052,0x4a, + 0x3b6d,0x1ebe,0x3b6b,0x2,0x4003d,0x196,0x1f48,0x198,0x40063,0x1f48,0x19a,0x3b6d, + 0x200f9,0x1edc,0x200f8,0x1edc,0x200f9,0x1edd,0x200f8,0x1edd,0x50080,0x6,0x1cef,0x1cd4, + 0x13e,0x4007c,0x13,0x1cf0,0x1cef,0x50050,0x2e,0x1cf5,0x1cf0,0x1cda,0x50080,0x6, + 0x1cf8,0x870,0x145,0x4007c,0x13,0x1cf9,0x1cf8,0x50050,0x2e,0x1cfe,0x1cf9,0x874, + 0x4007c,0x29,0x1d00,0x1cf5,0x50080,0x29,0x1f54,0x1d00,0x36c,0x50080,0x29,0x1f56, + 0x1d00,0x36f,0x50080,0x29,0x1f58,0x1d00,0x372,0x4003d,0x1a4,0x1fbb,0x1da,0x50062, + 0x4a,0x1fbd,0x1fbb,0x1cf5,0x50051,0x1a,0x1f88,0x1fbd,0x0,0x50051,0x1a,0x1f89, + 0x1fbd,0x1,0x70050,0x4a,0x1f8a,0x1f88,0x1f89,0x18d,0x18d,0x4007c,0x2e,0x1f72, + 0x1f54,0x4003d,0x1a4,0x1ffb,0x1da,0x50062,0x4a,0x1ffd,0x1ffb,0x1f72,0x50051,0x1a, + 0x1fc8,0x1ffd,0x0,0x50051,0x1a,0x1fc9,0x1ffd,0x1,0x70050,0x4a,0x1fca,0x1fc8, + 0x1fc9,0x18d,0x18d,0x4007c,0x2e,0x1f76,0x1f56,0x4003d,0x1a4,0x203b,0x1da,0x50062, + 0x4a,0x203d,0x203b,0x1f76,0x50051,0x1a,0x2008,0x203d,0x0,0x50051,0x1a,0x2009, + 0x203d,0x1,0x70050,0x4a,0x200a,0x2008,0x2009,0x18d,0x18d,0x4007c,0x2e,0x1f7a, + 0x1f58,0x4003d,0x1a4,0x207b,0x1da,0x50062,0x4a,0x207d,0x207b,0x1f7a,0x50051,0x1a, + 0x2048,0x207d,0x0,0x50051,0x1a,0x2049,0x207d,0x1,0x70050,0x4a,0x204a,0x2048, + 0x2049,0x18d,0x18d,0x50081,0x4a,0x2086,0x1f8a,0x1fca,0x50081,0x4a,0x2088,0x2086, + 0x200a,0x50081,0x4a,0x208a,0x2088,0x204a,0x5008e,0x4a,0x208b,0x208a,0x299,0x300f7, + 0x20d6,0x0,0x400fa,0x1eb6,0x20b0,0x20d6,0x200f8,0x20b0,0x500aa,0x2bb,0x20b2,0x1cfe, + 0x19a,0x4009b,0x9d,0x20b3,0x20b2,0x300f7,0x20d5,0x0,0x400fa,0x20b3,0x20b4,0x20d5, + 0x200f8,0x20b4,0x4003d,0x196,0x211f,0x198,0x50062,0x4a,0x2120,0x211f,0x19a,0x50051, + 0x1a,0x20b7,0x208b,0x1,0x50051,0x1a,0x20b9,0x2120,0x1,0x50051,0x1a,0x20bb, + 0x208b,0x0,0x500b8,0x9d,0x20bd,0x20b9,0x2cc,0x300f7,0x20cb,0x0,0x400fa,0x20bd, + 0x20be,0x20cb,0x200f8,0x20be,0x50083,0x1a,0x20c2,0x20bb,0x20b9,0x50041,0x165,0x2123, + 0x15e,0x145,0x4003d,0x1a,0x2124,0x2123,0x4007f,0x1a,0x20c4,0x2124,0x6000c,0x1a, + 0x20c5,0x1,0x1b,0x20c4,0x50083,0x1a,0x20c6,0x258,0x20c5,0x50085,0x1a,0x20c7, + 0x20c2,0x20c6,0x50081,0x1a,0x20c8,0x20b9,0x20c7,0x7000c,0x1a,0x2129,0x1,0x28, + 0x18d,0x20c8,0x200f9,0x20cb,0x200f8,0x20cb,0x700f5,0x1a,0x34b1,0x20bb,0x20b4,0x2129, + 0x20be,0x6000c,0x1a,0x2131,0x1,0x1b,0x34b1,0x50085,0x1a,0x2134,0x2131,0x39f4, + 0x6000c,0x1a,0x2135,0x1,0x1e,0x2134,0x7000c,0x1a,0x213f,0x1,0x1a,0x252, + 0x2135,0x50088,0x1a,0x213a,0x39f5,0x213f,0x60052,0x4a,0x3b72,0x213a,0x2120,0x0, + 0x60052,0x4a,0x3b74,0x34b1,0x3b72,0x1,0x60052,0x4a,0x3b76,0x20b7,0x3b74,0x2, + 0x4003d,0x196,0x2141,0x198,0x40063,0x2141,0x19a,0x3b76,0x200f9,0x20d5,0x200f8,0x20d5, + 0x200f9,0x20d6,0x200f8,0x20d6,0x50080,0x6,0x1d0d,0x1cd8,0x13e,0x4007c,0x13,0x1d0e, + 0x1d0d,0x50050,0x2e,0x1d0f,0x1cd6,0x1d0e,0x50080,0x6,0x1d16,0x873,0x145,0x4007c, + 0x13,0x1d17,0x1d16,0x50050,0x2e,0x1d18,0x871,0x1d17,0x4007c,0x29,0x1d1a,0x1d0f, + 0x50080,0x29,0x214d,0x1d1a,0x36c,0x50080,0x29,0x214f,0x1d1a,0x36f,0x50080,0x29, + 0x2151,0x1d1a,0x372,0x4003d,0x1a4,0x21b4,0x1da,0x50062,0x4a,0x21b6,0x21b4,0x1d0f, + 0x50051,0x1a,0x2181,0x21b6,0x0,0x50051,0x1a,0x2182,0x21b6,0x1,0x70050,0x4a, + 0x2183,0x2181,0x2182,0x18d,0x18d,0x4007c,0x2e,0x216b,0x214d,0x4003d,0x1a4,0x21f4, + 0x1da,0x50062,0x4a,0x21f6,0x21f4,0x216b,0x50051,0x1a,0x21c1,0x21f6,0x0,0x50051, + 0x1a,0x21c2,0x21f6,0x1,0x70050,0x4a,0x21c3,0x21c1,0x21c2,0x18d,0x18d,0x4007c, + 0x2e,0x216f,0x214f,0x4003d,0x1a4,0x2234,0x1da,0x50062,0x4a,0x2236,0x2234,0x216f, + 0x50051,0x1a,0x2201,0x2236,0x0,0x50051,0x1a,0x2202,0x2236,0x1,0x70050,0x4a, + 0x2203,0x2201,0x2202,0x18d,0x18d,0x4007c,0x2e,0x2173,0x2151,0x4003d,0x1a4,0x2274, + 0x1da,0x50062,0x4a,0x2276,0x2274,0x2173,0x50051,0x1a,0x2241,0x2276,0x0,0x50051, + 0x1a,0x2242,0x2276,0x1,0x70050,0x4a,0x2243,0x2241,0x2242,0x18d,0x18d,0x50081, + 0x4a,0x227f,0x2183,0x21c3,0x50081,0x4a,0x2281,0x227f,0x2203,0x50081,0x4a,0x2283, + 0x2281,0x2243,0x5008e,0x4a,0x2284,0x2283,0x299,0x300f7,0x22cf,0x0,0x400fa,0x1eb6, + 0x22a9,0x22cf,0x200f8,0x22a9,0x500aa,0x2bb,0x22ab,0x1d18,0x19a,0x4009b,0x9d,0x22ac, + 0x22ab,0x300f7,0x22ce,0x0,0x400fa,0x22ac,0x22ad,0x22ce,0x200f8,0x22ad,0x4003d,0x196, + 0x2318,0x198,0x50062,0x4a,0x2319,0x2318,0x19a,0x50051,0x1a,0x22b0,0x2284,0x1, + 0x50051,0x1a,0x22b2,0x2319,0x1,0x50051,0x1a,0x22b4,0x2284,0x0,0x500b8,0x9d, + 0x22b6,0x22b2,0x2cc,0x300f7,0x22c4,0x0,0x400fa,0x22b6,0x22b7,0x22c4,0x200f8,0x22b7, + 0x50083,0x1a,0x22bb,0x22b4,0x22b2,0x50041,0x165,0x231c,0x15e,0x145,0x4003d,0x1a, + 0x231d,0x231c,0x4007f,0x1a,0x22bd,0x231d,0x6000c,0x1a,0x22be,0x1,0x1b,0x22bd, + 0x50083,0x1a,0x22bf,0x258,0x22be,0x50085,0x1a,0x22c0,0x22bb,0x22bf,0x50081,0x1a, + 0x22c1,0x22b2,0x22c0,0x7000c,0x1a,0x2322,0x1,0x28,0x18d,0x22c1,0x200f9,0x22c4, + 0x200f8,0x22c4,0x700f5,0x1a,0x3516,0x22b4,0x22ad,0x2322,0x22b7,0x6000c,0x1a,0x232a, + 0x1,0x1b,0x3516,0x50085,0x1a,0x232d,0x232a,0x39f4,0x6000c,0x1a,0x232e,0x1, + 0x1e,0x232d,0x7000c,0x1a,0x2338,0x1,0x1a,0x252,0x232e,0x50088,0x1a,0x2333, + 0x39f5,0x2338,0x60052,0x4a,0x3b7b,0x2333,0x2319,0x0,0x60052,0x4a,0x3b7d,0x3516, + 0x3b7b,0x1,0x60052,0x4a,0x3b7f,0x22b0,0x3b7d,0x2,0x4003d,0x196,0x233a,0x198, + 0x40063,0x233a,0x19a,0x3b7f,0x200f9,0x22ce,0x200f8,0x22ce,0x200f9,0x22cf,0x200f8,0x22cf, + 0x50050,0x2e,0x1d29,0x1cf0,0x1d0e,0x50050,0x2e,0x1d32,0x1cf9,0x1d17,0x4007c,0x29, + 0x1d34,0x1d29,0x50080,0x29,0x2346,0x1d34,0x36c,0x50080,0x29,0x2348,0x1d34,0x36f, + 0x50080,0x29,0x234a,0x1d34,0x372,0x4003d,0x1a4,0x23ad,0x1da,0x50062,0x4a,0x23af, + 0x23ad,0x1d29,0x50051,0x1a,0x237a,0x23af,0x0,0x50051,0x1a,0x237b,0x23af,0x1, + 0x70050,0x4a,0x237c,0x237a,0x237b,0x18d,0x18d,0x4007c,0x2e,0x2364,0x2346,0x4003d, + 0x1a4,0x23ed,0x1da,0x50062,0x4a,0x23ef,0x23ed,0x2364,0x50051,0x1a,0x23ba,0x23ef, + 0x0,0x50051,0x1a,0x23bb,0x23ef,0x1,0x70050,0x4a,0x23bc,0x23ba,0x23bb,0x18d, + 0x18d,0x4007c,0x2e,0x2368,0x2348,0x4003d,0x1a4,0x242d,0x1da,0x50062,0x4a,0x242f, + 0x242d,0x2368,0x50051,0x1a,0x23fa,0x242f,0x0,0x50051,0x1a,0x23fb,0x242f,0x1, + 0x70050,0x4a,0x23fc,0x23fa,0x23fb,0x18d,0x18d,0x4007c,0x2e,0x236c,0x234a,0x4003d, + 0x1a4,0x246d,0x1da,0x50062,0x4a,0x246f,0x246d,0x236c,0x50051,0x1a,0x243a,0x246f, + 0x0,0x50051,0x1a,0x243b,0x246f,0x1,0x70050,0x4a,0x243c,0x243a,0x243b,0x18d, + 0x18d,0x50081,0x4a,0x2478,0x237c,0x23bc,0x50081,0x4a,0x247a,0x2478,0x23fc,0x50081, + 0x4a,0x247c,0x247a,0x243c,0x5008e,0x4a,0x247d,0x247c,0x299,0x300f7,0x24c8,0x0, + 0x400fa,0x1eb6,0x24a2,0x24c8,0x200f8,0x24a2,0x500aa,0x2bb,0x24a4,0x1d32,0x19a,0x4009b, + 0x9d,0x24a5,0x24a4,0x300f7,0x24c7,0x0,0x400fa,0x24a5,0x24a6,0x24c7,0x200f8,0x24a6, + 0x4003d,0x196,0x2511,0x198,0x50062,0x4a,0x2512,0x2511,0x19a,0x50051,0x1a,0x24a9, + 0x247d,0x1,0x50051,0x1a,0x24ab,0x2512,0x1,0x50051,0x1a,0x24ad,0x247d,0x0, + 0x500b8,0x9d,0x24af,0x24ab,0x2cc,0x300f7,0x24bd,0x0,0x400fa,0x24af,0x24b0,0x24bd, + 0x200f8,0x24b0,0x50083,0x1a,0x24b4,0x24ad,0x24ab,0x50041,0x165,0x2515,0x15e,0x145, + 0x4003d,0x1a,0x2516,0x2515,0x4007f,0x1a,0x24b6,0x2516,0x6000c,0x1a,0x24b7,0x1, + 0x1b,0x24b6,0x50083,0x1a,0x24b8,0x258,0x24b7,0x50085,0x1a,0x24b9,0x24b4,0x24b8, + 0x50081,0x1a,0x24ba,0x24ab,0x24b9,0x7000c,0x1a,0x251b,0x1,0x28,0x18d,0x24ba, + 0x200f9,0x24bd,0x200f8,0x24bd,0x700f5,0x1a,0x357b,0x24ad,0x24a6,0x251b,0x24b0,0x6000c, + 0x1a,0x2523,0x1,0x1b,0x357b,0x50085,0x1a,0x2526,0x2523,0x39f4,0x6000c,0x1a, + 0x2527,0x1,0x1e,0x2526,0x7000c,0x1a,0x2531,0x1,0x1a,0x252,0x2527,0x50088, + 0x1a,0x252c,0x39f5,0x2531,0x60052,0x4a,0x3b84,0x252c,0x2512,0x0,0x60052,0x4a, + 0x3b86,0x357b,0x3b84,0x1,0x60052,0x4a,0x3b88,0x24a9,0x3b86,0x2,0x4003d,0x196, + 0x2533,0x198,0x40063,0x2533,0x19a,0x3b88,0x200f9,0x24c7,0x200f8,0x24c7,0x200f9,0x24c8, + 0x200f8,0x24c8,0x500b2,0x9d,0x1d3c,0x76e,0x647,0x300f7,0x1d3e,0x0,0x400fa,0x1d3c, + 0x1d3d,0x1d3e,0x200f8,0x1d3d,0x200f9,0x1d50,0x200f8,0x1d3e,0x50081,0x4a,0x2539,0x1e92, + 0x208b,0x50081,0x4a,0x253b,0x2539,0x2284,0x50081,0x4a,0x253d,0x253b,0x247d,0x5008e, + 0x4a,0x253e,0x253d,0x299,0x500aa,0x9d,0x2562,0x647,0xb79,0x300f7,0x2589,0x0, + 0x400fa,0x2562,0x2563,0x2589,0x200f8,0x2563,0x500aa,0x2bb,0x2565,0x87f,0x19a,0x4009b, + 0x9d,0x2566,0x2565,0x300f7,0x2588,0x0,0x400fa,0x2566,0x2567,0x2588,0x200f8,0x2567, + 0x4003d,0x196,0x25d2,0x198,0x50062,0x4a,0x25d3,0x25d2,0x19a,0x50051,0x1a,0x256a, + 0x253e,0x1,0x50051,0x1a,0x256c,0x25d3,0x1,0x50051,0x1a,0x256e,0x253e,0x0, + 0x500b8,0x9d,0x2570,0x256c,0x2cc,0x300f7,0x257e,0x0,0x400fa,0x2570,0x2571,0x257e, + 0x200f8,0x2571,0x50083,0x1a,0x2575,0x256e,0x256c,0x50041,0x165,0x25d6,0x15e,0x145, + 0x4003d,0x1a,0x25d7,0x25d6,0x4007f,0x1a,0x2577,0x25d7,0x6000c,0x1a,0x2578,0x1, + 0x1b,0x2577,0x50083,0x1a,0x2579,0x258,0x2578,0x50085,0x1a,0x257a,0x2575,0x2579, + 0x50081,0x1a,0x257b,0x256c,0x257a,0x7000c,0x1a,0x25dc,0x1,0x28,0x18d,0x257b, + 0x200f9,0x257e,0x200f8,0x257e,0x700f5,0x1a,0x3687,0x256e,0x2567,0x25dc,0x2571,0x6000c, + 0x1a,0x25e4,0x1,0x1b,0x3687,0x50085,0x1a,0x25e7,0x25e4,0x39f4,0x6000c,0x1a, + 0x25e8,0x1,0x1e,0x25e7,0x7000c,0x1a,0x25f2,0x1,0x1a,0x252,0x25e8,0x50088, + 0x1a,0x25ed,0x39f5,0x25f2,0x60052,0x4a,0x3b8d,0x25ed,0x25d3,0x0,0x60052,0x4a, + 0x3b8f,0x3687,0x3b8d,0x1,0x60052,0x4a,0x3b91,0x256a,0x3b8f,0x2,0x4003d,0x196, + 0x25f4,0x198,0x40063,0x25f4,0x19a,0x3b91,0x200f9,0x2588,0x200f8,0x2588,0x200f9,0x2589, + 0x200f8,0x2589,0x50051,0x1a,0x25fa,0x253e,0x0,0x60041,0x2f0,0x25fb,0x2ed,0x7b1, + 0x7b7,0x3003e,0x25fb,0x25fa,0x50051,0x1a,0x25ff,0x253e,0x1,0x60041,0x2f0,0x2600, + 0x2f3,0x7b1,0x7b7,0x3003e,0x2600,0x25ff,0x50051,0x1a,0x2604,0x253e,0x2,0x60041, + 0x2f0,0x2605,0x2f8,0x7b1,0x7b7,0x3003e,0x2605,0x2604,0x50051,0x1a,0x2609,0x253e, + 0x3,0x60041,0x2f0,0x260a,0x2fd,0x7b1,0x7b7,0x3003e,0x260a,0x2609,0x200f9,0x1d50, + 0x200f8,0x1d50,0x300f7,0x265c,0x0,0x300fb,0x183,0x2623,0x200f8,0x2623,0x500b2,0x9d, + 0x2626,0x76e,0x4a3,0x300f7,0x2628,0x0,0x400fa,0x2626,0x2627,0x2628,0x200f8,0x2627, + 0x200f9,0x265c,0x200f8,0x2628,0x300e1,0x13e,0x319,0x400e0,0x13e,0x13e,0x31a,0x60041, + 0x2f0,0x2690,0x2ed,0x7b1,0x7b7,0x4003d,0x1a,0x2691,0x2690,0x60041,0x2f0,0x2694, + 0x2f3,0x7b1,0x7b7,0x4003d,0x1a,0x2695,0x2694,0x60041,0x2f0,0x2698,0x2f8,0x7b1, + 0x7b7,0x4003d,0x1a,0x2699,0x2698,0x60041,0x2f0,0x269c,0x2fd,0x7b1,0x7b7,0x4003d, + 0x1a,0x269d,0x269c,0x70050,0x4a,0x269e,0x2691,0x2695,0x2699,0x269d,0x6016e,0x4a, + 0x26ab,0x13f,0x269e,0x183,0x6016e,0x4a,0x26ad,0x13f,0x269e,0x145,0x6016e,0x4a, + 0x26af,0x13f,0x269e,0x13e,0x50081,0x4a,0x26b9,0x269e,0x26ab,0x50081,0x4a,0x26bb, + 0x26b9,0x26ad,0x50081,0x4a,0x26bd,0x26bb,0x26af,0x5008e,0x4a,0x26be,0x26bd,0x299, + 0x50089,0x6,0x2670,0x737,0x1cb,0x500aa,0x9d,0x2671,0x2670,0x183,0x300f7,0x268b, + 0x0,0x400fa,0x2671,0x2672,0x268b,0x200f8,0x2672,0x50086,0x6,0x2678,0x7b1,0x13e, + 0x4007c,0x13,0x2679,0x2678,0x50086,0x6,0x267b,0x7b7,0x13e,0x4007c,0x13,0x267c, + 0x267b,0x50050,0x2e,0x267d,0x2679,0x267c,0x500aa,0x9d,0x26e2,0x4a3,0xb79,0x300f7, + 0x2709,0x0,0x400fa,0x26e2,0x26e3,0x2709,0x200f8,0x26e3,0x500aa,0x2bb,0x26e5,0x267d, + 0x19a,0x4009b,0x9d,0x26e6,0x26e5,0x300f7,0x2708,0x0,0x400fa,0x26e6,0x26e7,0x2708, + 0x200f8,0x26e7,0x4003d,0x196,0x2752,0x198,0x50062,0x4a,0x2753,0x2752,0x19a,0x50051, + 0x1a,0x26ea,0x26be,0x1,0x50051,0x1a,0x26ec,0x2753,0x1,0x50051,0x1a,0x26ee, + 0x26be,0x0,0x500b8,0x9d,0x26f0,0x26ec,0x2cc,0x300f7,0x26fe,0x0,0x400fa,0x26f0, + 0x26f1,0x26fe,0x200f8,0x26f1,0x50083,0x1a,0x26f5,0x26ee,0x26ec,0x50041,0x165,0x2756, + 0x15e,0x145,0x4003d,0x1a,0x2757,0x2756,0x4007f,0x1a,0x26f7,0x2757,0x6000c,0x1a, + 0x26f8,0x1,0x1b,0x26f7,0x50083,0x1a,0x26f9,0x258,0x26f8,0x50085,0x1a,0x26fa, + 0x26f5,0x26f9,0x50081,0x1a,0x26fb,0x26ec,0x26fa,0x7000c,0x1a,0x275c,0x1,0x28, + 0x18d,0x26fb,0x200f9,0x26fe,0x200f8,0x26fe,0x700f5,0x1a,0x3832,0x26ee,0x26e7,0x275c, + 0x26f1,0x6000c,0x1a,0x2764,0x1,0x1b,0x3832,0x50085,0x1a,0x2767,0x2764,0x39f4, + 0x6000c,0x1a,0x2768,0x1,0x1e,0x2767,0x7000c,0x1a,0x2772,0x1,0x1a,0x252, + 0x2768,0x50088,0x1a,0x276d,0x39f5,0x2772,0x60052,0x4a,0x3b9a,0x276d,0x2753,0x0, + 0x60052,0x4a,0x3b9c,0x3832,0x3b9a,0x1,0x60052,0x4a,0x3b9e,0x26ea,0x3b9c,0x2, + 0x4003d,0x196,0x2774,0x198,0x40063,0x2774,0x19a,0x3b9e,0x200f9,0x2708,0x200f8,0x2708, + 0x200f9,0x2709,0x200f8,0x2709,0x50089,0x6,0x2686,0x267b,0x13e,0x50080,0x6,0x2687, + 0x7b1,0x2686,0x50051,0x1a,0x277a,0x26be,0x0,0x60041,0x2f0,0x277b,0x2ed,0x2687, + 0x7b7,0x3003e,0x277b,0x277a,0x50051,0x1a,0x277f,0x26be,0x1,0x60041,0x2f0,0x2780, + 0x2f3,0x2687,0x7b7,0x3003e,0x2780,0x277f,0x50051,0x1a,0x2784,0x26be,0x2,0x60041, + 0x2f0,0x2785,0x2f8,0x2687,0x7b7,0x3003e,0x2785,0x2784,0x50051,0x1a,0x2789,0x26be, + 0x3,0x60041,0x2f0,0x278a,0x2fd,0x2687,0x7b7,0x3003e,0x278a,0x2789,0x200f9,0x268b, + 0x200f8,0x268b,0x500b2,0x9d,0x2634,0x76e,0x39f0,0x300f7,0x2636,0x0,0x400fa,0x2634, + 0x2635,0x2636,0x200f8,0x2635,0x200f9,0x265c,0x200f8,0x2636,0x300e1,0x13e,0x319,0x400e0, + 0x13e,0x13e,0x31a,0x500b0,0x9d,0x2799,0x737,0x3bb,0x300f7,0x27c3,0x0,0x400fa, + 0x2799,0x279a,0x27c3,0x200f8,0x279a,0x50089,0x6,0x279e,0x7b7,0x13e,0x50080,0x6, + 0x279f,0x870,0x279e,0x60041,0x2f0,0x27c8,0x2ed,0x279f,0x873,0x4003d,0x1a,0x27c9, + 0x27c8,0x60041,0x2f0,0x27cc,0x2f3,0x279f,0x873,0x4003d,0x1a,0x27cd,0x27cc,0x60041, + 0x2f0,0x27d0,0x2f8,0x279f,0x873,0x4003d,0x1a,0x27d1,0x27d0,0x60041,0x2f0,0x27d4, + 0x2fd,0x279f,0x873,0x4003d,0x1a,0x27d5,0x27d4,0x70050,0x4a,0x27d6,0x27c9,0x27cd, + 0x27d1,0x27d5,0x6016e,0x4a,0x27e3,0x13f,0x27d6,0x183,0x6016e,0x4a,0x27e5,0x13f, + 0x27d6,0x145,0x6016e,0x4a,0x27e7,0x13f,0x27d6,0x13e,0x50081,0x4a,0x27f1,0x27d6, + 0x27e3,0x50081,0x4a,0x27f3,0x27f1,0x27e5,0x50081,0x4a,0x27f5,0x27f3,0x27e7,0x5008e, + 0x4a,0x27f6,0x27f5,0x299,0x300f7,0x27c2,0x0,0x400fa,0x2671,0x27a8,0x27c2,0x200f8, + 0x27a8,0x50086,0x6,0x27ae,0x7b1,0x13e,0x4007c,0x13,0x27af,0x27ae,0x50086,0x6, + 0x27b1,0x7b7,0x13e,0x4007c,0x13,0x27b2,0x27b1,0x50050,0x2e,0x27b3,0x27af,0x27b2, + 0x500aa,0x9d,0x281a,0x39f0,0xb79,0x300f7,0x2841,0x0,0x400fa,0x281a,0x281b,0x2841, + 0x200f8,0x281b,0x500aa,0x2bb,0x281d,0x27b3,0x19a,0x4009b,0x9d,0x281e,0x281d,0x300f7, + 0x2840,0x0,0x400fa,0x281e,0x281f,0x2840,0x200f8,0x281f,0x4003d,0x196,0x288a,0x198, + 0x50062,0x4a,0x288b,0x288a,0x19a,0x50051,0x1a,0x2822,0x27f6,0x1,0x50051,0x1a, + 0x2824,0x288b,0x1,0x50051,0x1a,0x2826,0x27f6,0x0,0x500b8,0x9d,0x2828,0x2824, + 0x2cc,0x300f7,0x2836,0x0,0x400fa,0x2828,0x2829,0x2836,0x200f8,0x2829,0x50083,0x1a, + 0x282d,0x2826,0x2824,0x50041,0x165,0x288e,0x15e,0x145,0x4003d,0x1a,0x288f,0x288e, + 0x4007f,0x1a,0x282f,0x288f,0x6000c,0x1a,0x2830,0x1,0x1b,0x282f,0x50083,0x1a, + 0x2831,0x258,0x2830,0x50085,0x1a,0x2832,0x282d,0x2831,0x50081,0x1a,0x2833,0x2824, + 0x2832,0x7000c,0x1a,0x2894,0x1,0x28,0x18d,0x2833,0x200f9,0x2836,0x200f8,0x2836, + 0x700f5,0x1a,0x38c8,0x2826,0x281f,0x2894,0x2829,0x6000c,0x1a,0x289c,0x1,0x1b, + 0x38c8,0x50085,0x1a,0x289f,0x289c,0x39f4,0x6000c,0x1a,0x28a0,0x1,0x1e,0x289f, + 0x7000c,0x1a,0x28aa,0x1,0x1a,0x252,0x28a0,0x50088,0x1a,0x28a5,0x39f5,0x28aa, + 0x60052,0x4a,0x3ba7,0x28a5,0x288b,0x0,0x60052,0x4a,0x3ba9,0x38c8,0x3ba7,0x1, + 0x60052,0x4a,0x3bab,0x2822,0x3ba9,0x2,0x4003d,0x196,0x28ac,0x198,0x40063,0x28ac, + 0x19a,0x3bab,0x200f9,0x2840,0x200f8,0x2840,0x200f9,0x2841,0x200f8,0x2841,0x50080,0x6, + 0x27bd,0x870,0x27b1,0x50051,0x1a,0x28b2,0x27f6,0x0,0x60041,0x2f0,0x28b3,0x2ed, + 0x27bd,0x873,0x3003e,0x28b3,0x28b2,0x50051,0x1a,0x28b7,0x27f6,0x1,0x60041,0x2f0, + 0x28b8,0x2f3,0x27bd,0x873,0x3003e,0x28b8,0x28b7,0x50051,0x1a,0x28bc,0x27f6,0x2, + 0x60041,0x2f0,0x28bd,0x2f8,0x27bd,0x873,0x3003e,0x28bd,0x28bc,0x50051,0x1a,0x28c1, + 0x27f6,0x3,0x60041,0x2f0,0x28c2,0x2fd,0x27bd,0x873,0x3003e,0x28c2,0x28c1,0x200f9, + 0x27c2,0x200f8,0x27c2,0x200f9,0x27c3,0x200f8,0x27c3,0x500b2,0x9d,0x2643,0x76e,0x39f1, + 0x300f7,0x2645,0x0,0x400fa,0x2643,0x2644,0x2645,0x200f8,0x2644,0x200f9,0x265c,0x200f8, + 0x2645,0x300e1,0x13e,0x319,0x400e0,0x13e,0x13e,0x31a,0x500b0,0x9d,0x28d1,0x737, + 0x2e9,0x300f7,0x28f7,0x0,0x400fa,0x28d1,0x28d2,0x28f7,0x200f8,0x28d2,0x50080,0x6, + 0x28d6,0x1cd4,0x7b7,0x60041,0x2f0,0x28fc,0x2ed,0x28d6,0x1cd8,0x4003d,0x1a,0x28fd, + 0x28fc,0x60041,0x2f0,0x2900,0x2f3,0x28d6,0x1cd8,0x4003d,0x1a,0x2901,0x2900,0x60041, + 0x2f0,0x2904,0x2f8,0x28d6,0x1cd8,0x4003d,0x1a,0x2905,0x2904,0x60041,0x2f0,0x2908, + 0x2fd,0x28d6,0x1cd8,0x4003d,0x1a,0x2909,0x2908,0x70050,0x4a,0x290a,0x28fd,0x2901, + 0x2905,0x2909,0x6016e,0x4a,0x2917,0x13f,0x290a,0x183,0x6016e,0x4a,0x2919,0x13f, + 0x290a,0x145,0x6016e,0x4a,0x291b,0x13f,0x290a,0x13e,0x50081,0x4a,0x2925,0x290a, + 0x2917,0x50081,0x4a,0x2927,0x2925,0x2919,0x50081,0x4a,0x2929,0x2927,0x291b,0x5008e, + 0x4a,0x292a,0x2929,0x299,0x300f7,0x28f6,0x0,0x400fa,0x2671,0x28df,0x28f6,0x200f8, + 0x28df,0x50086,0x6,0x28e5,0x7b1,0x13e,0x4007c,0x13,0x28e6,0x28e5,0x50086,0x6, + 0x28e8,0x7b7,0x13e,0x4007c,0x13,0x28e9,0x28e8,0x50050,0x2e,0x28ea,0x28e6,0x28e9, + 0x500aa,0x9d,0x294e,0x39f1,0xb79,0x300f7,0x2975,0x0,0x400fa,0x294e,0x294f,0x2975, + 0x200f8,0x294f,0x500aa,0x2bb,0x2951,0x28ea,0x19a,0x4009b,0x9d,0x2952,0x2951,0x300f7, + 0x2974,0x0,0x400fa,0x2952,0x2953,0x2974,0x200f8,0x2953,0x4003d,0x196,0x29be,0x198, + 0x50062,0x4a,0x29bf,0x29be,0x19a,0x50051,0x1a,0x2956,0x292a,0x1,0x50051,0x1a, + 0x2958,0x29bf,0x1,0x50051,0x1a,0x295a,0x292a,0x0,0x500b8,0x9d,0x295c,0x2958, + 0x2cc,0x300f7,0x296a,0x0,0x400fa,0x295c,0x295d,0x296a,0x200f8,0x295d,0x50083,0x1a, + 0x2961,0x295a,0x2958,0x50041,0x165,0x29c2,0x15e,0x145,0x4003d,0x1a,0x29c3,0x29c2, + 0x4007f,0x1a,0x2963,0x29c3,0x6000c,0x1a,0x2964,0x1,0x1b,0x2963,0x50083,0x1a, + 0x2965,0x258,0x2964,0x50085,0x1a,0x2966,0x2961,0x2965,0x50081,0x1a,0x2967,0x2958, + 0x2966,0x7000c,0x1a,0x29c8,0x1,0x28,0x18d,0x2967,0x200f9,0x296a,0x200f8,0x296a, + 0x700f5,0x1a,0x3965,0x295a,0x2953,0x29c8,0x295d,0x6000c,0x1a,0x29d0,0x1,0x1b, + 0x3965,0x50085,0x1a,0x29d3,0x29d0,0x39f4,0x6000c,0x1a,0x29d4,0x1,0x1e,0x29d3, + 0x7000c,0x1a,0x29de,0x1,0x1a,0x252,0x29d4,0x50088,0x1a,0x29d9,0x39f5,0x29de, + 0x60052,0x4a,0x3bb4,0x29d9,0x29bf,0x0,0x60052,0x4a,0x3bb6,0x3965,0x3bb4,0x1, + 0x60052,0x4a,0x3bb8,0x2956,0x3bb6,0x2,0x4003d,0x196,0x29e0,0x198,0x40063,0x29e0, + 0x19a,0x3bb8,0x200f9,0x2974,0x200f8,0x2974,0x200f9,0x2975,0x200f8,0x2975,0x50080,0x6, + 0x28f3,0x28e5,0x7b7,0x50051,0x1a,0x29e6,0x292a,0x0,0x60041,0x2f0,0x29e7,0x2ed, + 0x28f3,0x183,0x3003e,0x29e7,0x29e6,0x50051,0x1a,0x29eb,0x292a,0x1,0x60041,0x2f0, + 0x29ec,0x2f3,0x28f3,0x183,0x3003e,0x29ec,0x29eb,0x50051,0x1a,0x29f0,0x292a,0x2, + 0x60041,0x2f0,0x29f1,0x2f8,0x28f3,0x183,0x3003e,0x29f1,0x29f0,0x50051,0x1a,0x29f5, + 0x292a,0x3,0x60041,0x2f0,0x29f6,0x2fd,0x28f3,0x183,0x3003e,0x29f6,0x29f5,0x200f9, + 0x28f6,0x200f8,0x28f6,0x200f9,0x28f7,0x200f8,0x28f7,0x500b2,0x9d,0x2652,0x76e,0x39f2, + 0x300f7,0x2654,0x0,0x400fa,0x2652,0x2653,0x2654,0x200f8,0x2653,0x200f9,0x265c,0x200f8, + 0x2654,0x300e1,0x13e,0x319,0x400e0,0x13e,0x13e,0x31a,0x500b0,0x9d,0x2a02,0x737, + 0x1cb,0x300f7,0x2a13,0x0,0x400fa,0x2a02,0x2a03,0x2a13,0x200f8,0x2a03,0x60041,0x2f0, + 0x2a18,0x2ed,0x737,0x183,0x4003d,0x1a,0x2a19,0x2a18,0x60041,0x2f0,0x2a1c,0x2f3, + 0x737,0x183,0x4003d,0x1a,0x2a1d,0x2a1c,0x60041,0x2f0,0x2a20,0x2f8,0x737,0x183, + 0x4003d,0x1a,0x2a21,0x2a20,0x60041,0x2f0,0x2a24,0x2fd,0x737,0x183,0x4003d,0x1a, + 0x2a25,0x2a24,0x70050,0x4a,0x2a26,0x2a19,0x2a1d,0x2a21,0x2a25,0x6016e,0x4a,0x2a33, + 0x13f,0x2a26,0x183,0x6016e,0x4a,0x2a35,0x13f,0x2a26,0x145,0x6016e,0x4a,0x2a37, + 0x13f,0x2a26,0x13e,0x50081,0x4a,0x2a41,0x2a26,0x2a33,0x50081,0x4a,0x2a43,0x2a41, + 0x2a35,0x50081,0x4a,0x2a45,0x2a43,0x2a37,0x5008e,0x4a,0x2a46,0x2a45,0x299,0x300f7, + 0x2a12,0x0,0x400fa,0x2671,0x2a0b,0x2a12,0x200f8,0x2a0b,0x500aa,0x9d,0x2a6a,0x39f2, + 0xb79,0x300f7,0x2a91,0x0,0x400fa,0x2a6a,0x2a6b,0x2a91,0x200f8,0x2a6b,0x4009b,0x9d, + 0x2a6e,0x39f6,0x300f7,0x2a90,0x0,0x400fa,0x2a6e,0x2a6f,0x2a90,0x200f8,0x2a6f,0x4003d, + 0x196,0x2ada,0x198,0x50062,0x4a,0x2adb,0x2ada,0x19a,0x50051,0x1a,0x2a72,0x2a46, + 0x1,0x50051,0x1a,0x2a74,0x2adb,0x1,0x50051,0x1a,0x2a76,0x2a46,0x0,0x500b8, + 0x9d,0x2a78,0x2a74,0x2cc,0x300f7,0x2a86,0x0,0x400fa,0x2a78,0x2a79,0x2a86,0x200f8, + 0x2a79,0x50083,0x1a,0x2a7d,0x2a76,0x2a74,0x50041,0x165,0x2ade,0x15e,0x145,0x4003d, + 0x1a,0x2adf,0x2ade,0x4007f,0x1a,0x2a7f,0x2adf,0x6000c,0x1a,0x2a80,0x1,0x1b, + 0x2a7f,0x50083,0x1a,0x2a81,0x258,0x2a80,0x50085,0x1a,0x2a82,0x2a7d,0x2a81,0x50081, + 0x1a,0x2a83,0x2a74,0x2a82,0x7000c,0x1a,0x2ae4,0x1,0x28,0x18d,0x2a83,0x200f9, + 0x2a86,0x200f8,0x2a86,0x700f5,0x1a,0x39e8,0x2a76,0x2a6f,0x2ae4,0x2a79,0x6000c,0x1a, + 0x2aec,0x1,0x1b,0x39e8,0x50085,0x1a,0x2aef,0x2aec,0x39f4,0x6000c,0x1a,0x2af0, + 0x1,0x1e,0x2aef,0x7000c,0x1a,0x2afa,0x1,0x1a,0x252,0x2af0,0x50088,0x1a, + 0x2af5,0x39f5,0x2afa,0x60052,0x4a,0x3bc1,0x2af5,0x2adb,0x0,0x60052,0x4a,0x3bc3, + 0x39e8,0x3bc1,0x1,0x60052,0x4a,0x3bc5,0x2a72,0x3bc3,0x2,0x4003d,0x196,0x2afc, + 0x198,0x40063,0x2afc,0x19a,0x3bc5,0x200f9,0x2a90,0x200f8,0x2a90,0x200f9,0x2a91,0x200f8, + 0x2a91,0x200f9,0x2a12,0x200f8,0x2a12,0x200f9,0x2a13,0x200f8,0x2a13,0x200f9,0x265c,0x200f8, + 0x265c,0x200f9,0x7dd,0x200f8,0x7dd,0x100fd,0x10038, +}; +static const char *fu0_luma_pyramid_pass_0_cb_names[] = {"cbFSR3Upscaler", "cbSPD"}; +static const uint32_t fu0_luma_pyramid_pass_0_cb_bind[] = {11, 12}; +static const uint32_t fu0_luma_pyramid_pass_0_cb_count[] = {1, 1}; +static const uint32_t fu0_luma_pyramid_pass_0_cb_space[] = {0, 0}; +static const char *fu0_luma_pyramid_pass_0_srv_tex_names[] = {"r_current_luma", "r_farthest_depth"}; +static const uint32_t fu0_luma_pyramid_pass_0_srv_tex_bind[] = {0, 1}; +static const uint32_t fu0_luma_pyramid_pass_0_srv_tex_count[] = {1, 1}; +static const uint32_t fu0_luma_pyramid_pass_0_srv_tex_space[] = {0, 0}; +static const char *fu0_luma_pyramid_pass_0_uav_tex_names[] = {"rw_spd_global_atomic", "rw_frame_info", "rw_spd_mip5", "rw_farthest_depth_mip1"}; +static const uint32_t fu0_luma_pyramid_pass_0_uav_tex_bind[] = {2, 3, 9, 10}; +static const uint32_t fu0_luma_pyramid_pass_0_uav_tex_count[] = {1, 1, 1, 1}; +static const uint32_t fu0_luma_pyramid_pass_0_uav_tex_space[] = {0, 0, 0, 0}; + +static const uint32_t fu0_shading_change_pyramid_pass_0_spv[27480] = { + 0x7230203,0x10500,0x8000b,0x97b3,0x0,0x20011,0x1,0x20011,0x31,0x20011,0x3d,0x20011, + 0x44,0x6000b,0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0x19000f,0x5, + 0x4,0x6e69616d,0x0,0x18b,0x1a9,0x1bb,0x1c3,0x1ca,0x1d2,0x1e6,0x1f0,0x1fa, + 0x204,0x20f,0x219,0x260,0x2b0,0x4c3,0x4c9,0x4ce,0x4d3,0x905,0x907,0x60010, + 0x4,0x11,0x100,0x1,0x1,0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61, + 0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0,0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72, + 0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79, + 0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669, + 0x90004,0x4b5f4c47,0x735f5248,0x65646168,0x75735f72,0x6f726762,0x625f7075,0x63697361,0x0,0x80004,0x4b5f4c47,0x735f5248, + 0x65646168,0x75735f72,0x6f726762,0x715f7075,0x646175,0x40005,0x4,0x6e69616d,0x0,0x70005,0x189,0x53466263, + 0x50553352,0x4c414353,0x745f5245,0x0,0x60006,0x189,0x0,0x6e655269,0x53726564,0x657a69,0xa0006,0x189, + 0x1,0x65725069,0x756f6976,0x61724673,0x6552656d,0x7265646e,0x657a6953,0x0,0x50006,0x189,0x2,0x74694a66, + 0x726574,0x90006,0x189,0x3,0x65725066,0x756f6976,0x61724673,0x694a656d,0x72657474,0x0,0x80006,0x189, + 0x4,0x6c654466,0x72506174,0x70784565,0x7275736f,0x65,0x60005,0x18b,0x53466263,0x70553352,0x6c616373,0x7265, + 0x40005,0x1a7,0x50536263,0x745f44,0x50006,0x1a7,0x0,0x7370696d,0x0,0x70006,0x1a7,0x1, + 0x576d756e,0x476b726f,0x70756f72,0x73,0x70006,0x1a7,0x2,0x6b726f77,0x756f7247,0x66664f70,0x746573,0x40005, + 0x1a9,0x50536263,0x44,0x60005,0x1bb,0x75635f72,0x6e657272,0x756c5f74,0x616d,0x60005,0x1c3,0x72705f72, + 0x6f697665,0x6c5f7375,0x616d75,0x90005,0x1ca,0x69645f72,0x6574616c,0x6f6d5f64,0x6e6f6974,0x6365765f,0x73726f74,0x0, + 0x70005,0x1d2,0x6e695f72,0x5f747570,0x6f707865,0x65727573,0x0,0x50005,0x1e6,0x735f7772,0x6d5f6470,0x307069, + 0x50005,0x1f0,0x735f7772,0x6d5f6470,0x317069,0x50005,0x1fa,0x735f7772,0x6d5f6470,0x327069,0x50005,0x204, + 0x735f7772,0x6d5f6470,0x337069,0x50005,0x20f,0x735f7772,0x6d5f6470,0x347069,0x50005,0x219,0x735f7772,0x6d5f6470, + 0x357069,0x80005,0x260,0x735f7772,0x675f6470,0x61626f6c,0x74615f6c,0x63696d6f,0x0,0x50005,0x2b0,0x43647073, + 0x746e756f,0x7265,0x70005,0x4c3,0x49647073,0x7265746e,0x6964656d,0x52657461,0x0,0x70005,0x4c9,0x49647073, + 0x7265746e,0x6964656d,0x47657461,0x0,0x70005,0x4ce,0x49647073,0x7265746e,0x6964656d,0x42657461,0x0,0x70005, + 0x4d3,0x49647073,0x7265746e,0x6964656d,0x41657461,0x0,0x60005,0x905,0x575f6c67,0x476b726f,0x70756f72,0x4449, + 0x80005,0x907,0x4c5f6c67,0x6c61636f,0x6f766e49,0x69746163,0x6e496e6f,0x786564,0x30047,0x189,0x2,0x50048, + 0x189,0x0,0x23,0x0,0x50048,0x189,0x1,0x23,0x8,0x50048,0x189,0x2, + 0x23,0x40,0x50048,0x189,0x3,0x23,0x48,0x50048,0x189,0x4,0x23,0x74, + 0x40047,0x18b,0x21,0xb,0x40047,0x18b,0x22,0x0,0x30047,0x1a7,0x2,0x50048, + 0x1a7,0x0,0x23,0x0,0x50048,0x1a7,0x1,0x23,0x4,0x50048,0x1a7,0x2, + 0x23,0x8,0x40047,0x1a9,0x21,0xc,0x40047,0x1a9,0x22,0x0,0x40047,0x1bb, + 0x21,0x0,0x40047,0x1bb,0x22,0x0,0x40047,0x1c3,0x21,0x1,0x40047,0x1c3, + 0x22,0x0,0x40047,0x1ca,0x21,0x2,0x40047,0x1ca,0x22,0x0,0x40047,0x1d2, + 0x21,0x3,0x40047,0x1d2,0x22,0x0,0x40047,0x1e6,0x21,0x5,0x40047,0x1e6, + 0x22,0x0,0x40047,0x1f0,0x21,0x6,0x40047,0x1f0,0x22,0x0,0x40047,0x1fa, + 0x21,0x7,0x40047,0x1fa,0x22,0x0,0x40047,0x204,0x21,0x8,0x40047,0x204, + 0x22,0x0,0x40047,0x20f,0x21,0x9,0x40047,0x20f,0x22,0x0,0x30047,0x219, + 0x17,0x40047,0x219,0x21,0xa,0x40047,0x219,0x22,0x0,0x30047,0x260,0x17, + 0x40047,0x260,0x21,0x4,0x40047,0x260,0x22,0x0,0x40047,0x905,0xb,0x1a, + 0x40047,0x907,0xb,0x1d,0x40047,0x91a,0xb,0x19,0x30047,0xc0e,0x18,0x30047, + 0xcad,0x18,0x30047,0x1072,0x18,0x30047,0x1111,0x18,0x30047,0x14d6,0x18,0x30047, + 0x1575,0x18,0x30047,0x193a,0x18,0x30047,0x19d9,0x18,0x30047,0x1e2e,0x18,0x30047, + 0x1ecd,0x18,0x30047,0x2292,0x18,0x30047,0x2331,0x18,0x30047,0x26f6,0x18,0x30047, + 0x2795,0x18,0x30047,0x2b5a,0x18,0x30047,0x2bf9,0x18,0x30047,0x304e,0x18,0x30047, + 0x30ed,0x18,0x30047,0x34b2,0x18,0x30047,0x3551,0x18,0x30047,0x3916,0x18,0x30047, + 0x39b5,0x18,0x30047,0x3d7a,0x18,0x30047,0x3e19,0x18,0x30047,0x426e,0x18,0x30047, + 0x430d,0x18,0x30047,0x46d2,0x18,0x30047,0x4771,0x18,0x30047,0x4b36,0x18,0x30047, + 0x4bd5,0x18,0x30047,0x4f9a,0x18,0x30047,0x5039,0x18,0x20013,0x2,0x30021,0x3, + 0x2,0x40015,0x6,0x20,0x0,0x30016,0x13,0x20,0x40020,0x14,0x7,0x13, + 0x40015,0x1a,0x20,0x1,0x40017,0x2d,0x6,0x2,0x40017,0x32,0x1a,0x2, + 0x40017,0x38,0x13,0x2,0x40020,0x49,0x7,0x32,0x20014,0x6e,0x4002b,0x6, + 0x81,0x5,0x4001c,0x82,0x13,0x81,0x40017,0x9f,0x13,0x4,0x40017,0x13b, + 0x6,0x3,0x4002b,0x1a,0x14c,0x0,0x4002b,0x6,0x16b,0x2,0x4002b,0x6, + 0x16c,0x3,0x4002b,0x6,0x172,0x1,0x7001e,0x189,0x32,0x32,0x38,0x38, + 0x13,0x40020,0x18a,0x2,0x189,0x4003b,0x18a,0x18b,0x2,0x40020,0x18c,0x2, + 0x32,0x4002b,0x1a,0x191,0x1,0x4002b,0x1a,0x196,0x7,0x40020,0x197,0x2, + 0x38,0x40020,0x1a2,0x2,0x13,0x5001e,0x1a7,0x6,0x6,0x2d,0x40020,0x1a8, + 0x2,0x1a7,0x4003b,0x1a8,0x1a9,0x2,0x40020,0x1aa,0x2,0x6,0x4002b,0x1a, + 0x1b3,0x2,0x40020,0x1b4,0x2,0x2d,0x90019,0x1b9,0x13,0x1,0x0,0x0, + 0x0,0x1,0x0,0x40020,0x1ba,0x0,0x1b9,0x4003b,0x1ba,0x1bb,0x0,0x4002b, + 0x6,0x1bf,0x0,0x4003b,0x1ba,0x1c3,0x0,0x4003b,0x1ba,0x1ca,0x0,0x4003b, + 0x1ba,0x1d2,0x0,0x5002c,0x32,0x1d4,0x14c,0x14c,0x4002b,0x13,0x1d8,0x0, + 0x4002b,0x13,0x1dc,0x3f800000,0x90019,0x1e4,0x13,0x1,0x0,0x0,0x0,0x2, + 0x7,0x40020,0x1e5,0x0,0x1e4,0x4003b,0x1e5,0x1e6,0x0,0x4003b,0x1e5,0x1f0, + 0x0,0x4003b,0x1e5,0x1fa,0x0,0x4003b,0x1e5,0x204,0x0,0x4002b,0x6,0x20b, + 0x4,0x4003b,0x1e5,0x20f,0x0,0x4003b,0x1e5,0x219,0x0,0x90019,0x25e,0x6, + 0x1,0x0,0x0,0x0,0x2,0x21,0x40020,0x25f,0x0,0x25e,0x4003b,0x25f, + 0x260,0x0,0x40020,0x261,0xb,0x6,0x40017,0x265,0x6,0x4,0x7002c,0x265, + 0x266,0x1bf,0x1bf,0x1bf,0x1bf,0x40020,0x2af,0x4,0x6,0x4003b,0x2af,0x2b0, + 0x4,0x4002b,0x1a,0x2ba,0x3,0x4002b,0x1a,0x2cd,0x4,0x4002b,0x13,0x35e, + 0x477fdf00,0x4002b,0x13,0x372,0x800000,0x4002b,0x1a,0x37d,0x5,0x4002b,0x13,0x380, + 0x477fe000,0x4002b,0x13,0x38d,0x387fda40,0x4001c,0x3d9,0x32,0x81,0x4002b,0x1a,0x3da, + 0xffffffff,0x5002c,0x32,0x3db,0x3da,0x14c,0x5002c,0x32,0x3dc,0x191,0x14c,0x5002c, + 0x32,0x3dd,0x14c,0x3da,0x5002c,0x32,0x3de,0x14c,0x191,0x8002c,0x3d9,0x3df, + 0x1d4,0x3db,0x3dc,0x3dd,0x3de,0x40020,0x3e5,0x7,0x3d9,0x4002b,0x13,0x47f, + 0x3f000000,0x7002c,0x9f,0x48e,0x1d8,0x1d8,0x1d8,0x1d8,0x4002b,0x13,0x4af,0x3e800000, + 0x4002b,0x6,0x4bf,0x10,0x4001c,0x4c0,0x13,0x4bf,0x4001c,0x4c1,0x4c0,0x4bf, + 0x40020,0x4c2,0x4,0x4c1,0x4003b,0x4c2,0x4c3,0x4,0x40020,0x4c6,0x4,0x13, + 0x4003b,0x4c2,0x4c9,0x4,0x4003b,0x4c2,0x4ce,0x4,0x4003b,0x4c2,0x4d3,0x4, + 0x4002b,0x6,0x4ef,0xd48,0x4002b,0x6,0x4f0,0x108,0x5002c,0x2d,0x542,0x1bf, + 0x172,0x5002c,0x2d,0x545,0x172,0x1bf,0x5002c,0x2d,0x548,0x172,0x172,0x4002b, + 0x6,0x591,0x40,0x4002b,0x6,0x59f,0x20,0x4002b,0x6,0x678,0x8,0x4002b, + 0x6,0x7af,0x6,0x4002b,0x6,0x81c,0x7,0x4002b,0x1a,0x899,0x6,0x40020, + 0x904,0x1,0x13b,0x4003b,0x904,0x905,0x1,0x40020,0x906,0x1,0x6,0x4003b, + 0x906,0x907,0x1,0x4002b,0x6,0x919,0x100,0x6002c,0x13b,0x91a,0x919,0x172, + 0x172,0x40020,0x63a0,0x7,0x82,0x5002c,0x2d,0x94fb,0x591,0x591,0x5002c,0x2d, + 0x94fc,0x59f,0x59f,0x5002c,0x38,0x94fd,0x47f,0x47f,0x5002c,0x2d,0x94fe,0x4bf, + 0x4bf,0x5002c,0x2d,0x94ff,0x678,0x678,0x5002c,0x2d,0x9500,0x20b,0x20b,0x5002c, + 0x2d,0x9501,0x16b,0x16b,0x4002b,0x6,0x9502,0x9,0x4002b,0x6,0x9503,0xa, + 0x4002b,0x6,0x9504,0xb,0x50036,0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003b, + 0x63a0,0x7345,0x7,0x4003b,0x63a0,0x72f5,0x7,0x4003b,0x63a0,0x72a5,0x7,0x4003b, + 0x63a0,0x7255,0x7,0x4003b,0x63a0,0x7205,0x7,0x4003b,0x63a0,0x71b5,0x7,0x4003b, + 0x63a0,0x7165,0x7,0x4003b,0x63a0,0x7115,0x7,0x4003b,0x63a0,0x70c5,0x7,0x4003b, + 0x63a0,0x7075,0x7,0x4003b,0x63a0,0x7025,0x7,0x4003b,0x63a0,0x6fd5,0x7,0x4003b, + 0x63a0,0x6f85,0x7,0x4003b,0x63a0,0x6f35,0x7,0x4003b,0x63a0,0x6ee5,0x7,0x4003b, + 0x63a0,0x6e95,0x7,0x4003b,0x63a0,0x6e67,0x7,0x4003b,0x63a0,0x6e5d,0x7,0x4003b, + 0x63a0,0x6e49,0x7,0x4003b,0x63a0,0x6dba,0x7,0x4003b,0x63a0,0x6db0,0x7,0x4003b, + 0x63a0,0x6d9c,0x7,0x4003b,0x63a0,0x6d0d,0x7,0x4003b,0x63a0,0x6d03,0x7,0x4003b, + 0x63a0,0x6cef,0x7,0x4003b,0x63a0,0x6c60,0x7,0x4003b,0x63a0,0x6c56,0x7,0x4003b, + 0x63a0,0x6c42,0x7,0x4003b,0x63a0,0x6bb3,0x7,0x4003b,0x63a0,0x6ba9,0x7,0x4003b, + 0x63a0,0x6b95,0x7,0x4003b,0x63a0,0x6b06,0x7,0x4003b,0x63a0,0x6afc,0x7,0x4003b, + 0x63a0,0x6ae8,0x7,0x4003b,0x63a0,0x6a59,0x7,0x4003b,0x63a0,0x6a4f,0x7,0x4003b, + 0x63a0,0x6a3b,0x7,0x4003b,0x63a0,0x69ac,0x7,0x4003b,0x63a0,0x69a2,0x7,0x4003b, + 0x63a0,0x698e,0x7,0x4003b,0x63a0,0x68ff,0x7,0x4003b,0x63a0,0x68f5,0x7,0x4003b, + 0x63a0,0x68e1,0x7,0x4003b,0x63a0,0x6852,0x7,0x4003b,0x63a0,0x6848,0x7,0x4003b, + 0x63a0,0x6834,0x7,0x4003b,0x63a0,0x67a5,0x7,0x4003b,0x63a0,0x679b,0x7,0x4003b, + 0x63a0,0x6787,0x7,0x4003b,0x63a0,0x66f8,0x7,0x4003b,0x63a0,0x66ee,0x7,0x4003b, + 0x63a0,0x66da,0x7,0x4003b,0x63a0,0x664b,0x7,0x4003b,0x63a0,0x6641,0x7,0x4003b, + 0x63a0,0x662d,0x7,0x4003b,0x63a0,0x659e,0x7,0x4003b,0x63a0,0x6594,0x7,0x4003b, + 0x63a0,0x6580,0x7,0x4003b,0x63a0,0x64f1,0x7,0x4003b,0x63a0,0x64e7,0x7,0x4003b, + 0x63a0,0x64d3,0x7,0x4003b,0x63a0,0x6444,0x7,0x4003b,0x63a0,0x643a,0x7,0x4003b, + 0x63a0,0x6426,0x7,0x5003b,0x3e5,0x5039,0x7,0x3df,0x5003b,0x3e5,0x4f9a,0x7, + 0x3df,0x5003b,0x3e5,0x4bd5,0x7,0x3df,0x5003b,0x3e5,0x4b36,0x7,0x3df,0x5003b, + 0x3e5,0x4771,0x7,0x3df,0x5003b,0x3e5,0x46d2,0x7,0x3df,0x5003b,0x3e5,0x430d, + 0x7,0x3df,0x5003b,0x3e5,0x426e,0x7,0x3df,0x5003b,0x3e5,0x3e19,0x7,0x3df, + 0x5003b,0x3e5,0x3d7a,0x7,0x3df,0x5003b,0x3e5,0x39b5,0x7,0x3df,0x5003b,0x3e5, + 0x3916,0x7,0x3df,0x5003b,0x3e5,0x3551,0x7,0x3df,0x5003b,0x3e5,0x34b2,0x7, + 0x3df,0x5003b,0x3e5,0x30ed,0x7,0x3df,0x5003b,0x3e5,0x304e,0x7,0x3df,0x5003b, + 0x3e5,0x2bf9,0x7,0x3df,0x5003b,0x3e5,0x2b5a,0x7,0x3df,0x5003b,0x3e5,0x2795, + 0x7,0x3df,0x5003b,0x3e5,0x26f6,0x7,0x3df,0x5003b,0x3e5,0x2331,0x7,0x3df, + 0x5003b,0x3e5,0x2292,0x7,0x3df,0x5003b,0x3e5,0x1ecd,0x7,0x3df,0x5003b,0x3e5, + 0x1e2e,0x7,0x3df,0x5003b,0x3e5,0x19d9,0x7,0x3df,0x5003b,0x3e5,0x193a,0x7, + 0x3df,0x5003b,0x3e5,0x1575,0x7,0x3df,0x5003b,0x3e5,0x14d6,0x7,0x3df,0x5003b, + 0x3e5,0x1111,0x7,0x3df,0x5003b,0x3e5,0x1072,0x7,0x3df,0x5003b,0x3e5,0xcad, + 0x7,0x3df,0x5003b,0x3e5,0xc0e,0x7,0x3df,0x4003d,0x13b,0x909,0x905,0x4003d, + 0x6,0x90b,0x907,0x7004f,0x2d,0x936,0x909,0x909,0x0,0x1,0x50041,0x1aa, + 0x940,0x1a9,0x14c,0x4003d,0x6,0x941,0x940,0x50041,0x1aa,0x944,0x1a9,0x191, + 0x4003d,0x6,0x945,0x944,0x50041,0x1b4,0x948,0x1a9,0x1b3,0x4003d,0x2d,0x949, + 0x948,0x50080,0x2d,0x952,0x936,0x949,0x300f7,0x9b0,0x0,0x300fb,0x1bf,0x97a, + 0x200f8,0x97a,0x50089,0x6,0x97c,0x90b,0x591,0x600cb,0x6,0x9d3,0x97c,0x1b3, + 0x2ba,0x700c9,0x6,0x9da,0x9d3,0x97c,0x14c,0x191,0x600cb,0x6,0x9e2,0x97c, + 0x2ba,0x2ba,0x600cb,0x6,0x9ea,0x97c,0x191,0x1b3,0x700c9,0x6,0x9f1,0x9e2, + 0x9ea,0x14c,0x1b3,0x500c2,0x6,0x981,0x90b,0x899,0x50089,0x6,0x982,0x981, + 0x16b,0x50084,0x6,0x983,0x678,0x982,0x50080,0x6,0x984,0x9da,0x983,0x500c2, + 0x6,0x988,0x90b,0x196,0x50084,0x6,0x989,0x678,0x988,0x50080,0x6,0x98a, + 0x9f1,0x989,0x300f7,0xb43,0x0,0x300fb,0x1bf,0xa3d,0x200f8,0xa3d,0x50084,0x2d, + 0xa40,0x952,0x94fb,0x4007c,0x32,0xa41,0xa40,0x50084,0x6,0xa43,0x984,0x16b, + 0x4007c,0x1a,0xa44,0xa43,0x50084,0x6,0xa46,0x98a,0x16b,0x4007c,0x1a,0xa47, + 0xa46,0x50050,0x32,0xa48,0xa44,0xa47,0x50080,0x32,0xa49,0xa41,0xa48,0x50084, + 0x2d,0xa4c,0x952,0x94fc,0x4007c,0x32,0xa4d,0xa4c,0x4007c,0x1a,0xa4f,0x984, + 0x4007c,0x1a,0xa51,0x98a,0x50050,0x32,0xa52,0xa4f,0xa51,0x50080,0x32,0xa53, + 0xa4d,0xa52,0x4007c,0x2d,0xa55,0xa49,0x50080,0x2d,0xb4e,0xa55,0x542,0x50080, + 0x2d,0xb50,0xa55,0x545,0x50080,0x2d,0xb52,0xa55,0x548,0x4006f,0x38,0xb69, + 0xa49,0x4006e,0x32,0xb90,0xb69,0x50041,0x18c,0xbaf,0x18b,0x14c,0x4003d,0x32, + 0xbb0,0xbaf,0x50051,0x1a,0xbc0,0xbb0,0x0,0x50082,0x1a,0xbc1,0xbc0,0x191, + 0x50051,0x1a,0xbc3,0xb90,0x0,0x7000c,0x1a,0xbd4,0x1,0x27,0xbc3,0xbc1, + 0x7000c,0x1a,0xbd9,0x1,0x2a,0x14c,0xbd4,0x50051,0x1a,0xbc8,0xbb0,0x1, + 0x50082,0x1a,0xbc9,0xbc8,0x191,0x50051,0x1a,0xbcb,0xb90,0x1,0x7000c,0x1a, + 0xbde,0x1,0x27,0xbcb,0xbc9,0x7000c,0x1a,0xbe3,0x1,0x2a,0x14c,0xbde, + 0x50050,0x32,0x9783,0xbd9,0xbe3,0x4003d,0x1b9,0xbe6,0x1ca,0x7005f,0x9f,0xbe8, + 0xbe6,0x9783,0x2,0x14c,0x7004f,0x38,0xbe9,0xbe8,0xbe8,0x0,0x1,0x4006f, + 0x38,0xb96,0x9783,0x50081,0x38,0xb98,0xb96,0x94fd,0x4006f,0x38,0xb9a,0xbb0, + 0x50088,0x38,0xb9b,0xb98,0xb9a,0x3003e,0xc0e,0x3df,0x50041,0x197,0xc48,0x18b, + 0x16b,0x4003d,0x38,0xc49,0xc48,0x50088,0x38,0xc1c,0xc49,0xb9a,0x50081,0x38, + 0xc1d,0xb9b,0xc1c,0x50085,0x38,0xc21,0xc1d,0xb9a,0x6000c,0x38,0xc22,0x1, + 0x8,0xc21,0x4006e,0x32,0xc23,0xc22,0x200f9,0xc24,0x200f8,0xc24,0x700f5,0x1a, + 0x7575,0x14c,0xa3d,0xc43,0xc28,0x500b1,0x6e,0xc27,0x7575,0x37d,0x400f6,0xc44, + 0xc28,0x0,0x400fa,0xc27,0xc28,0xc44,0x200f8,0xc28,0x50041,0x49,0xc2c,0xc0e, + 0x7575,0x4003d,0x32,0xc2d,0xc2c,0x50080,0x32,0xc63,0xc23,0xc2d,0x50051,0x1a, + 0xc68,0xc63,0x0,0x7000c,0x1a,0xc79,0x1,0x27,0xc68,0xbc1,0x7000c,0x1a, + 0xc7e,0x1,0x2a,0x14c,0xc79,0x50051,0x1a,0xc70,0xc63,0x1,0x7000c,0x1a, + 0xc83,0x1,0x27,0xc70,0xbc9,0x7000c,0x1a,0xc88,0x1,0x2a,0x14c,0xc83, + 0x50050,0x32,0x97b2,0xc7e,0xc88,0x4003d,0x1b9,0xc8b,0x1bb,0x7005f,0x9f,0xc8d, + 0xc8b,0x97b2,0x2,0x14c,0x50051,0x13,0xc8e,0xc8d,0x0,0x4003d,0x1b9,0xc92, + 0x1d2,0x7005f,0x9f,0xc93,0xc92,0x1d4,0x2,0x14c,0x50051,0x13,0xc94,0xc93, + 0x0,0x500b4,0x6e,0xc96,0xc94,0x1d8,0x600a9,0x13,0x9505,0xc96,0x1dc,0xc94, + 0x50085,0x13,0xc33,0xc8e,0x9505,0x50041,0x14,0x6e4a,0x6e49,0x7575,0x3003e,0x6e4a, + 0xc33,0x4003d,0x13,0xc38,0x6e4a,0x7000c,0x13,0xc9e,0x1,0x1a,0xc38,0x1dc, + 0x3003e,0x6e4a,0xc9e,0x4003d,0x13,0xc3e,0x6e4a,0x7000c,0x13,0xca3,0x1,0x28, + 0xc3e,0x38d,0x3003e,0x6e4a,0xca3,0x50080,0x1a,0xc43,0x7575,0x191,0x200f9,0xc24, + 0x200f8,0xc44,0x4003d,0x82,0x6e4f,0x6e49,0x3003e,0xcad,0x3df,0x50041,0x197,0xcf2, + 0x18b,0x16c,0x4003d,0x38,0xcf3,0xcf2,0x50041,0x18c,0xcf6,0x18b,0x191,0x4003d, + 0x32,0xcf7,0xcf6,0x4006f,0x38,0xcb9,0xcf7,0x50088,0x38,0xcba,0xcf3,0xcb9, + 0x50081,0x38,0xcbb,0xb9b,0xcba,0x50081,0x38,0xcbe,0xcbb,0xbe9,0x50051,0x13, + 0xcfb,0xcbe,0x0,0x500be,0x6e,0xcfc,0xcfb,0x1d8,0x300f7,0xd01,0x0,0x400fa, + 0xcfc,0xcfd,0xd01,0x200f8,0xcfd,0x500bc,0x6e,0xd00,0xcfb,0x1dc,0x200f9,0xd01, + 0x200f8,0xd01,0x700f5,0x6e,0xd02,0xcfc,0xc44,0xd00,0xcfd,0x300f7,0xd0d,0x0, + 0x400fa,0xd02,0xd03,0xd0d,0x200f8,0xd03,0x50051,0x13,0xd05,0xcbe,0x1,0x500be, + 0x6e,0xd06,0xd05,0x1d8,0x300f7,0xd0b,0x0,0x400fa,0xd06,0xd07,0xd0b,0x200f8, + 0xd07,0x500bc,0x6e,0xd0a,0xd05,0x1dc,0x200f9,0xd0b,0x200f8,0xd0b,0x700f5,0x6e, + 0xd0c,0xd06,0xd03,0xd0a,0xd07,0x200f9,0xd0d,0x200f8,0xd0d,0x700f5,0x6e,0xd0e, + 0xd02,0xd01,0xd0c,0xd0b,0x300f7,0xcee,0x0,0x400fa,0xd0e,0xcc4,0xcee,0x200f8, + 0xcc4,0x50085,0x38,0xcc8,0xcbe,0xcb9,0x6000c,0x38,0xcc9,0x1,0x8,0xcc8, + 0x4006e,0x32,0xcca,0xcc9,0x200f9,0xccb,0x200f8,0xccb,0x700f5,0x1a,0x757b,0x14c, + 0xcc4,0xcec,0xccf,0x500b1,0x6e,0xcce,0x757b,0x37d,0x400f6,0xced,0xccf,0x0, + 0x400fa,0xcce,0xccf,0xced,0x200f8,0xccf,0x50041,0x49,0xcd3,0xcad,0x757b,0x4003d, + 0x32,0xcd4,0xcd3,0x50080,0x32,0xd24,0xcca,0xcd4,0x50051,0x1a,0xd26,0xcf7, + 0x0,0x50082,0x1a,0xd27,0xd26,0x191,0x50051,0x1a,0xd29,0xd24,0x0,0x7000c, + 0x1a,0xd3a,0x1,0x27,0xd29,0xd27,0x7000c,0x1a,0xd3f,0x1,0x2a,0x14c, + 0xd3a,0x50051,0x1a,0xd2e,0xcf7,0x1,0x50082,0x1a,0xd2f,0xd2e,0x191,0x50051, + 0x1a,0xd31,0xd24,0x1,0x7000c,0x1a,0xd44,0x1,0x27,0xd31,0xd2f,0x7000c, + 0x1a,0xd49,0x1,0x2a,0x14c,0xd44,0x50050,0x32,0x97b1,0xd3f,0xd49,0x4003d, + 0x1b9,0xd4c,0x1c3,0x7005f,0x9f,0xd4e,0xd4c,0x97b1,0x2,0x14c,0x50051,0x13, + 0xd4f,0xd4e,0x0,0x50041,0x1a2,0xd52,0x18b,0x20b,0x4003d,0x13,0xd53,0xd52, + 0x50085,0x13,0xcda,0xd4f,0xd53,0x4003d,0x1b9,0xd57,0x1d2,0x7005f,0x9f,0xd58, + 0xd57,0x1d4,0x2,0x14c,0x50051,0x13,0xd59,0xd58,0x0,0x500b4,0x6e,0xd5b, + 0xd59,0x1d8,0x600a9,0x13,0x9506,0xd5b,0x1dc,0xd59,0x50085,0x13,0xcdc,0xcda, + 0x9506,0x50041,0x14,0x7346,0x7345,0x757b,0x3003e,0x7346,0xcdc,0x4003d,0x13,0xce1, + 0x7346,0x7000c,0x13,0xd63,0x1,0x1a,0xce1,0x1dc,0x3003e,0x7346,0xd63,0x4003d, + 0x13,0xce7,0x7346,0x7000c,0x13,0xd68,0x1,0x28,0xce7,0x38d,0x3003e,0x7346, + 0xd68,0x50080,0x1a,0xcec,0x757b,0x191,0x200f9,0xccb,0x200f8,0xced,0x200f9,0xcee, + 0x200f8,0xcee,0x4003d,0x82,0x734b,0x7345,0x300f7,0xc06,0x0,0x400fa,0xd0e,0xc00, + 0xc06,0x200f8,0xc00,0x50051,0x13,0x732a,0x6e4f,0x0,0x50051,0x13,0x732b,0x6e4f, + 0x1,0x50051,0x13,0x732c,0x6e4f,0x2,0x50051,0x13,0x732d,0x6e4f,0x3,0x50051, + 0x13,0x732e,0x6e4f,0x4,0x7000c,0x13,0xe70,0x1,0x25,0x732a,0x732d,0x7000c, + 0x13,0xe75,0x1,0x28,0x732a,0x732d,0x7000c,0x13,0xe7a,0x1,0x25,0x732b, + 0x732e,0x7000c,0x13,0xe7f,0x1,0x28,0x732b,0x732e,0x7000c,0x13,0xe84,0x1, + 0x25,0xe70,0x732c,0x7000c,0x13,0xe89,0x1,0x28,0xe70,0x732c,0x7000c,0x13, + 0xe8e,0x1,0x25,0xe7a,0xe75,0x7000c,0x13,0xe93,0x1,0x28,0xe7a,0xe75, + 0x7000c,0x13,0xe98,0x1,0x25,0xe84,0xe8e,0x7000c,0x13,0xe9d,0x1,0x28, + 0xe84,0xe8e,0x7000c,0x13,0xea2,0x1,0x25,0xe89,0xe7f,0x7000c,0x13,0xea7, + 0x1,0x28,0xe89,0xe7f,0x7000c,0x13,0xeac,0x1,0x25,0xe9d,0xea2,0x7000c, + 0x13,0xeb1,0x1,0x28,0xe9d,0xea2,0x7000c,0x13,0xeb6,0x1,0x25,0xe93, + 0xea7,0x7000c,0x13,0xebb,0x1,0x28,0xe93,0xea7,0x7000c,0x13,0xec0,0x1, + 0x25,0xeb1,0xeb6,0x7000c,0x13,0xec5,0x1,0x28,0xeb1,0xeb6,0x80050,0x82, + 0x7334,0xe98,0xeac,0xec0,0xec5,0xebb,0x3003e,0x6e5d,0x7334,0x50051,0x13,0x733a, + 0x734b,0x0,0x50051,0x13,0x733b,0x734b,0x1,0x50051,0x13,0x733c,0x734b,0x2, + 0x50051,0x13,0x733d,0x734b,0x3,0x50051,0x13,0x733e,0x734b,0x4,0x7000c,0x13, + 0xf6d,0x1,0x25,0x733a,0x733d,0x7000c,0x13,0xf72,0x1,0x28,0x733a,0x733d, + 0x7000c,0x13,0xf77,0x1,0x25,0x733b,0x733e,0x7000c,0x13,0xf7c,0x1,0x28, + 0x733b,0x733e,0x7000c,0x13,0xf81,0x1,0x25,0xf6d,0x733c,0x7000c,0x13,0xf86, + 0x1,0x28,0xf6d,0x733c,0x7000c,0x13,0xf8b,0x1,0x25,0xf77,0xf72,0x7000c, + 0x13,0xf90,0x1,0x28,0xf77,0xf72,0x7000c,0x13,0xf95,0x1,0x25,0xf81, + 0xf8b,0x7000c,0x13,0xf9a,0x1,0x28,0xf81,0xf8b,0x7000c,0x13,0xf9f,0x1, + 0x25,0xf86,0xf7c,0x7000c,0x13,0xfa4,0x1,0x28,0xf86,0xf7c,0x7000c,0x13, + 0xfa9,0x1,0x25,0xf9a,0xf9f,0x7000c,0x13,0xfae,0x1,0x28,0xf9a,0xf9f, + 0x7000c,0x13,0xfb3,0x1,0x25,0xf90,0xfa4,0x7000c,0x13,0xfb8,0x1,0x28, + 0xf90,0xfa4,0x7000c,0x13,0xfbd,0x1,0x25,0xfae,0xfb3,0x7000c,0x13,0xfc2, + 0x1,0x28,0xfae,0xfb3,0x80050,0x82,0x7344,0xf95,0xfa9,0xfbd,0xfc2,0xfb8, + 0x3003e,0x6e67,0x7344,0x50041,0x14,0x6e62,0x6e5d,0x2cd,0x4003d,0x13,0xd7c,0x6e62, + 0x50041,0x14,0x6e6c,0x6e67,0x2cd,0x4003d,0x13,0xd7e,0x6e6c,0x7000c,0x13,0xfc7, + 0x1,0x25,0xd7c,0xd7e,0x500ba,0x6e,0xd81,0xfc7,0x372,0x300f7,0xdc3,0x0, + 0x400fa,0xd81,0xd82,0xdc3,0x200f8,0xd82,0x200f9,0xd83,0x200f8,0xd83,0x700f5,0x1a, + 0x8f0e,0x14c,0xd82,0x94f8,0xdbf,0x700f5,0x1a,0x8f0d,0x14c,0xd82,0x94f7,0xdbf, + 0x700f5,0x13,0x759e,0x35e,0xd82,0x8f25,0xdbf,0x700f5,0x1a,0x759d,0x14c,0xd82, + 0xdc1,0xdbf,0x500b1,0x6e,0xd86,0x759d,0x37d,0x500b8,0x6e,0xd88,0x759e,0x380, + 0x500a7,0x6e,0xd89,0xd86,0xd88,0x400f6,0xdc2,0xdbf,0x0,0x400fa,0xd89,0xd8a, + 0xdc2,0x200f8,0xd8a,0x50041,0x14,0x6e63,0x6e5d,0x8f0d,0x4003d,0x13,0xd8d,0x6e63, + 0x50041,0x14,0x6e6d,0x6e67,0x8f0e,0x4003d,0x13,0xd90,0x6e6d,0x50083,0x13,0xd91, + 0xd8d,0xd90,0x6000c,0x13,0xd93,0x1,0x4,0xd91,0x500ba,0x6e,0xd94,0xd93, + 0x38d,0x300f7,0xdbe,0x0,0x400fa,0xd94,0xd95,0xdbd,0x200f8,0xdbd,0x200f9,0xdbe, + 0x200f8,0xd95,0x6000c,0x13,0xd97,0x1,0x6,0xd91,0x4003d,0x13,0xd9a,0x6e63, + 0x4003d,0x13,0xd9d,0x6e6d,0x7000c,0x13,0xfde,0x1,0x28,0xd9a,0xd9d,0x500b7, + 0x6e,0xfd2,0xfde,0x1d8,0x300f7,0xfd8,0x0,0x400fa,0xfd2,0xfd3,0xfd7,0x200f8, + 0xfd7,0x200f9,0xfd8,0x200f8,0xfd3,0x7000c,0x13,0xfe3,0x1,0x25,0xd9a,0xd9d, + 0x50088,0x13,0xfd6,0xfe3,0xfde,0x200f9,0xfd8,0x200f8,0xfd8,0x700f5,0x13,0x8f0f, + 0xfd6,0xfd3,0x1d8,0xfd7,0x50083,0x13,0xd9f,0x1dc,0x8f0f,0x50085,0x13,0xda0, + 0xd97,0xd9f,0x6000c,0x13,0xda2,0x1,0x4,0xda0,0x6000c,0x13,0xda4,0x1, + 0x4,0x759e,0x500b8,0x6e,0xda5,0xda2,0xda4,0x600a9,0x13,0xda8,0xda5,0xda0, + 0x759e,0x4003d,0x13,0xdab,0x6e63,0x4003d,0x13,0xdae,0x6e6d,0x500b8,0x6e,0xdaf, + 0xdab,0xdae,0x600a9,0x1a,0xdb0,0xdaf,0x191,0x14c,0x50080,0x1a,0xdb2,0x8f0d, + 0xdb0,0x50041,0x14,0x6e66,0x6e5d,0xdb2,0x4003d,0x13,0xdb5,0x6e66,0x4003d,0x13, + 0xdb8,0x6e6d,0x500be,0x6e,0xdb9,0xdb5,0xdb8,0x600a9,0x1a,0xdba,0xdb9,0x191, + 0x14c,0x50080,0x1a,0xdbc,0x8f0e,0xdba,0x200f9,0xdbe,0x200f8,0xdbe,0x700f5,0x1a, + 0x94f8,0xdbc,0xfd8,0x8f0e,0xdbd,0x700f5,0x1a,0x94f7,0xdb2,0xfd8,0x8f0d,0xdbd, + 0x700f5,0x13,0x8f25,0xda8,0xfd8,0x380,0xdbd,0x200f9,0xdbf,0x200f8,0xdbf,0x50080, + 0x1a,0xdc1,0x759d,0x191,0x200f9,0xd83,0x200f8,0xdc2,0x200f9,0xdc3,0x200f8,0xdc3, + 0x700f5,0x13,0x759f,0x35e,0xc00,0x759e,0xdc2,0x500b8,0x6e,0xdc6,0x759f,0x35e, + 0x600a9,0x13,0xdc7,0xdc6,0x1dc,0x1d8,0x50085,0x13,0xdc8,0x759f,0xdc7,0x200f9, + 0xc06,0x200f8,0xc06,0x700f5,0x13,0x75a0,0x1d8,0xcee,0xdc8,0xdc3,0x60052,0x9f, + 0x9544,0x75a0,0x48e,0x0,0x500b7,0x6e,0xba3,0x75a0,0x1d8,0x300f7,0xba8,0x0, + 0x400fa,0xba3,0xba4,0xba7,0x200f8,0xba7,0x200f9,0xba8,0x200f8,0xba4,0x6000c,0x13, + 0xba6,0x1,0x6,0x75a0,0x200f9,0xba8,0x200f8,0xba8,0x700f5,0x13,0x75a7,0xba6, + 0xba4,0x1d8,0xba7,0x60052,0x9f,0x9546,0x75a7,0x9544,0x1,0x60052,0x9f,0x9548, + 0x1dc,0x9546,0x2,0x4007c,0x32,0xb6d,0xb4e,0x4006f,0x38,0xb6e,0xb6d,0x4006e, + 0x32,0xff4,0xb6e,0x50051,0x1a,0x1027,0xff4,0x0,0x7000c,0x1a,0x1038,0x1, + 0x27,0x1027,0xbc1,0x7000c,0x1a,0x103d,0x1,0x2a,0x14c,0x1038,0x50051,0x1a, + 0x102f,0xff4,0x1,0x7000c,0x1a,0x1042,0x1,0x27,0x102f,0xbc9,0x7000c,0x1a, + 0x1047,0x1,0x2a,0x14c,0x1042,0x50050,0x32,0x9784,0x103d,0x1047,0x4003d,0x1b9, + 0x104a,0x1ca,0x7005f,0x9f,0x104c,0x104a,0x9784,0x2,0x14c,0x7004f,0x38,0x104d, + 0x104c,0x104c,0x0,0x1,0x4006f,0x38,0xffa,0x9784,0x50081,0x38,0xffc,0xffa, + 0x94fd,0x50088,0x38,0xfff,0xffc,0xb9a,0x3003e,0x1072,0x3df,0x50081,0x38,0x1081, + 0xfff,0xc1c,0x50085,0x38,0x1085,0x1081,0xb9a,0x6000c,0x38,0x1086,0x1,0x8, + 0x1085,0x4006e,0x32,0x1087,0x1086,0x200f9,0x1088,0x200f8,0x1088,0x700f5,0x1a,0x75bc, + 0x14c,0xba8,0x10a7,0x108c,0x500b1,0x6e,0x108b,0x75bc,0x37d,0x400f6,0x10a8,0x108c, + 0x0,0x400fa,0x108b,0x108c,0x10a8,0x200f8,0x108c,0x50041,0x49,0x1090,0x1072,0x75bc, + 0x4003d,0x32,0x1091,0x1090,0x50080,0x32,0x10c7,0x1087,0x1091,0x50051,0x1a,0x10cc, + 0x10c7,0x0,0x7000c,0x1a,0x10dd,0x1,0x27,0x10cc,0xbc1,0x7000c,0x1a,0x10e2, + 0x1,0x2a,0x14c,0x10dd,0x50051,0x1a,0x10d4,0x10c7,0x1,0x7000c,0x1a,0x10e7, + 0x1,0x27,0x10d4,0xbc9,0x7000c,0x1a,0x10ec,0x1,0x2a,0x14c,0x10e7,0x50050, + 0x32,0x97b0,0x10e2,0x10ec,0x4003d,0x1b9,0x10ef,0x1bb,0x7005f,0x9f,0x10f1,0x10ef, + 0x97b0,0x2,0x14c,0x50051,0x13,0x10f2,0x10f1,0x0,0x4003d,0x1b9,0x10f6,0x1d2, + 0x7005f,0x9f,0x10f7,0x10f6,0x1d4,0x2,0x14c,0x50051,0x13,0x10f8,0x10f7,0x0, + 0x500b4,0x6e,0x10fa,0x10f8,0x1d8,0x600a9,0x13,0x9507,0x10fa,0x1dc,0x10f8,0x50085, + 0x13,0x1097,0x10f2,0x9507,0x50041,0x14,0x6d9d,0x6d9c,0x75bc,0x3003e,0x6d9d,0x1097, + 0x4003d,0x13,0x109c,0x6d9d,0x7000c,0x13,0x1102,0x1,0x1a,0x109c,0x1dc,0x3003e, + 0x6d9d,0x1102,0x4003d,0x13,0x10a2,0x6d9d,0x7000c,0x13,0x1107,0x1,0x28,0x10a2, + 0x38d,0x3003e,0x6d9d,0x1107,0x50080,0x1a,0x10a7,0x75bc,0x191,0x200f9,0x1088,0x200f8, + 0x10a8,0x4003d,0x82,0x6da2,0x6d9c,0x3003e,0x1111,0x3df,0x50081,0x38,0x111f,0xfff, + 0xcba,0x50081,0x38,0x1122,0x111f,0x104d,0x50051,0x13,0x115f,0x1122,0x0,0x500be, + 0x6e,0x1160,0x115f,0x1d8,0x300f7,0x1165,0x0,0x400fa,0x1160,0x1161,0x1165,0x200f8, + 0x1161,0x500bc,0x6e,0x1164,0x115f,0x1dc,0x200f9,0x1165,0x200f8,0x1165,0x700f5,0x6e, + 0x1166,0x1160,0x10a8,0x1164,0x1161,0x300f7,0x1171,0x0,0x400fa,0x1166,0x1167,0x1171, + 0x200f8,0x1167,0x50051,0x13,0x1169,0x1122,0x1,0x500be,0x6e,0x116a,0x1169,0x1d8, + 0x300f7,0x116f,0x0,0x400fa,0x116a,0x116b,0x116f,0x200f8,0x116b,0x500bc,0x6e,0x116e, + 0x1169,0x1dc,0x200f9,0x116f,0x200f8,0x116f,0x700f5,0x6e,0x1170,0x116a,0x1167,0x116e, + 0x116b,0x200f9,0x1171,0x200f8,0x1171,0x700f5,0x6e,0x1172,0x1166,0x1165,0x1170,0x116f, + 0x300f7,0x1152,0x0,0x400fa,0x1172,0x1128,0x1152,0x200f8,0x1128,0x50085,0x38,0x112c, + 0x1122,0xcb9,0x6000c,0x38,0x112d,0x1,0x8,0x112c,0x4006e,0x32,0x112e,0x112d, + 0x200f9,0x112f,0x200f8,0x112f,0x700f5,0x1a,0x75c2,0x14c,0x1128,0x1150,0x1133,0x500b1, + 0x6e,0x1132,0x75c2,0x37d,0x400f6,0x1151,0x1133,0x0,0x400fa,0x1132,0x1133,0x1151, + 0x200f8,0x1133,0x50041,0x49,0x1137,0x1111,0x75c2,0x4003d,0x32,0x1138,0x1137,0x50080, + 0x32,0x1188,0x112e,0x1138,0x50051,0x1a,0x118a,0xcf7,0x0,0x50082,0x1a,0x118b, + 0x118a,0x191,0x50051,0x1a,0x118d,0x1188,0x0,0x7000c,0x1a,0x119e,0x1,0x27, + 0x118d,0x118b,0x7000c,0x1a,0x11a3,0x1,0x2a,0x14c,0x119e,0x50051,0x1a,0x1192, + 0xcf7,0x1,0x50082,0x1a,0x1193,0x1192,0x191,0x50051,0x1a,0x1195,0x1188,0x1, + 0x7000c,0x1a,0x11a8,0x1,0x27,0x1195,0x1193,0x7000c,0x1a,0x11ad,0x1,0x2a, + 0x14c,0x11a8,0x50050,0x32,0x97af,0x11a3,0x11ad,0x4003d,0x1b9,0x11b0,0x1c3,0x7005f, + 0x9f,0x11b2,0x11b0,0x97af,0x2,0x14c,0x50051,0x13,0x11b3,0x11b2,0x0,0x50041, + 0x1a2,0x11b6,0x18b,0x20b,0x4003d,0x13,0x11b7,0x11b6,0x50085,0x13,0x113e,0x11b3, + 0x11b7,0x4003d,0x1b9,0x11bb,0x1d2,0x7005f,0x9f,0x11bc,0x11bb,0x1d4,0x2,0x14c, + 0x50051,0x13,0x11bd,0x11bc,0x0,0x500b4,0x6e,0x11bf,0x11bd,0x1d8,0x600a9,0x13, + 0x9508,0x11bf,0x1dc,0x11bd,0x50085,0x13,0x1140,0x113e,0x9508,0x50041,0x14,0x72f6, + 0x72f5,0x75c2,0x3003e,0x72f6,0x1140,0x4003d,0x13,0x1145,0x72f6,0x7000c,0x13,0x11c7, + 0x1,0x1a,0x1145,0x1dc,0x3003e,0x72f6,0x11c7,0x4003d,0x13,0x114b,0x72f6,0x7000c, + 0x13,0x11cc,0x1,0x28,0x114b,0x38d,0x3003e,0x72f6,0x11cc,0x50080,0x1a,0x1150, + 0x75c2,0x191,0x200f9,0x112f,0x200f8,0x1151,0x200f9,0x1152,0x200f8,0x1152,0x4003d,0x82, + 0x72fb,0x72f5,0x300f7,0x106a,0x0,0x400fa,0x1172,0x1064,0x106a,0x200f8,0x1064,0x50051, + 0x13,0x72da,0x6da2,0x0,0x50051,0x13,0x72db,0x6da2,0x1,0x50051,0x13,0x72dc, + 0x6da2,0x2,0x50051,0x13,0x72dd,0x6da2,0x3,0x50051,0x13,0x72de,0x6da2,0x4, + 0x7000c,0x13,0x12d4,0x1,0x25,0x72da,0x72dd,0x7000c,0x13,0x12d9,0x1,0x28, + 0x72da,0x72dd,0x7000c,0x13,0x12de,0x1,0x25,0x72db,0x72de,0x7000c,0x13,0x12e3, + 0x1,0x28,0x72db,0x72de,0x7000c,0x13,0x12e8,0x1,0x25,0x12d4,0x72dc,0x7000c, + 0x13,0x12ed,0x1,0x28,0x12d4,0x72dc,0x7000c,0x13,0x12f2,0x1,0x25,0x12de, + 0x12d9,0x7000c,0x13,0x12f7,0x1,0x28,0x12de,0x12d9,0x7000c,0x13,0x12fc,0x1, + 0x25,0x12e8,0x12f2,0x7000c,0x13,0x1301,0x1,0x28,0x12e8,0x12f2,0x7000c,0x13, + 0x1306,0x1,0x25,0x12ed,0x12e3,0x7000c,0x13,0x130b,0x1,0x28,0x12ed,0x12e3, + 0x7000c,0x13,0x1310,0x1,0x25,0x1301,0x1306,0x7000c,0x13,0x1315,0x1,0x28, + 0x1301,0x1306,0x7000c,0x13,0x131a,0x1,0x25,0x12f7,0x130b,0x7000c,0x13,0x131f, + 0x1,0x28,0x12f7,0x130b,0x7000c,0x13,0x1324,0x1,0x25,0x1315,0x131a,0x7000c, + 0x13,0x1329,0x1,0x28,0x1315,0x131a,0x80050,0x82,0x72e4,0x12fc,0x1310,0x1324, + 0x1329,0x131f,0x3003e,0x6db0,0x72e4,0x50051,0x13,0x72ea,0x72fb,0x0,0x50051,0x13, + 0x72eb,0x72fb,0x1,0x50051,0x13,0x72ec,0x72fb,0x2,0x50051,0x13,0x72ed,0x72fb, + 0x3,0x50051,0x13,0x72ee,0x72fb,0x4,0x7000c,0x13,0x13d1,0x1,0x25,0x72ea, + 0x72ed,0x7000c,0x13,0x13d6,0x1,0x28,0x72ea,0x72ed,0x7000c,0x13,0x13db,0x1, + 0x25,0x72eb,0x72ee,0x7000c,0x13,0x13e0,0x1,0x28,0x72eb,0x72ee,0x7000c,0x13, + 0x13e5,0x1,0x25,0x13d1,0x72ec,0x7000c,0x13,0x13ea,0x1,0x28,0x13d1,0x72ec, + 0x7000c,0x13,0x13ef,0x1,0x25,0x13db,0x13d6,0x7000c,0x13,0x13f4,0x1,0x28, + 0x13db,0x13d6,0x7000c,0x13,0x13f9,0x1,0x25,0x13e5,0x13ef,0x7000c,0x13,0x13fe, + 0x1,0x28,0x13e5,0x13ef,0x7000c,0x13,0x1403,0x1,0x25,0x13ea,0x13e0,0x7000c, + 0x13,0x1408,0x1,0x28,0x13ea,0x13e0,0x7000c,0x13,0x140d,0x1,0x25,0x13fe, + 0x1403,0x7000c,0x13,0x1412,0x1,0x28,0x13fe,0x1403,0x7000c,0x13,0x1417,0x1, + 0x25,0x13f4,0x1408,0x7000c,0x13,0x141c,0x1,0x28,0x13f4,0x1408,0x7000c,0x13, + 0x1421,0x1,0x25,0x1412,0x1417,0x7000c,0x13,0x1426,0x1,0x28,0x1412,0x1417, + 0x80050,0x82,0x72f4,0x13f9,0x140d,0x1421,0x1426,0x141c,0x3003e,0x6dba,0x72f4,0x50041, + 0x14,0x6db5,0x6db0,0x2cd,0x4003d,0x13,0x11e0,0x6db5,0x50041,0x14,0x6dbf,0x6dba, + 0x2cd,0x4003d,0x13,0x11e2,0x6dbf,0x7000c,0x13,0x142b,0x1,0x25,0x11e0,0x11e2, + 0x500ba,0x6e,0x11e5,0x142b,0x372,0x300f7,0x1227,0x0,0x400fa,0x11e5,0x11e6,0x1227, + 0x200f8,0x11e6,0x200f9,0x11e7,0x200f8,0x11e7,0x700f5,0x1a,0x8f00,0x14c,0x11e6,0x94f4, + 0x1223,0x700f5,0x1a,0x8eff,0x14c,0x11e6,0x94f3,0x1223,0x700f5,0x13,0x75e5,0x35e, + 0x11e6,0x8f3a,0x1223,0x700f5,0x1a,0x75e4,0x14c,0x11e6,0x1225,0x1223,0x500b1,0x6e, + 0x11ea,0x75e4,0x37d,0x500b8,0x6e,0x11ec,0x75e5,0x380,0x500a7,0x6e,0x11ed,0x11ea, + 0x11ec,0x400f6,0x1226,0x1223,0x0,0x400fa,0x11ed,0x11ee,0x1226,0x200f8,0x11ee,0x50041, + 0x14,0x6db6,0x6db0,0x8eff,0x4003d,0x13,0x11f1,0x6db6,0x50041,0x14,0x6dc0,0x6dba, + 0x8f00,0x4003d,0x13,0x11f4,0x6dc0,0x50083,0x13,0x11f5,0x11f1,0x11f4,0x6000c,0x13, + 0x11f7,0x1,0x4,0x11f5,0x500ba,0x6e,0x11f8,0x11f7,0x38d,0x300f7,0x1222,0x0, + 0x400fa,0x11f8,0x11f9,0x1221,0x200f8,0x1221,0x200f9,0x1222,0x200f8,0x11f9,0x6000c,0x13, + 0x11fb,0x1,0x6,0x11f5,0x4003d,0x13,0x11fe,0x6db6,0x4003d,0x13,0x1201,0x6dc0, + 0x7000c,0x13,0x1442,0x1,0x28,0x11fe,0x1201,0x500b7,0x6e,0x1436,0x1442,0x1d8, + 0x300f7,0x143c,0x0,0x400fa,0x1436,0x1437,0x143b,0x200f8,0x143b,0x200f9,0x143c,0x200f8, + 0x1437,0x7000c,0x13,0x1447,0x1,0x25,0x11fe,0x1201,0x50088,0x13,0x143a,0x1447, + 0x1442,0x200f9,0x143c,0x200f8,0x143c,0x700f5,0x13,0x8f01,0x143a,0x1437,0x1d8,0x143b, + 0x50083,0x13,0x1203,0x1dc,0x8f01,0x50085,0x13,0x1204,0x11fb,0x1203,0x6000c,0x13, + 0x1206,0x1,0x4,0x1204,0x6000c,0x13,0x1208,0x1,0x4,0x75e5,0x500b8,0x6e, + 0x1209,0x1206,0x1208,0x600a9,0x13,0x120c,0x1209,0x1204,0x75e5,0x4003d,0x13,0x120f, + 0x6db6,0x4003d,0x13,0x1212,0x6dc0,0x500b8,0x6e,0x1213,0x120f,0x1212,0x600a9,0x1a, + 0x1214,0x1213,0x191,0x14c,0x50080,0x1a,0x1216,0x8eff,0x1214,0x50041,0x14,0x6db9, + 0x6db0,0x1216,0x4003d,0x13,0x1219,0x6db9,0x4003d,0x13,0x121c,0x6dc0,0x500be,0x6e, + 0x121d,0x1219,0x121c,0x600a9,0x1a,0x121e,0x121d,0x191,0x14c,0x50080,0x1a,0x1220, + 0x8f00,0x121e,0x200f9,0x1222,0x200f8,0x1222,0x700f5,0x1a,0x94f4,0x1220,0x143c,0x8f00, + 0x1221,0x700f5,0x1a,0x94f3,0x1216,0x143c,0x8eff,0x1221,0x700f5,0x13,0x8f3a,0x120c, + 0x143c,0x380,0x1221,0x200f9,0x1223,0x200f8,0x1223,0x50080,0x1a,0x1225,0x75e4,0x191, + 0x200f9,0x11e7,0x200f8,0x1226,0x200f9,0x1227,0x200f8,0x1227,0x700f5,0x13,0x75e6,0x35e, + 0x1064,0x75e5,0x1226,0x500b8,0x6e,0x122a,0x75e6,0x35e,0x600a9,0x13,0x122b,0x122a, + 0x1dc,0x1d8,0x50085,0x13,0x122c,0x75e6,0x122b,0x200f9,0x106a,0x200f8,0x106a,0x700f5, + 0x13,0x75e7,0x1d8,0x1152,0x122c,0x1227,0x60052,0x9f,0x9566,0x75e7,0x48e,0x0, + 0x500b7,0x6e,0x1007,0x75e7,0x1d8,0x300f7,0x100c,0x0,0x400fa,0x1007,0x1008,0x100b, + 0x200f8,0x100b,0x200f9,0x100c,0x200f8,0x1008,0x6000c,0x13,0x100a,0x1,0x6,0x75e7, + 0x200f9,0x100c,0x200f8,0x100c,0x700f5,0x13,0x75ee,0x100a,0x1008,0x1d8,0x100b,0x60052, + 0x9f,0x9568,0x75ee,0x9566,0x1,0x60052,0x9f,0x956a,0x1dc,0x9568,0x2,0x4007c, + 0x32,0xb72,0xb50,0x4006f,0x38,0xb73,0xb72,0x4006e,0x32,0x1458,0xb73,0x50051, + 0x1a,0x148b,0x1458,0x0,0x7000c,0x1a,0x149c,0x1,0x27,0x148b,0xbc1,0x7000c, + 0x1a,0x14a1,0x1,0x2a,0x14c,0x149c,0x50051,0x1a,0x1493,0x1458,0x1,0x7000c, + 0x1a,0x14a6,0x1,0x27,0x1493,0xbc9,0x7000c,0x1a,0x14ab,0x1,0x2a,0x14c, + 0x14a6,0x50050,0x32,0x9785,0x14a1,0x14ab,0x4003d,0x1b9,0x14ae,0x1ca,0x7005f,0x9f, + 0x14b0,0x14ae,0x9785,0x2,0x14c,0x7004f,0x38,0x14b1,0x14b0,0x14b0,0x0,0x1, + 0x4006f,0x38,0x145e,0x9785,0x50081,0x38,0x1460,0x145e,0x94fd,0x50088,0x38,0x1463, + 0x1460,0xb9a,0x3003e,0x14d6,0x3df,0x50081,0x38,0x14e5,0x1463,0xc1c,0x50085,0x38, + 0x14e9,0x14e5,0xb9a,0x6000c,0x38,0x14ea,0x1,0x8,0x14e9,0x4006e,0x32,0x14eb, + 0x14ea,0x200f9,0x14ec,0x200f8,0x14ec,0x700f5,0x1a,0x760d,0x14c,0x100c,0x150b,0x14f0, + 0x500b1,0x6e,0x14ef,0x760d,0x37d,0x400f6,0x150c,0x14f0,0x0,0x400fa,0x14ef,0x14f0, + 0x150c,0x200f8,0x14f0,0x50041,0x49,0x14f4,0x14d6,0x760d,0x4003d,0x32,0x14f5,0x14f4, + 0x50080,0x32,0x152b,0x14eb,0x14f5,0x50051,0x1a,0x1530,0x152b,0x0,0x7000c,0x1a, + 0x1541,0x1,0x27,0x1530,0xbc1,0x7000c,0x1a,0x1546,0x1,0x2a,0x14c,0x1541, + 0x50051,0x1a,0x1538,0x152b,0x1,0x7000c,0x1a,0x154b,0x1,0x27,0x1538,0xbc9, + 0x7000c,0x1a,0x1550,0x1,0x2a,0x14c,0x154b,0x50050,0x32,0x97ae,0x1546,0x1550, + 0x4003d,0x1b9,0x1553,0x1bb,0x7005f,0x9f,0x1555,0x1553,0x97ae,0x2,0x14c,0x50051, + 0x13,0x1556,0x1555,0x0,0x4003d,0x1b9,0x155a,0x1d2,0x7005f,0x9f,0x155b,0x155a, + 0x1d4,0x2,0x14c,0x50051,0x13,0x155c,0x155b,0x0,0x500b4,0x6e,0x155e,0x155c, + 0x1d8,0x600a9,0x13,0x9509,0x155e,0x1dc,0x155c,0x50085,0x13,0x14fb,0x1556,0x9509, + 0x50041,0x14,0x6cf0,0x6cef,0x760d,0x3003e,0x6cf0,0x14fb,0x4003d,0x13,0x1500,0x6cf0, + 0x7000c,0x13,0x1566,0x1,0x1a,0x1500,0x1dc,0x3003e,0x6cf0,0x1566,0x4003d,0x13, + 0x1506,0x6cf0,0x7000c,0x13,0x156b,0x1,0x28,0x1506,0x38d,0x3003e,0x6cf0,0x156b, + 0x50080,0x1a,0x150b,0x760d,0x191,0x200f9,0x14ec,0x200f8,0x150c,0x4003d,0x82,0x6cf5, + 0x6cef,0x3003e,0x1575,0x3df,0x50081,0x38,0x1583,0x1463,0xcba,0x50081,0x38,0x1586, + 0x1583,0x14b1,0x50051,0x13,0x15c3,0x1586,0x0,0x500be,0x6e,0x15c4,0x15c3,0x1d8, + 0x300f7,0x15c9,0x0,0x400fa,0x15c4,0x15c5,0x15c9,0x200f8,0x15c5,0x500bc,0x6e,0x15c8, + 0x15c3,0x1dc,0x200f9,0x15c9,0x200f8,0x15c9,0x700f5,0x6e,0x15ca,0x15c4,0x150c,0x15c8, + 0x15c5,0x300f7,0x15d5,0x0,0x400fa,0x15ca,0x15cb,0x15d5,0x200f8,0x15cb,0x50051,0x13, + 0x15cd,0x1586,0x1,0x500be,0x6e,0x15ce,0x15cd,0x1d8,0x300f7,0x15d3,0x0,0x400fa, + 0x15ce,0x15cf,0x15d3,0x200f8,0x15cf,0x500bc,0x6e,0x15d2,0x15cd,0x1dc,0x200f9,0x15d3, + 0x200f8,0x15d3,0x700f5,0x6e,0x15d4,0x15ce,0x15cb,0x15d2,0x15cf,0x200f9,0x15d5,0x200f8, + 0x15d5,0x700f5,0x6e,0x15d6,0x15ca,0x15c9,0x15d4,0x15d3,0x300f7,0x15b6,0x0,0x400fa, + 0x15d6,0x158c,0x15b6,0x200f8,0x158c,0x50085,0x38,0x1590,0x1586,0xcb9,0x6000c,0x38, + 0x1591,0x1,0x8,0x1590,0x4006e,0x32,0x1592,0x1591,0x200f9,0x1593,0x200f8,0x1593, + 0x700f5,0x1a,0x7613,0x14c,0x158c,0x15b4,0x1597,0x500b1,0x6e,0x1596,0x7613,0x37d, + 0x400f6,0x15b5,0x1597,0x0,0x400fa,0x1596,0x1597,0x15b5,0x200f8,0x1597,0x50041,0x49, + 0x159b,0x1575,0x7613,0x4003d,0x32,0x159c,0x159b,0x50080,0x32,0x15ec,0x1592,0x159c, + 0x50051,0x1a,0x15ee,0xcf7,0x0,0x50082,0x1a,0x15ef,0x15ee,0x191,0x50051,0x1a, + 0x15f1,0x15ec,0x0,0x7000c,0x1a,0x1602,0x1,0x27,0x15f1,0x15ef,0x7000c,0x1a, + 0x1607,0x1,0x2a,0x14c,0x1602,0x50051,0x1a,0x15f6,0xcf7,0x1,0x50082,0x1a, + 0x15f7,0x15f6,0x191,0x50051,0x1a,0x15f9,0x15ec,0x1,0x7000c,0x1a,0x160c,0x1, + 0x27,0x15f9,0x15f7,0x7000c,0x1a,0x1611,0x1,0x2a,0x14c,0x160c,0x50050,0x32, + 0x97ad,0x1607,0x1611,0x4003d,0x1b9,0x1614,0x1c3,0x7005f,0x9f,0x1616,0x1614,0x97ad, + 0x2,0x14c,0x50051,0x13,0x1617,0x1616,0x0,0x50041,0x1a2,0x161a,0x18b,0x20b, + 0x4003d,0x13,0x161b,0x161a,0x50085,0x13,0x15a2,0x1617,0x161b,0x4003d,0x1b9,0x161f, + 0x1d2,0x7005f,0x9f,0x1620,0x161f,0x1d4,0x2,0x14c,0x50051,0x13,0x1621,0x1620, + 0x0,0x500b4,0x6e,0x1623,0x1621,0x1d8,0x600a9,0x13,0x950a,0x1623,0x1dc,0x1621, + 0x50085,0x13,0x15a4,0x15a2,0x950a,0x50041,0x14,0x72a6,0x72a5,0x7613,0x3003e,0x72a6, + 0x15a4,0x4003d,0x13,0x15a9,0x72a6,0x7000c,0x13,0x162b,0x1,0x1a,0x15a9,0x1dc, + 0x3003e,0x72a6,0x162b,0x4003d,0x13,0x15af,0x72a6,0x7000c,0x13,0x1630,0x1,0x28, + 0x15af,0x38d,0x3003e,0x72a6,0x1630,0x50080,0x1a,0x15b4,0x7613,0x191,0x200f9,0x1593, + 0x200f8,0x15b5,0x200f9,0x15b6,0x200f8,0x15b6,0x4003d,0x82,0x72ab,0x72a5,0x300f7,0x14ce, + 0x0,0x400fa,0x15d6,0x14c8,0x14ce,0x200f8,0x14c8,0x50051,0x13,0x728a,0x6cf5,0x0, + 0x50051,0x13,0x728b,0x6cf5,0x1,0x50051,0x13,0x728c,0x6cf5,0x2,0x50051,0x13, + 0x728d,0x6cf5,0x3,0x50051,0x13,0x728e,0x6cf5,0x4,0x7000c,0x13,0x1738,0x1, + 0x25,0x728a,0x728d,0x7000c,0x13,0x173d,0x1,0x28,0x728a,0x728d,0x7000c,0x13, + 0x1742,0x1,0x25,0x728b,0x728e,0x7000c,0x13,0x1747,0x1,0x28,0x728b,0x728e, + 0x7000c,0x13,0x174c,0x1,0x25,0x1738,0x728c,0x7000c,0x13,0x1751,0x1,0x28, + 0x1738,0x728c,0x7000c,0x13,0x1756,0x1,0x25,0x1742,0x173d,0x7000c,0x13,0x175b, + 0x1,0x28,0x1742,0x173d,0x7000c,0x13,0x1760,0x1,0x25,0x174c,0x1756,0x7000c, + 0x13,0x1765,0x1,0x28,0x174c,0x1756,0x7000c,0x13,0x176a,0x1,0x25,0x1751, + 0x1747,0x7000c,0x13,0x176f,0x1,0x28,0x1751,0x1747,0x7000c,0x13,0x1774,0x1, + 0x25,0x1765,0x176a,0x7000c,0x13,0x1779,0x1,0x28,0x1765,0x176a,0x7000c,0x13, + 0x177e,0x1,0x25,0x175b,0x176f,0x7000c,0x13,0x1783,0x1,0x28,0x175b,0x176f, + 0x7000c,0x13,0x1788,0x1,0x25,0x1779,0x177e,0x7000c,0x13,0x178d,0x1,0x28, + 0x1779,0x177e,0x80050,0x82,0x7294,0x1760,0x1774,0x1788,0x178d,0x1783,0x3003e,0x6d03, + 0x7294,0x50051,0x13,0x729a,0x72ab,0x0,0x50051,0x13,0x729b,0x72ab,0x1,0x50051, + 0x13,0x729c,0x72ab,0x2,0x50051,0x13,0x729d,0x72ab,0x3,0x50051,0x13,0x729e, + 0x72ab,0x4,0x7000c,0x13,0x1835,0x1,0x25,0x729a,0x729d,0x7000c,0x13,0x183a, + 0x1,0x28,0x729a,0x729d,0x7000c,0x13,0x183f,0x1,0x25,0x729b,0x729e,0x7000c, + 0x13,0x1844,0x1,0x28,0x729b,0x729e,0x7000c,0x13,0x1849,0x1,0x25,0x1835, + 0x729c,0x7000c,0x13,0x184e,0x1,0x28,0x1835,0x729c,0x7000c,0x13,0x1853,0x1, + 0x25,0x183f,0x183a,0x7000c,0x13,0x1858,0x1,0x28,0x183f,0x183a,0x7000c,0x13, + 0x185d,0x1,0x25,0x1849,0x1853,0x7000c,0x13,0x1862,0x1,0x28,0x1849,0x1853, + 0x7000c,0x13,0x1867,0x1,0x25,0x184e,0x1844,0x7000c,0x13,0x186c,0x1,0x28, + 0x184e,0x1844,0x7000c,0x13,0x1871,0x1,0x25,0x1862,0x1867,0x7000c,0x13,0x1876, + 0x1,0x28,0x1862,0x1867,0x7000c,0x13,0x187b,0x1,0x25,0x1858,0x186c,0x7000c, + 0x13,0x1880,0x1,0x28,0x1858,0x186c,0x7000c,0x13,0x1885,0x1,0x25,0x1876, + 0x187b,0x7000c,0x13,0x188a,0x1,0x28,0x1876,0x187b,0x80050,0x82,0x72a4,0x185d, + 0x1871,0x1885,0x188a,0x1880,0x3003e,0x6d0d,0x72a4,0x50041,0x14,0x6d08,0x6d03,0x2cd, + 0x4003d,0x13,0x1644,0x6d08,0x50041,0x14,0x6d12,0x6d0d,0x2cd,0x4003d,0x13,0x1646, + 0x6d12,0x7000c,0x13,0x188f,0x1,0x25,0x1644,0x1646,0x500ba,0x6e,0x1649,0x188f, + 0x372,0x300f7,0x168b,0x0,0x400fa,0x1649,0x164a,0x168b,0x200f8,0x164a,0x200f9,0x164b, + 0x200f8,0x164b,0x700f5,0x1a,0x8ef2,0x14c,0x164a,0x94f0,0x1687,0x700f5,0x1a,0x8ef1, + 0x14c,0x164a,0x94ef,0x1687,0x700f5,0x13,0x7636,0x35e,0x164a,0x8f53,0x1687,0x700f5, + 0x1a,0x7635,0x14c,0x164a,0x1689,0x1687,0x500b1,0x6e,0x164e,0x7635,0x37d,0x500b8, + 0x6e,0x1650,0x7636,0x380,0x500a7,0x6e,0x1651,0x164e,0x1650,0x400f6,0x168a,0x1687, + 0x0,0x400fa,0x1651,0x1652,0x168a,0x200f8,0x1652,0x50041,0x14,0x6d09,0x6d03,0x8ef1, + 0x4003d,0x13,0x1655,0x6d09,0x50041,0x14,0x6d13,0x6d0d,0x8ef2,0x4003d,0x13,0x1658, + 0x6d13,0x50083,0x13,0x1659,0x1655,0x1658,0x6000c,0x13,0x165b,0x1,0x4,0x1659, + 0x500ba,0x6e,0x165c,0x165b,0x38d,0x300f7,0x1686,0x0,0x400fa,0x165c,0x165d,0x1685, + 0x200f8,0x1685,0x200f9,0x1686,0x200f8,0x165d,0x6000c,0x13,0x165f,0x1,0x6,0x1659, + 0x4003d,0x13,0x1662,0x6d09,0x4003d,0x13,0x1665,0x6d13,0x7000c,0x13,0x18a6,0x1, + 0x28,0x1662,0x1665,0x500b7,0x6e,0x189a,0x18a6,0x1d8,0x300f7,0x18a0,0x0,0x400fa, + 0x189a,0x189b,0x189f,0x200f8,0x189f,0x200f9,0x18a0,0x200f8,0x189b,0x7000c,0x13,0x18ab, + 0x1,0x25,0x1662,0x1665,0x50088,0x13,0x189e,0x18ab,0x18a6,0x200f9,0x18a0,0x200f8, + 0x18a0,0x700f5,0x13,0x8ef3,0x189e,0x189b,0x1d8,0x189f,0x50083,0x13,0x1667,0x1dc, + 0x8ef3,0x50085,0x13,0x1668,0x165f,0x1667,0x6000c,0x13,0x166a,0x1,0x4,0x1668, + 0x6000c,0x13,0x166c,0x1,0x4,0x7636,0x500b8,0x6e,0x166d,0x166a,0x166c,0x600a9, + 0x13,0x1670,0x166d,0x1668,0x7636,0x4003d,0x13,0x1673,0x6d09,0x4003d,0x13,0x1676, + 0x6d13,0x500b8,0x6e,0x1677,0x1673,0x1676,0x600a9,0x1a,0x1678,0x1677,0x191,0x14c, + 0x50080,0x1a,0x167a,0x8ef1,0x1678,0x50041,0x14,0x6d0c,0x6d03,0x167a,0x4003d,0x13, + 0x167d,0x6d0c,0x4003d,0x13,0x1680,0x6d13,0x500be,0x6e,0x1681,0x167d,0x1680,0x600a9, + 0x1a,0x1682,0x1681,0x191,0x14c,0x50080,0x1a,0x1684,0x8ef2,0x1682,0x200f9,0x1686, + 0x200f8,0x1686,0x700f5,0x1a,0x94f0,0x1684,0x18a0,0x8ef2,0x1685,0x700f5,0x1a,0x94ef, + 0x167a,0x18a0,0x8ef1,0x1685,0x700f5,0x13,0x8f53,0x1670,0x18a0,0x380,0x1685,0x200f9, + 0x1687,0x200f8,0x1687,0x50080,0x1a,0x1689,0x7635,0x191,0x200f9,0x164b,0x200f8,0x168a, + 0x200f9,0x168b,0x200f8,0x168b,0x700f5,0x13,0x7637,0x35e,0x14c8,0x7636,0x168a,0x500b8, + 0x6e,0x168e,0x7637,0x35e,0x600a9,0x13,0x168f,0x168e,0x1dc,0x1d8,0x50085,0x13, + 0x1690,0x7637,0x168f,0x200f9,0x14ce,0x200f8,0x14ce,0x700f5,0x13,0x7638,0x1d8,0x15b6, + 0x1690,0x168b,0x60052,0x9f,0x9588,0x7638,0x48e,0x0,0x500b7,0x6e,0x146b,0x7638, + 0x1d8,0x300f7,0x1470,0x0,0x400fa,0x146b,0x146c,0x146f,0x200f8,0x146f,0x200f9,0x1470, + 0x200f8,0x146c,0x6000c,0x13,0x146e,0x1,0x6,0x7638,0x200f9,0x1470,0x200f8,0x1470, + 0x700f5,0x13,0x763f,0x146e,0x146c,0x1d8,0x146f,0x60052,0x9f,0x958a,0x763f,0x9588, + 0x1,0x60052,0x9f,0x958c,0x1dc,0x958a,0x2,0x4007c,0x32,0xb77,0xb52,0x4006f, + 0x38,0xb78,0xb77,0x4006e,0x32,0x18bc,0xb78,0x50051,0x1a,0x18ef,0x18bc,0x0, + 0x7000c,0x1a,0x1900,0x1,0x27,0x18ef,0xbc1,0x7000c,0x1a,0x1905,0x1,0x2a, + 0x14c,0x1900,0x50051,0x1a,0x18f7,0x18bc,0x1,0x7000c,0x1a,0x190a,0x1,0x27, + 0x18f7,0xbc9,0x7000c,0x1a,0x190f,0x1,0x2a,0x14c,0x190a,0x50050,0x32,0x9786, + 0x1905,0x190f,0x4003d,0x1b9,0x1912,0x1ca,0x7005f,0x9f,0x1914,0x1912,0x9786,0x2, + 0x14c,0x7004f,0x38,0x1915,0x1914,0x1914,0x0,0x1,0x4006f,0x38,0x18c2,0x9786, + 0x50081,0x38,0x18c4,0x18c2,0x94fd,0x50088,0x38,0x18c7,0x18c4,0xb9a,0x3003e,0x193a, + 0x3df,0x50081,0x38,0x1949,0x18c7,0xc1c,0x50085,0x38,0x194d,0x1949,0xb9a,0x6000c, + 0x38,0x194e,0x1,0x8,0x194d,0x4006e,0x32,0x194f,0x194e,0x200f9,0x1950,0x200f8, + 0x1950,0x700f5,0x1a,0x7668,0x14c,0x1470,0x196f,0x1954,0x500b1,0x6e,0x1953,0x7668, + 0x37d,0x400f6,0x1970,0x1954,0x0,0x400fa,0x1953,0x1954,0x1970,0x200f8,0x1954,0x50041, + 0x49,0x1958,0x193a,0x7668,0x4003d,0x32,0x1959,0x1958,0x50080,0x32,0x198f,0x194f, + 0x1959,0x50051,0x1a,0x1994,0x198f,0x0,0x7000c,0x1a,0x19a5,0x1,0x27,0x1994, + 0xbc1,0x7000c,0x1a,0x19aa,0x1,0x2a,0x14c,0x19a5,0x50051,0x1a,0x199c,0x198f, + 0x1,0x7000c,0x1a,0x19af,0x1,0x27,0x199c,0xbc9,0x7000c,0x1a,0x19b4,0x1, + 0x2a,0x14c,0x19af,0x50050,0x32,0x97ac,0x19aa,0x19b4,0x4003d,0x1b9,0x19b7,0x1bb, + 0x7005f,0x9f,0x19b9,0x19b7,0x97ac,0x2,0x14c,0x50051,0x13,0x19ba,0x19b9,0x0, + 0x4003d,0x1b9,0x19be,0x1d2,0x7005f,0x9f,0x19bf,0x19be,0x1d4,0x2,0x14c,0x50051, + 0x13,0x19c0,0x19bf,0x0,0x500b4,0x6e,0x19c2,0x19c0,0x1d8,0x600a9,0x13,0x950b, + 0x19c2,0x1dc,0x19c0,0x50085,0x13,0x195f,0x19ba,0x950b,0x50041,0x14,0x6c43,0x6c42, + 0x7668,0x3003e,0x6c43,0x195f,0x4003d,0x13,0x1964,0x6c43,0x7000c,0x13,0x19ca,0x1, + 0x1a,0x1964,0x1dc,0x3003e,0x6c43,0x19ca,0x4003d,0x13,0x196a,0x6c43,0x7000c,0x13, + 0x19cf,0x1,0x28,0x196a,0x38d,0x3003e,0x6c43,0x19cf,0x50080,0x1a,0x196f,0x7668, + 0x191,0x200f9,0x1950,0x200f8,0x1970,0x4003d,0x82,0x6c48,0x6c42,0x3003e,0x19d9,0x3df, + 0x50081,0x38,0x19e7,0x18c7,0xcba,0x50081,0x38,0x19ea,0x19e7,0x1915,0x50051,0x13, + 0x1a27,0x19ea,0x0,0x500be,0x6e,0x1a28,0x1a27,0x1d8,0x300f7,0x1a2d,0x0,0x400fa, + 0x1a28,0x1a29,0x1a2d,0x200f8,0x1a29,0x500bc,0x6e,0x1a2c,0x1a27,0x1dc,0x200f9,0x1a2d, + 0x200f8,0x1a2d,0x700f5,0x6e,0x1a2e,0x1a28,0x1970,0x1a2c,0x1a29,0x300f7,0x1a39,0x0, + 0x400fa,0x1a2e,0x1a2f,0x1a39,0x200f8,0x1a2f,0x50051,0x13,0x1a31,0x19ea,0x1,0x500be, + 0x6e,0x1a32,0x1a31,0x1d8,0x300f7,0x1a37,0x0,0x400fa,0x1a32,0x1a33,0x1a37,0x200f8, + 0x1a33,0x500bc,0x6e,0x1a36,0x1a31,0x1dc,0x200f9,0x1a37,0x200f8,0x1a37,0x700f5,0x6e, + 0x1a38,0x1a32,0x1a2f,0x1a36,0x1a33,0x200f9,0x1a39,0x200f8,0x1a39,0x700f5,0x6e,0x1a3a, + 0x1a2e,0x1a2d,0x1a38,0x1a37,0x300f7,0x1a1a,0x0,0x400fa,0x1a3a,0x19f0,0x1a1a,0x200f8, + 0x19f0,0x50085,0x38,0x19f4,0x19ea,0xcb9,0x6000c,0x38,0x19f5,0x1,0x8,0x19f4, + 0x4006e,0x32,0x19f6,0x19f5,0x200f9,0x19f7,0x200f8,0x19f7,0x700f5,0x1a,0x766e,0x14c, + 0x19f0,0x1a18,0x19fb,0x500b1,0x6e,0x19fa,0x766e,0x37d,0x400f6,0x1a19,0x19fb,0x0, + 0x400fa,0x19fa,0x19fb,0x1a19,0x200f8,0x19fb,0x50041,0x49,0x19ff,0x19d9,0x766e,0x4003d, + 0x32,0x1a00,0x19ff,0x50080,0x32,0x1a50,0x19f6,0x1a00,0x50051,0x1a,0x1a52,0xcf7, + 0x0,0x50082,0x1a,0x1a53,0x1a52,0x191,0x50051,0x1a,0x1a55,0x1a50,0x0,0x7000c, + 0x1a,0x1a66,0x1,0x27,0x1a55,0x1a53,0x7000c,0x1a,0x1a6b,0x1,0x2a,0x14c, + 0x1a66,0x50051,0x1a,0x1a5a,0xcf7,0x1,0x50082,0x1a,0x1a5b,0x1a5a,0x191,0x50051, + 0x1a,0x1a5d,0x1a50,0x1,0x7000c,0x1a,0x1a70,0x1,0x27,0x1a5d,0x1a5b,0x7000c, + 0x1a,0x1a75,0x1,0x2a,0x14c,0x1a70,0x50050,0x32,0x97ab,0x1a6b,0x1a75,0x4003d, + 0x1b9,0x1a78,0x1c3,0x7005f,0x9f,0x1a7a,0x1a78,0x97ab,0x2,0x14c,0x50051,0x13, + 0x1a7b,0x1a7a,0x0,0x50041,0x1a2,0x1a7e,0x18b,0x20b,0x4003d,0x13,0x1a7f,0x1a7e, + 0x50085,0x13,0x1a06,0x1a7b,0x1a7f,0x4003d,0x1b9,0x1a83,0x1d2,0x7005f,0x9f,0x1a84, + 0x1a83,0x1d4,0x2,0x14c,0x50051,0x13,0x1a85,0x1a84,0x0,0x500b4,0x6e,0x1a87, + 0x1a85,0x1d8,0x600a9,0x13,0x950c,0x1a87,0x1dc,0x1a85,0x50085,0x13,0x1a08,0x1a06, + 0x950c,0x50041,0x14,0x7256,0x7255,0x766e,0x3003e,0x7256,0x1a08,0x4003d,0x13,0x1a0d, + 0x7256,0x7000c,0x13,0x1a8f,0x1,0x1a,0x1a0d,0x1dc,0x3003e,0x7256,0x1a8f,0x4003d, + 0x13,0x1a13,0x7256,0x7000c,0x13,0x1a94,0x1,0x28,0x1a13,0x38d,0x3003e,0x7256, + 0x1a94,0x50080,0x1a,0x1a18,0x766e,0x191,0x200f9,0x19f7,0x200f8,0x1a19,0x200f9,0x1a1a, + 0x200f8,0x1a1a,0x4003d,0x82,0x725b,0x7255,0x300f7,0x1932,0x0,0x400fa,0x1a3a,0x192c, + 0x1932,0x200f8,0x192c,0x50051,0x13,0x723a,0x6c48,0x0,0x50051,0x13,0x723b,0x6c48, + 0x1,0x50051,0x13,0x723c,0x6c48,0x2,0x50051,0x13,0x723d,0x6c48,0x3,0x50051, + 0x13,0x723e,0x6c48,0x4,0x7000c,0x13,0x1b9c,0x1,0x25,0x723a,0x723d,0x7000c, + 0x13,0x1ba1,0x1,0x28,0x723a,0x723d,0x7000c,0x13,0x1ba6,0x1,0x25,0x723b, + 0x723e,0x7000c,0x13,0x1bab,0x1,0x28,0x723b,0x723e,0x7000c,0x13,0x1bb0,0x1, + 0x25,0x1b9c,0x723c,0x7000c,0x13,0x1bb5,0x1,0x28,0x1b9c,0x723c,0x7000c,0x13, + 0x1bba,0x1,0x25,0x1ba6,0x1ba1,0x7000c,0x13,0x1bbf,0x1,0x28,0x1ba6,0x1ba1, + 0x7000c,0x13,0x1bc4,0x1,0x25,0x1bb0,0x1bba,0x7000c,0x13,0x1bc9,0x1,0x28, + 0x1bb0,0x1bba,0x7000c,0x13,0x1bce,0x1,0x25,0x1bb5,0x1bab,0x7000c,0x13,0x1bd3, + 0x1,0x28,0x1bb5,0x1bab,0x7000c,0x13,0x1bd8,0x1,0x25,0x1bc9,0x1bce,0x7000c, + 0x13,0x1bdd,0x1,0x28,0x1bc9,0x1bce,0x7000c,0x13,0x1be2,0x1,0x25,0x1bbf, + 0x1bd3,0x7000c,0x13,0x1be7,0x1,0x28,0x1bbf,0x1bd3,0x7000c,0x13,0x1bec,0x1, + 0x25,0x1bdd,0x1be2,0x7000c,0x13,0x1bf1,0x1,0x28,0x1bdd,0x1be2,0x80050,0x82, + 0x7244,0x1bc4,0x1bd8,0x1bec,0x1bf1,0x1be7,0x3003e,0x6c56,0x7244,0x50051,0x13,0x724a, + 0x725b,0x0,0x50051,0x13,0x724b,0x725b,0x1,0x50051,0x13,0x724c,0x725b,0x2, + 0x50051,0x13,0x724d,0x725b,0x3,0x50051,0x13,0x724e,0x725b,0x4,0x7000c,0x13, + 0x1c99,0x1,0x25,0x724a,0x724d,0x7000c,0x13,0x1c9e,0x1,0x28,0x724a,0x724d, + 0x7000c,0x13,0x1ca3,0x1,0x25,0x724b,0x724e,0x7000c,0x13,0x1ca8,0x1,0x28, + 0x724b,0x724e,0x7000c,0x13,0x1cad,0x1,0x25,0x1c99,0x724c,0x7000c,0x13,0x1cb2, + 0x1,0x28,0x1c99,0x724c,0x7000c,0x13,0x1cb7,0x1,0x25,0x1ca3,0x1c9e,0x7000c, + 0x13,0x1cbc,0x1,0x28,0x1ca3,0x1c9e,0x7000c,0x13,0x1cc1,0x1,0x25,0x1cad, + 0x1cb7,0x7000c,0x13,0x1cc6,0x1,0x28,0x1cad,0x1cb7,0x7000c,0x13,0x1ccb,0x1, + 0x25,0x1cb2,0x1ca8,0x7000c,0x13,0x1cd0,0x1,0x28,0x1cb2,0x1ca8,0x7000c,0x13, + 0x1cd5,0x1,0x25,0x1cc6,0x1ccb,0x7000c,0x13,0x1cda,0x1,0x28,0x1cc6,0x1ccb, + 0x7000c,0x13,0x1cdf,0x1,0x25,0x1cbc,0x1cd0,0x7000c,0x13,0x1ce4,0x1,0x28, + 0x1cbc,0x1cd0,0x7000c,0x13,0x1ce9,0x1,0x25,0x1cda,0x1cdf,0x7000c,0x13,0x1cee, + 0x1,0x28,0x1cda,0x1cdf,0x80050,0x82,0x7254,0x1cc1,0x1cd5,0x1ce9,0x1cee,0x1ce4, + 0x3003e,0x6c60,0x7254,0x50041,0x14,0x6c5b,0x6c56,0x2cd,0x4003d,0x13,0x1aa8,0x6c5b, + 0x50041,0x14,0x6c65,0x6c60,0x2cd,0x4003d,0x13,0x1aaa,0x6c65,0x7000c,0x13,0x1cf3, + 0x1,0x25,0x1aa8,0x1aaa,0x500ba,0x6e,0x1aad,0x1cf3,0x372,0x300f7,0x1aef,0x0, + 0x400fa,0x1aad,0x1aae,0x1aef,0x200f8,0x1aae,0x200f9,0x1aaf,0x200f8,0x1aaf,0x700f5,0x1a, + 0x8ee4,0x14c,0x1aae,0x94ec,0x1aeb,0x700f5,0x1a,0x8ee3,0x14c,0x1aae,0x94eb,0x1aeb, + 0x700f5,0x13,0x7691,0x35e,0x1aae,0x8f70,0x1aeb,0x700f5,0x1a,0x7690,0x14c,0x1aae, + 0x1aed,0x1aeb,0x500b1,0x6e,0x1ab2,0x7690,0x37d,0x500b8,0x6e,0x1ab4,0x7691,0x380, + 0x500a7,0x6e,0x1ab5,0x1ab2,0x1ab4,0x400f6,0x1aee,0x1aeb,0x0,0x400fa,0x1ab5,0x1ab6, + 0x1aee,0x200f8,0x1ab6,0x50041,0x14,0x6c5c,0x6c56,0x8ee3,0x4003d,0x13,0x1ab9,0x6c5c, + 0x50041,0x14,0x6c66,0x6c60,0x8ee4,0x4003d,0x13,0x1abc,0x6c66,0x50083,0x13,0x1abd, + 0x1ab9,0x1abc,0x6000c,0x13,0x1abf,0x1,0x4,0x1abd,0x500ba,0x6e,0x1ac0,0x1abf, + 0x38d,0x300f7,0x1aea,0x0,0x400fa,0x1ac0,0x1ac1,0x1ae9,0x200f8,0x1ae9,0x200f9,0x1aea, + 0x200f8,0x1ac1,0x6000c,0x13,0x1ac3,0x1,0x6,0x1abd,0x4003d,0x13,0x1ac6,0x6c5c, + 0x4003d,0x13,0x1ac9,0x6c66,0x7000c,0x13,0x1d0a,0x1,0x28,0x1ac6,0x1ac9,0x500b7, + 0x6e,0x1cfe,0x1d0a,0x1d8,0x300f7,0x1d04,0x0,0x400fa,0x1cfe,0x1cff,0x1d03,0x200f8, + 0x1d03,0x200f9,0x1d04,0x200f8,0x1cff,0x7000c,0x13,0x1d0f,0x1,0x25,0x1ac6,0x1ac9, + 0x50088,0x13,0x1d02,0x1d0f,0x1d0a,0x200f9,0x1d04,0x200f8,0x1d04,0x700f5,0x13,0x8ee5, + 0x1d02,0x1cff,0x1d8,0x1d03,0x50083,0x13,0x1acb,0x1dc,0x8ee5,0x50085,0x13,0x1acc, + 0x1ac3,0x1acb,0x6000c,0x13,0x1ace,0x1,0x4,0x1acc,0x6000c,0x13,0x1ad0,0x1, + 0x4,0x7691,0x500b8,0x6e,0x1ad1,0x1ace,0x1ad0,0x600a9,0x13,0x1ad4,0x1ad1,0x1acc, + 0x7691,0x4003d,0x13,0x1ad7,0x6c5c,0x4003d,0x13,0x1ada,0x6c66,0x500b8,0x6e,0x1adb, + 0x1ad7,0x1ada,0x600a9,0x1a,0x1adc,0x1adb,0x191,0x14c,0x50080,0x1a,0x1ade,0x8ee3, + 0x1adc,0x50041,0x14,0x6c5f,0x6c56,0x1ade,0x4003d,0x13,0x1ae1,0x6c5f,0x4003d,0x13, + 0x1ae4,0x6c66,0x500be,0x6e,0x1ae5,0x1ae1,0x1ae4,0x600a9,0x1a,0x1ae6,0x1ae5,0x191, + 0x14c,0x50080,0x1a,0x1ae8,0x8ee4,0x1ae6,0x200f9,0x1aea,0x200f8,0x1aea,0x700f5,0x1a, + 0x94ec,0x1ae8,0x1d04,0x8ee4,0x1ae9,0x700f5,0x1a,0x94eb,0x1ade,0x1d04,0x8ee3,0x1ae9, + 0x700f5,0x13,0x8f70,0x1ad4,0x1d04,0x380,0x1ae9,0x200f9,0x1aeb,0x200f8,0x1aeb,0x50080, + 0x1a,0x1aed,0x7690,0x191,0x200f9,0x1aaf,0x200f8,0x1aee,0x200f9,0x1aef,0x200f8,0x1aef, + 0x700f5,0x13,0x7692,0x35e,0x192c,0x7691,0x1aee,0x500b8,0x6e,0x1af2,0x7692,0x35e, + 0x600a9,0x13,0x1af3,0x1af2,0x1dc,0x1d8,0x50085,0x13,0x1af4,0x7692,0x1af3,0x200f9, + 0x1932,0x200f8,0x1932,0x700f5,0x13,0x7693,0x1d8,0x1a1a,0x1af4,0x1aef,0x60052,0x9f, + 0x95aa,0x7693,0x48e,0x0,0x500b7,0x6e,0x18cf,0x7693,0x1d8,0x300f7,0x18d4,0x0, + 0x400fa,0x18cf,0x18d0,0x18d3,0x200f8,0x18d3,0x200f9,0x18d4,0x200f8,0x18d0,0x6000c,0x13, + 0x18d2,0x1,0x6,0x7693,0x200f9,0x18d4,0x200f8,0x18d4,0x700f5,0x13,0x769a,0x18d2, + 0x18d0,0x1d8,0x18d3,0x60052,0x9f,0x95ac,0x769a,0x95aa,0x1,0x60052,0x9f,0x95ae, + 0x1dc,0x95ac,0x2,0x50081,0x9f,0x1d14,0x9548,0x956a,0x50081,0x9f,0x1d16,0x1d14, + 0x958c,0x50081,0x9f,0x1d18,0x1d16,0x95ae,0x5008e,0x9f,0x1d19,0x1d18,0x4af,0x4003d, + 0x1e4,0x1d2b,0x1e6,0x50051,0x13,0x1d2e,0x1d19,0x0,0x50051,0x13,0x1d2f,0x1d19, + 0x1,0x70050,0x9f,0x1d30,0x1d2e,0x1d2f,0x1d8,0x1d8,0x40063,0x1d2b,0xa53,0x1d30, + 0x50080,0x6,0xa64,0xa43,0x59f,0x4007c,0x1a,0xa65,0xa64,0x50050,0x32,0xa69, + 0xa65,0xa47,0x50080,0x32,0xa6a,0xa41,0xa69,0x50080,0x6,0xa70,0x984,0x4bf, + 0x4007c,0x1a,0xa71,0xa70,0x50050,0x32,0xa74,0xa71,0xa51,0x50080,0x32,0xa75, + 0xa4d,0xa74,0x4007c,0x2d,0xa77,0xa6a,0x50080,0x2d,0x1d6e,0xa77,0x542,0x50080, + 0x2d,0x1d70,0xa77,0x545,0x50080,0x2d,0x1d72,0xa77,0x548,0x4006f,0x38,0x1d89, + 0xa6a,0x4006e,0x32,0x1db0,0x1d89,0x50051,0x1a,0x1de3,0x1db0,0x0,0x7000c,0x1a, + 0x1df4,0x1,0x27,0x1de3,0xbc1,0x7000c,0x1a,0x1df9,0x1,0x2a,0x14c,0x1df4, + 0x50051,0x1a,0x1deb,0x1db0,0x1,0x7000c,0x1a,0x1dfe,0x1,0x27,0x1deb,0xbc9, + 0x7000c,0x1a,0x1e03,0x1,0x2a,0x14c,0x1dfe,0x50050,0x32,0x9787,0x1df9,0x1e03, + 0x4003d,0x1b9,0x1e06,0x1ca,0x7005f,0x9f,0x1e08,0x1e06,0x9787,0x2,0x14c,0x7004f, + 0x38,0x1e09,0x1e08,0x1e08,0x0,0x1,0x4006f,0x38,0x1db6,0x9787,0x50081,0x38, + 0x1db8,0x1db6,0x94fd,0x50088,0x38,0x1dbb,0x1db8,0xb9a,0x3003e,0x1e2e,0x3df,0x50081, + 0x38,0x1e3d,0x1dbb,0xc1c,0x50085,0x38,0x1e41,0x1e3d,0xb9a,0x6000c,0x38,0x1e42, + 0x1,0x8,0x1e41,0x4006e,0x32,0x1e43,0x1e42,0x200f9,0x1e44,0x200f8,0x1e44,0x700f5, + 0x1a,0x77ca,0x14c,0x18d4,0x1e63,0x1e48,0x500b1,0x6e,0x1e47,0x77ca,0x37d,0x400f6, + 0x1e64,0x1e48,0x0,0x400fa,0x1e47,0x1e48,0x1e64,0x200f8,0x1e48,0x50041,0x49,0x1e4c, + 0x1e2e,0x77ca,0x4003d,0x32,0x1e4d,0x1e4c,0x50080,0x32,0x1e83,0x1e43,0x1e4d,0x50051, + 0x1a,0x1e88,0x1e83,0x0,0x7000c,0x1a,0x1e99,0x1,0x27,0x1e88,0xbc1,0x7000c, + 0x1a,0x1e9e,0x1,0x2a,0x14c,0x1e99,0x50051,0x1a,0x1e90,0x1e83,0x1,0x7000c, + 0x1a,0x1ea3,0x1,0x27,0x1e90,0xbc9,0x7000c,0x1a,0x1ea8,0x1,0x2a,0x14c, + 0x1ea3,0x50050,0x32,0x97aa,0x1e9e,0x1ea8,0x4003d,0x1b9,0x1eab,0x1bb,0x7005f,0x9f, + 0x1ead,0x1eab,0x97aa,0x2,0x14c,0x50051,0x13,0x1eae,0x1ead,0x0,0x4003d,0x1b9, + 0x1eb2,0x1d2,0x7005f,0x9f,0x1eb3,0x1eb2,0x1d4,0x2,0x14c,0x50051,0x13,0x1eb4, + 0x1eb3,0x0,0x500b4,0x6e,0x1eb6,0x1eb4,0x1d8,0x600a9,0x13,0x950d,0x1eb6,0x1dc, + 0x1eb4,0x50085,0x13,0x1e53,0x1eae,0x950d,0x50041,0x14,0x6b96,0x6b95,0x77ca,0x3003e, + 0x6b96,0x1e53,0x4003d,0x13,0x1e58,0x6b96,0x7000c,0x13,0x1ebe,0x1,0x1a,0x1e58, + 0x1dc,0x3003e,0x6b96,0x1ebe,0x4003d,0x13,0x1e5e,0x6b96,0x7000c,0x13,0x1ec3,0x1, + 0x28,0x1e5e,0x38d,0x3003e,0x6b96,0x1ec3,0x50080,0x1a,0x1e63,0x77ca,0x191,0x200f9, + 0x1e44,0x200f8,0x1e64,0x4003d,0x82,0x6b9b,0x6b95,0x3003e,0x1ecd,0x3df,0x50081,0x38, + 0x1edb,0x1dbb,0xcba,0x50081,0x38,0x1ede,0x1edb,0x1e09,0x50051,0x13,0x1f1b,0x1ede, + 0x0,0x500be,0x6e,0x1f1c,0x1f1b,0x1d8,0x300f7,0x1f21,0x0,0x400fa,0x1f1c,0x1f1d, + 0x1f21,0x200f8,0x1f1d,0x500bc,0x6e,0x1f20,0x1f1b,0x1dc,0x200f9,0x1f21,0x200f8,0x1f21, + 0x700f5,0x6e,0x1f22,0x1f1c,0x1e64,0x1f20,0x1f1d,0x300f7,0x1f2d,0x0,0x400fa,0x1f22, + 0x1f23,0x1f2d,0x200f8,0x1f23,0x50051,0x13,0x1f25,0x1ede,0x1,0x500be,0x6e,0x1f26, + 0x1f25,0x1d8,0x300f7,0x1f2b,0x0,0x400fa,0x1f26,0x1f27,0x1f2b,0x200f8,0x1f27,0x500bc, + 0x6e,0x1f2a,0x1f25,0x1dc,0x200f9,0x1f2b,0x200f8,0x1f2b,0x700f5,0x6e,0x1f2c,0x1f26, + 0x1f23,0x1f2a,0x1f27,0x200f9,0x1f2d,0x200f8,0x1f2d,0x700f5,0x6e,0x1f2e,0x1f22,0x1f21, + 0x1f2c,0x1f2b,0x300f7,0x1f0e,0x0,0x400fa,0x1f2e,0x1ee4,0x1f0e,0x200f8,0x1ee4,0x50085, + 0x38,0x1ee8,0x1ede,0xcb9,0x6000c,0x38,0x1ee9,0x1,0x8,0x1ee8,0x4006e,0x32, + 0x1eea,0x1ee9,0x200f9,0x1eeb,0x200f8,0x1eeb,0x700f5,0x1a,0x77d0,0x14c,0x1ee4,0x1f0c, + 0x1eef,0x500b1,0x6e,0x1eee,0x77d0,0x37d,0x400f6,0x1f0d,0x1eef,0x0,0x400fa,0x1eee, + 0x1eef,0x1f0d,0x200f8,0x1eef,0x50041,0x49,0x1ef3,0x1ecd,0x77d0,0x4003d,0x32,0x1ef4, + 0x1ef3,0x50080,0x32,0x1f44,0x1eea,0x1ef4,0x50051,0x1a,0x1f46,0xcf7,0x0,0x50082, + 0x1a,0x1f47,0x1f46,0x191,0x50051,0x1a,0x1f49,0x1f44,0x0,0x7000c,0x1a,0x1f5a, + 0x1,0x27,0x1f49,0x1f47,0x7000c,0x1a,0x1f5f,0x1,0x2a,0x14c,0x1f5a,0x50051, + 0x1a,0x1f4e,0xcf7,0x1,0x50082,0x1a,0x1f4f,0x1f4e,0x191,0x50051,0x1a,0x1f51, + 0x1f44,0x1,0x7000c,0x1a,0x1f64,0x1,0x27,0x1f51,0x1f4f,0x7000c,0x1a,0x1f69, + 0x1,0x2a,0x14c,0x1f64,0x50050,0x32,0x97a9,0x1f5f,0x1f69,0x4003d,0x1b9,0x1f6c, + 0x1c3,0x7005f,0x9f,0x1f6e,0x1f6c,0x97a9,0x2,0x14c,0x50051,0x13,0x1f6f,0x1f6e, + 0x0,0x50041,0x1a2,0x1f72,0x18b,0x20b,0x4003d,0x13,0x1f73,0x1f72,0x50085,0x13, + 0x1efa,0x1f6f,0x1f73,0x4003d,0x1b9,0x1f77,0x1d2,0x7005f,0x9f,0x1f78,0x1f77,0x1d4, + 0x2,0x14c,0x50051,0x13,0x1f79,0x1f78,0x0,0x500b4,0x6e,0x1f7b,0x1f79,0x1d8, + 0x600a9,0x13,0x950e,0x1f7b,0x1dc,0x1f79,0x50085,0x13,0x1efc,0x1efa,0x950e,0x50041, + 0x14,0x7206,0x7205,0x77d0,0x3003e,0x7206,0x1efc,0x4003d,0x13,0x1f01,0x7206,0x7000c, + 0x13,0x1f83,0x1,0x1a,0x1f01,0x1dc,0x3003e,0x7206,0x1f83,0x4003d,0x13,0x1f07, + 0x7206,0x7000c,0x13,0x1f88,0x1,0x28,0x1f07,0x38d,0x3003e,0x7206,0x1f88,0x50080, + 0x1a,0x1f0c,0x77d0,0x191,0x200f9,0x1eeb,0x200f8,0x1f0d,0x200f9,0x1f0e,0x200f8,0x1f0e, + 0x4003d,0x82,0x720b,0x7205,0x300f7,0x1e26,0x0,0x400fa,0x1f2e,0x1e20,0x1e26,0x200f8, + 0x1e20,0x50051,0x13,0x71ea,0x6b9b,0x0,0x50051,0x13,0x71eb,0x6b9b,0x1,0x50051, + 0x13,0x71ec,0x6b9b,0x2,0x50051,0x13,0x71ed,0x6b9b,0x3,0x50051,0x13,0x71ee, + 0x6b9b,0x4,0x7000c,0x13,0x2090,0x1,0x25,0x71ea,0x71ed,0x7000c,0x13,0x2095, + 0x1,0x28,0x71ea,0x71ed,0x7000c,0x13,0x209a,0x1,0x25,0x71eb,0x71ee,0x7000c, + 0x13,0x209f,0x1,0x28,0x71eb,0x71ee,0x7000c,0x13,0x20a4,0x1,0x25,0x2090, + 0x71ec,0x7000c,0x13,0x20a9,0x1,0x28,0x2090,0x71ec,0x7000c,0x13,0x20ae,0x1, + 0x25,0x209a,0x2095,0x7000c,0x13,0x20b3,0x1,0x28,0x209a,0x2095,0x7000c,0x13, + 0x20b8,0x1,0x25,0x20a4,0x20ae,0x7000c,0x13,0x20bd,0x1,0x28,0x20a4,0x20ae, + 0x7000c,0x13,0x20c2,0x1,0x25,0x20a9,0x209f,0x7000c,0x13,0x20c7,0x1,0x28, + 0x20a9,0x209f,0x7000c,0x13,0x20cc,0x1,0x25,0x20bd,0x20c2,0x7000c,0x13,0x20d1, + 0x1,0x28,0x20bd,0x20c2,0x7000c,0x13,0x20d6,0x1,0x25,0x20b3,0x20c7,0x7000c, + 0x13,0x20db,0x1,0x28,0x20b3,0x20c7,0x7000c,0x13,0x20e0,0x1,0x25,0x20d1, + 0x20d6,0x7000c,0x13,0x20e5,0x1,0x28,0x20d1,0x20d6,0x80050,0x82,0x71f4,0x20b8, + 0x20cc,0x20e0,0x20e5,0x20db,0x3003e,0x6ba9,0x71f4,0x50051,0x13,0x71fa,0x720b,0x0, + 0x50051,0x13,0x71fb,0x720b,0x1,0x50051,0x13,0x71fc,0x720b,0x2,0x50051,0x13, + 0x71fd,0x720b,0x3,0x50051,0x13,0x71fe,0x720b,0x4,0x7000c,0x13,0x218d,0x1, + 0x25,0x71fa,0x71fd,0x7000c,0x13,0x2192,0x1,0x28,0x71fa,0x71fd,0x7000c,0x13, + 0x2197,0x1,0x25,0x71fb,0x71fe,0x7000c,0x13,0x219c,0x1,0x28,0x71fb,0x71fe, + 0x7000c,0x13,0x21a1,0x1,0x25,0x218d,0x71fc,0x7000c,0x13,0x21a6,0x1,0x28, + 0x218d,0x71fc,0x7000c,0x13,0x21ab,0x1,0x25,0x2197,0x2192,0x7000c,0x13,0x21b0, + 0x1,0x28,0x2197,0x2192,0x7000c,0x13,0x21b5,0x1,0x25,0x21a1,0x21ab,0x7000c, + 0x13,0x21ba,0x1,0x28,0x21a1,0x21ab,0x7000c,0x13,0x21bf,0x1,0x25,0x21a6, + 0x219c,0x7000c,0x13,0x21c4,0x1,0x28,0x21a6,0x219c,0x7000c,0x13,0x21c9,0x1, + 0x25,0x21ba,0x21bf,0x7000c,0x13,0x21ce,0x1,0x28,0x21ba,0x21bf,0x7000c,0x13, + 0x21d3,0x1,0x25,0x21b0,0x21c4,0x7000c,0x13,0x21d8,0x1,0x28,0x21b0,0x21c4, + 0x7000c,0x13,0x21dd,0x1,0x25,0x21ce,0x21d3,0x7000c,0x13,0x21e2,0x1,0x28, + 0x21ce,0x21d3,0x80050,0x82,0x7204,0x21b5,0x21c9,0x21dd,0x21e2,0x21d8,0x3003e,0x6bb3, + 0x7204,0x50041,0x14,0x6bae,0x6ba9,0x2cd,0x4003d,0x13,0x1f9c,0x6bae,0x50041,0x14, + 0x6bb8,0x6bb3,0x2cd,0x4003d,0x13,0x1f9e,0x6bb8,0x7000c,0x13,0x21e7,0x1,0x25, + 0x1f9c,0x1f9e,0x500ba,0x6e,0x1fa1,0x21e7,0x372,0x300f7,0x1fe3,0x0,0x400fa,0x1fa1, + 0x1fa2,0x1fe3,0x200f8,0x1fa2,0x200f9,0x1fa3,0x200f8,0x1fa3,0x700f5,0x1a,0x8ed6,0x14c, + 0x1fa2,0x94e8,0x1fdf,0x700f5,0x1a,0x8ed5,0x14c,0x1fa2,0x94e7,0x1fdf,0x700f5,0x13, + 0x77f3,0x35e,0x1fa2,0x8fe5,0x1fdf,0x700f5,0x1a,0x77f2,0x14c,0x1fa2,0x1fe1,0x1fdf, + 0x500b1,0x6e,0x1fa6,0x77f2,0x37d,0x500b8,0x6e,0x1fa8,0x77f3,0x380,0x500a7,0x6e, + 0x1fa9,0x1fa6,0x1fa8,0x400f6,0x1fe2,0x1fdf,0x0,0x400fa,0x1fa9,0x1faa,0x1fe2,0x200f8, + 0x1faa,0x50041,0x14,0x6baf,0x6ba9,0x8ed5,0x4003d,0x13,0x1fad,0x6baf,0x50041,0x14, + 0x6bb9,0x6bb3,0x8ed6,0x4003d,0x13,0x1fb0,0x6bb9,0x50083,0x13,0x1fb1,0x1fad,0x1fb0, + 0x6000c,0x13,0x1fb3,0x1,0x4,0x1fb1,0x500ba,0x6e,0x1fb4,0x1fb3,0x38d,0x300f7, + 0x1fde,0x0,0x400fa,0x1fb4,0x1fb5,0x1fdd,0x200f8,0x1fdd,0x200f9,0x1fde,0x200f8,0x1fb5, + 0x6000c,0x13,0x1fb7,0x1,0x6,0x1fb1,0x4003d,0x13,0x1fba,0x6baf,0x4003d,0x13, + 0x1fbd,0x6bb9,0x7000c,0x13,0x21fe,0x1,0x28,0x1fba,0x1fbd,0x500b7,0x6e,0x21f2, + 0x21fe,0x1d8,0x300f7,0x21f8,0x0,0x400fa,0x21f2,0x21f3,0x21f7,0x200f8,0x21f7,0x200f9, + 0x21f8,0x200f8,0x21f3,0x7000c,0x13,0x2203,0x1,0x25,0x1fba,0x1fbd,0x50088,0x13, + 0x21f6,0x2203,0x21fe,0x200f9,0x21f8,0x200f8,0x21f8,0x700f5,0x13,0x8ed7,0x21f6,0x21f3, + 0x1d8,0x21f7,0x50083,0x13,0x1fbf,0x1dc,0x8ed7,0x50085,0x13,0x1fc0,0x1fb7,0x1fbf, + 0x6000c,0x13,0x1fc2,0x1,0x4,0x1fc0,0x6000c,0x13,0x1fc4,0x1,0x4,0x77f3, + 0x500b8,0x6e,0x1fc5,0x1fc2,0x1fc4,0x600a9,0x13,0x1fc8,0x1fc5,0x1fc0,0x77f3,0x4003d, + 0x13,0x1fcb,0x6baf,0x4003d,0x13,0x1fce,0x6bb9,0x500b8,0x6e,0x1fcf,0x1fcb,0x1fce, + 0x600a9,0x1a,0x1fd0,0x1fcf,0x191,0x14c,0x50080,0x1a,0x1fd2,0x8ed5,0x1fd0,0x50041, + 0x14,0x6bb2,0x6ba9,0x1fd2,0x4003d,0x13,0x1fd5,0x6bb2,0x4003d,0x13,0x1fd8,0x6bb9, + 0x500be,0x6e,0x1fd9,0x1fd5,0x1fd8,0x600a9,0x1a,0x1fda,0x1fd9,0x191,0x14c,0x50080, + 0x1a,0x1fdc,0x8ed6,0x1fda,0x200f9,0x1fde,0x200f8,0x1fde,0x700f5,0x1a,0x94e8,0x1fdc, + 0x21f8,0x8ed6,0x1fdd,0x700f5,0x1a,0x94e7,0x1fd2,0x21f8,0x8ed5,0x1fdd,0x700f5,0x13, + 0x8fe5,0x1fc8,0x21f8,0x380,0x1fdd,0x200f9,0x1fdf,0x200f8,0x1fdf,0x50080,0x1a,0x1fe1, + 0x77f2,0x191,0x200f9,0x1fa3,0x200f8,0x1fe2,0x200f9,0x1fe3,0x200f8,0x1fe3,0x700f5,0x13, + 0x77f4,0x35e,0x1e20,0x77f3,0x1fe2,0x500b8,0x6e,0x1fe6,0x77f4,0x35e,0x600a9,0x13, + 0x1fe7,0x1fe6,0x1dc,0x1d8,0x50085,0x13,0x1fe8,0x77f4,0x1fe7,0x200f9,0x1e26,0x200f8, + 0x1e26,0x700f5,0x13,0x77f5,0x1d8,0x1f0e,0x1fe8,0x1fe3,0x60052,0x9f,0x95cc,0x77f5, + 0x48e,0x0,0x500b7,0x6e,0x1dc3,0x77f5,0x1d8,0x300f7,0x1dc8,0x0,0x400fa,0x1dc3, + 0x1dc4,0x1dc7,0x200f8,0x1dc7,0x200f9,0x1dc8,0x200f8,0x1dc4,0x6000c,0x13,0x1dc6,0x1, + 0x6,0x77f5,0x200f9,0x1dc8,0x200f8,0x1dc8,0x700f5,0x13,0x77fc,0x1dc6,0x1dc4,0x1d8, + 0x1dc7,0x60052,0x9f,0x95ce,0x77fc,0x95cc,0x1,0x60052,0x9f,0x95d0,0x1dc,0x95ce, + 0x2,0x4007c,0x32,0x1d8d,0x1d6e,0x4006f,0x38,0x1d8e,0x1d8d,0x4006e,0x32,0x2214, + 0x1d8e,0x50051,0x1a,0x2247,0x2214,0x0,0x7000c,0x1a,0x2258,0x1,0x27,0x2247, + 0xbc1,0x7000c,0x1a,0x225d,0x1,0x2a,0x14c,0x2258,0x50051,0x1a,0x224f,0x2214, + 0x1,0x7000c,0x1a,0x2262,0x1,0x27,0x224f,0xbc9,0x7000c,0x1a,0x2267,0x1, + 0x2a,0x14c,0x2262,0x50050,0x32,0x9788,0x225d,0x2267,0x4003d,0x1b9,0x226a,0x1ca, + 0x7005f,0x9f,0x226c,0x226a,0x9788,0x2,0x14c,0x7004f,0x38,0x226d,0x226c,0x226c, + 0x0,0x1,0x4006f,0x38,0x221a,0x9788,0x50081,0x38,0x221c,0x221a,0x94fd,0x50088, + 0x38,0x221f,0x221c,0xb9a,0x3003e,0x2292,0x3df,0x50081,0x38,0x22a1,0x221f,0xc1c, + 0x50085,0x38,0x22a5,0x22a1,0xb9a,0x6000c,0x38,0x22a6,0x1,0x8,0x22a5,0x4006e, + 0x32,0x22a7,0x22a6,0x200f9,0x22a8,0x200f8,0x22a8,0x700f5,0x1a,0x7811,0x14c,0x1dc8, + 0x22c7,0x22ac,0x500b1,0x6e,0x22ab,0x7811,0x37d,0x400f6,0x22c8,0x22ac,0x0,0x400fa, + 0x22ab,0x22ac,0x22c8,0x200f8,0x22ac,0x50041,0x49,0x22b0,0x2292,0x7811,0x4003d,0x32, + 0x22b1,0x22b0,0x50080,0x32,0x22e7,0x22a7,0x22b1,0x50051,0x1a,0x22ec,0x22e7,0x0, + 0x7000c,0x1a,0x22fd,0x1,0x27,0x22ec,0xbc1,0x7000c,0x1a,0x2302,0x1,0x2a, + 0x14c,0x22fd,0x50051,0x1a,0x22f4,0x22e7,0x1,0x7000c,0x1a,0x2307,0x1,0x27, + 0x22f4,0xbc9,0x7000c,0x1a,0x230c,0x1,0x2a,0x14c,0x2307,0x50050,0x32,0x97a8, + 0x2302,0x230c,0x4003d,0x1b9,0x230f,0x1bb,0x7005f,0x9f,0x2311,0x230f,0x97a8,0x2, + 0x14c,0x50051,0x13,0x2312,0x2311,0x0,0x4003d,0x1b9,0x2316,0x1d2,0x7005f,0x9f, + 0x2317,0x2316,0x1d4,0x2,0x14c,0x50051,0x13,0x2318,0x2317,0x0,0x500b4,0x6e, + 0x231a,0x2318,0x1d8,0x600a9,0x13,0x950f,0x231a,0x1dc,0x2318,0x50085,0x13,0x22b7, + 0x2312,0x950f,0x50041,0x14,0x6ae9,0x6ae8,0x7811,0x3003e,0x6ae9,0x22b7,0x4003d,0x13, + 0x22bc,0x6ae9,0x7000c,0x13,0x2322,0x1,0x1a,0x22bc,0x1dc,0x3003e,0x6ae9,0x2322, + 0x4003d,0x13,0x22c2,0x6ae9,0x7000c,0x13,0x2327,0x1,0x28,0x22c2,0x38d,0x3003e, + 0x6ae9,0x2327,0x50080,0x1a,0x22c7,0x7811,0x191,0x200f9,0x22a8,0x200f8,0x22c8,0x4003d, + 0x82,0x6aee,0x6ae8,0x3003e,0x2331,0x3df,0x50081,0x38,0x233f,0x221f,0xcba,0x50081, + 0x38,0x2342,0x233f,0x226d,0x50051,0x13,0x237f,0x2342,0x0,0x500be,0x6e,0x2380, + 0x237f,0x1d8,0x300f7,0x2385,0x0,0x400fa,0x2380,0x2381,0x2385,0x200f8,0x2381,0x500bc, + 0x6e,0x2384,0x237f,0x1dc,0x200f9,0x2385,0x200f8,0x2385,0x700f5,0x6e,0x2386,0x2380, + 0x22c8,0x2384,0x2381,0x300f7,0x2391,0x0,0x400fa,0x2386,0x2387,0x2391,0x200f8,0x2387, + 0x50051,0x13,0x2389,0x2342,0x1,0x500be,0x6e,0x238a,0x2389,0x1d8,0x300f7,0x238f, + 0x0,0x400fa,0x238a,0x238b,0x238f,0x200f8,0x238b,0x500bc,0x6e,0x238e,0x2389,0x1dc, + 0x200f9,0x238f,0x200f8,0x238f,0x700f5,0x6e,0x2390,0x238a,0x2387,0x238e,0x238b,0x200f9, + 0x2391,0x200f8,0x2391,0x700f5,0x6e,0x2392,0x2386,0x2385,0x2390,0x238f,0x300f7,0x2372, + 0x0,0x400fa,0x2392,0x2348,0x2372,0x200f8,0x2348,0x50085,0x38,0x234c,0x2342,0xcb9, + 0x6000c,0x38,0x234d,0x1,0x8,0x234c,0x4006e,0x32,0x234e,0x234d,0x200f9,0x234f, + 0x200f8,0x234f,0x700f5,0x1a,0x7817,0x14c,0x2348,0x2370,0x2353,0x500b1,0x6e,0x2352, + 0x7817,0x37d,0x400f6,0x2371,0x2353,0x0,0x400fa,0x2352,0x2353,0x2371,0x200f8,0x2353, + 0x50041,0x49,0x2357,0x2331,0x7817,0x4003d,0x32,0x2358,0x2357,0x50080,0x32,0x23a8, + 0x234e,0x2358,0x50051,0x1a,0x23aa,0xcf7,0x0,0x50082,0x1a,0x23ab,0x23aa,0x191, + 0x50051,0x1a,0x23ad,0x23a8,0x0,0x7000c,0x1a,0x23be,0x1,0x27,0x23ad,0x23ab, + 0x7000c,0x1a,0x23c3,0x1,0x2a,0x14c,0x23be,0x50051,0x1a,0x23b2,0xcf7,0x1, + 0x50082,0x1a,0x23b3,0x23b2,0x191,0x50051,0x1a,0x23b5,0x23a8,0x1,0x7000c,0x1a, + 0x23c8,0x1,0x27,0x23b5,0x23b3,0x7000c,0x1a,0x23cd,0x1,0x2a,0x14c,0x23c8, + 0x50050,0x32,0x97a7,0x23c3,0x23cd,0x4003d,0x1b9,0x23d0,0x1c3,0x7005f,0x9f,0x23d2, + 0x23d0,0x97a7,0x2,0x14c,0x50051,0x13,0x23d3,0x23d2,0x0,0x50041,0x1a2,0x23d6, + 0x18b,0x20b,0x4003d,0x13,0x23d7,0x23d6,0x50085,0x13,0x235e,0x23d3,0x23d7,0x4003d, + 0x1b9,0x23db,0x1d2,0x7005f,0x9f,0x23dc,0x23db,0x1d4,0x2,0x14c,0x50051,0x13, + 0x23dd,0x23dc,0x0,0x500b4,0x6e,0x23df,0x23dd,0x1d8,0x600a9,0x13,0x9510,0x23df, + 0x1dc,0x23dd,0x50085,0x13,0x2360,0x235e,0x9510,0x50041,0x14,0x71b6,0x71b5,0x7817, + 0x3003e,0x71b6,0x2360,0x4003d,0x13,0x2365,0x71b6,0x7000c,0x13,0x23e7,0x1,0x1a, + 0x2365,0x1dc,0x3003e,0x71b6,0x23e7,0x4003d,0x13,0x236b,0x71b6,0x7000c,0x13,0x23ec, + 0x1,0x28,0x236b,0x38d,0x3003e,0x71b6,0x23ec,0x50080,0x1a,0x2370,0x7817,0x191, + 0x200f9,0x234f,0x200f8,0x2371,0x200f9,0x2372,0x200f8,0x2372,0x4003d,0x82,0x71bb,0x71b5, + 0x300f7,0x228a,0x0,0x400fa,0x2392,0x2284,0x228a,0x200f8,0x2284,0x50051,0x13,0x719a, + 0x6aee,0x0,0x50051,0x13,0x719b,0x6aee,0x1,0x50051,0x13,0x719c,0x6aee,0x2, + 0x50051,0x13,0x719d,0x6aee,0x3,0x50051,0x13,0x719e,0x6aee,0x4,0x7000c,0x13, + 0x24f4,0x1,0x25,0x719a,0x719d,0x7000c,0x13,0x24f9,0x1,0x28,0x719a,0x719d, + 0x7000c,0x13,0x24fe,0x1,0x25,0x719b,0x719e,0x7000c,0x13,0x2503,0x1,0x28, + 0x719b,0x719e,0x7000c,0x13,0x2508,0x1,0x25,0x24f4,0x719c,0x7000c,0x13,0x250d, + 0x1,0x28,0x24f4,0x719c,0x7000c,0x13,0x2512,0x1,0x25,0x24fe,0x24f9,0x7000c, + 0x13,0x2517,0x1,0x28,0x24fe,0x24f9,0x7000c,0x13,0x251c,0x1,0x25,0x2508, + 0x2512,0x7000c,0x13,0x2521,0x1,0x28,0x2508,0x2512,0x7000c,0x13,0x2526,0x1, + 0x25,0x250d,0x2503,0x7000c,0x13,0x252b,0x1,0x28,0x250d,0x2503,0x7000c,0x13, + 0x2530,0x1,0x25,0x2521,0x2526,0x7000c,0x13,0x2535,0x1,0x28,0x2521,0x2526, + 0x7000c,0x13,0x253a,0x1,0x25,0x2517,0x252b,0x7000c,0x13,0x253f,0x1,0x28, + 0x2517,0x252b,0x7000c,0x13,0x2544,0x1,0x25,0x2535,0x253a,0x7000c,0x13,0x2549, + 0x1,0x28,0x2535,0x253a,0x80050,0x82,0x71a4,0x251c,0x2530,0x2544,0x2549,0x253f, + 0x3003e,0x6afc,0x71a4,0x50051,0x13,0x71aa,0x71bb,0x0,0x50051,0x13,0x71ab,0x71bb, + 0x1,0x50051,0x13,0x71ac,0x71bb,0x2,0x50051,0x13,0x71ad,0x71bb,0x3,0x50051, + 0x13,0x71ae,0x71bb,0x4,0x7000c,0x13,0x25f1,0x1,0x25,0x71aa,0x71ad,0x7000c, + 0x13,0x25f6,0x1,0x28,0x71aa,0x71ad,0x7000c,0x13,0x25fb,0x1,0x25,0x71ab, + 0x71ae,0x7000c,0x13,0x2600,0x1,0x28,0x71ab,0x71ae,0x7000c,0x13,0x2605,0x1, + 0x25,0x25f1,0x71ac,0x7000c,0x13,0x260a,0x1,0x28,0x25f1,0x71ac,0x7000c,0x13, + 0x260f,0x1,0x25,0x25fb,0x25f6,0x7000c,0x13,0x2614,0x1,0x28,0x25fb,0x25f6, + 0x7000c,0x13,0x2619,0x1,0x25,0x2605,0x260f,0x7000c,0x13,0x261e,0x1,0x28, + 0x2605,0x260f,0x7000c,0x13,0x2623,0x1,0x25,0x260a,0x2600,0x7000c,0x13,0x2628, + 0x1,0x28,0x260a,0x2600,0x7000c,0x13,0x262d,0x1,0x25,0x261e,0x2623,0x7000c, + 0x13,0x2632,0x1,0x28,0x261e,0x2623,0x7000c,0x13,0x2637,0x1,0x25,0x2614, + 0x2628,0x7000c,0x13,0x263c,0x1,0x28,0x2614,0x2628,0x7000c,0x13,0x2641,0x1, + 0x25,0x2632,0x2637,0x7000c,0x13,0x2646,0x1,0x28,0x2632,0x2637,0x80050,0x82, + 0x71b4,0x2619,0x262d,0x2641,0x2646,0x263c,0x3003e,0x6b06,0x71b4,0x50041,0x14,0x6b01, + 0x6afc,0x2cd,0x4003d,0x13,0x2400,0x6b01,0x50041,0x14,0x6b0b,0x6b06,0x2cd,0x4003d, + 0x13,0x2402,0x6b0b,0x7000c,0x13,0x264b,0x1,0x25,0x2400,0x2402,0x500ba,0x6e, + 0x2405,0x264b,0x372,0x300f7,0x2447,0x0,0x400fa,0x2405,0x2406,0x2447,0x200f8,0x2406, + 0x200f9,0x2407,0x200f8,0x2407,0x700f5,0x1a,0x8ec8,0x14c,0x2406,0x94e4,0x2443,0x700f5, + 0x1a,0x8ec7,0x14c,0x2406,0x94e3,0x2443,0x700f5,0x13,0x783a,0x35e,0x2406,0x8ffa, + 0x2443,0x700f5,0x1a,0x7839,0x14c,0x2406,0x2445,0x2443,0x500b1,0x6e,0x240a,0x7839, + 0x37d,0x500b8,0x6e,0x240c,0x783a,0x380,0x500a7,0x6e,0x240d,0x240a,0x240c,0x400f6, + 0x2446,0x2443,0x0,0x400fa,0x240d,0x240e,0x2446,0x200f8,0x240e,0x50041,0x14,0x6b02, + 0x6afc,0x8ec7,0x4003d,0x13,0x2411,0x6b02,0x50041,0x14,0x6b0c,0x6b06,0x8ec8,0x4003d, + 0x13,0x2414,0x6b0c,0x50083,0x13,0x2415,0x2411,0x2414,0x6000c,0x13,0x2417,0x1, + 0x4,0x2415,0x500ba,0x6e,0x2418,0x2417,0x38d,0x300f7,0x2442,0x0,0x400fa,0x2418, + 0x2419,0x2441,0x200f8,0x2441,0x200f9,0x2442,0x200f8,0x2419,0x6000c,0x13,0x241b,0x1, + 0x6,0x2415,0x4003d,0x13,0x241e,0x6b02,0x4003d,0x13,0x2421,0x6b0c,0x7000c,0x13, + 0x2662,0x1,0x28,0x241e,0x2421,0x500b7,0x6e,0x2656,0x2662,0x1d8,0x300f7,0x265c, + 0x0,0x400fa,0x2656,0x2657,0x265b,0x200f8,0x265b,0x200f9,0x265c,0x200f8,0x2657,0x7000c, + 0x13,0x2667,0x1,0x25,0x241e,0x2421,0x50088,0x13,0x265a,0x2667,0x2662,0x200f9, + 0x265c,0x200f8,0x265c,0x700f5,0x13,0x8ec9,0x265a,0x2657,0x1d8,0x265b,0x50083,0x13, + 0x2423,0x1dc,0x8ec9,0x50085,0x13,0x2424,0x241b,0x2423,0x6000c,0x13,0x2426,0x1, + 0x4,0x2424,0x6000c,0x13,0x2428,0x1,0x4,0x783a,0x500b8,0x6e,0x2429,0x2426, + 0x2428,0x600a9,0x13,0x242c,0x2429,0x2424,0x783a,0x4003d,0x13,0x242f,0x6b02,0x4003d, + 0x13,0x2432,0x6b0c,0x500b8,0x6e,0x2433,0x242f,0x2432,0x600a9,0x1a,0x2434,0x2433, + 0x191,0x14c,0x50080,0x1a,0x2436,0x8ec7,0x2434,0x50041,0x14,0x6b05,0x6afc,0x2436, + 0x4003d,0x13,0x2439,0x6b05,0x4003d,0x13,0x243c,0x6b0c,0x500be,0x6e,0x243d,0x2439, + 0x243c,0x600a9,0x1a,0x243e,0x243d,0x191,0x14c,0x50080,0x1a,0x2440,0x8ec8,0x243e, + 0x200f9,0x2442,0x200f8,0x2442,0x700f5,0x1a,0x94e4,0x2440,0x265c,0x8ec8,0x2441,0x700f5, + 0x1a,0x94e3,0x2436,0x265c,0x8ec7,0x2441,0x700f5,0x13,0x8ffa,0x242c,0x265c,0x380, + 0x2441,0x200f9,0x2443,0x200f8,0x2443,0x50080,0x1a,0x2445,0x7839,0x191,0x200f9,0x2407, + 0x200f8,0x2446,0x200f9,0x2447,0x200f8,0x2447,0x700f5,0x13,0x783b,0x35e,0x2284,0x783a, + 0x2446,0x500b8,0x6e,0x244a,0x783b,0x35e,0x600a9,0x13,0x244b,0x244a,0x1dc,0x1d8, + 0x50085,0x13,0x244c,0x783b,0x244b,0x200f9,0x228a,0x200f8,0x228a,0x700f5,0x13,0x783c, + 0x1d8,0x2372,0x244c,0x2447,0x60052,0x9f,0x95ee,0x783c,0x48e,0x0,0x500b7,0x6e, + 0x2227,0x783c,0x1d8,0x300f7,0x222c,0x0,0x400fa,0x2227,0x2228,0x222b,0x200f8,0x222b, + 0x200f9,0x222c,0x200f8,0x2228,0x6000c,0x13,0x222a,0x1,0x6,0x783c,0x200f9,0x222c, + 0x200f8,0x222c,0x700f5,0x13,0x7843,0x222a,0x2228,0x1d8,0x222b,0x60052,0x9f,0x95f0, + 0x7843,0x95ee,0x1,0x60052,0x9f,0x95f2,0x1dc,0x95f0,0x2,0x4007c,0x32,0x1d92, + 0x1d70,0x4006f,0x38,0x1d93,0x1d92,0x4006e,0x32,0x2678,0x1d93,0x50051,0x1a,0x26ab, + 0x2678,0x0,0x7000c,0x1a,0x26bc,0x1,0x27,0x26ab,0xbc1,0x7000c,0x1a,0x26c1, + 0x1,0x2a,0x14c,0x26bc,0x50051,0x1a,0x26b3,0x2678,0x1,0x7000c,0x1a,0x26c6, + 0x1,0x27,0x26b3,0xbc9,0x7000c,0x1a,0x26cb,0x1,0x2a,0x14c,0x26c6,0x50050, + 0x32,0x9789,0x26c1,0x26cb,0x4003d,0x1b9,0x26ce,0x1ca,0x7005f,0x9f,0x26d0,0x26ce, + 0x9789,0x2,0x14c,0x7004f,0x38,0x26d1,0x26d0,0x26d0,0x0,0x1,0x4006f,0x38, + 0x267e,0x9789,0x50081,0x38,0x2680,0x267e,0x94fd,0x50088,0x38,0x2683,0x2680,0xb9a, + 0x3003e,0x26f6,0x3df,0x50081,0x38,0x2705,0x2683,0xc1c,0x50085,0x38,0x2709,0x2705, + 0xb9a,0x6000c,0x38,0x270a,0x1,0x8,0x2709,0x4006e,0x32,0x270b,0x270a,0x200f9, + 0x270c,0x200f8,0x270c,0x700f5,0x1a,0x7862,0x14c,0x222c,0x272b,0x2710,0x500b1,0x6e, + 0x270f,0x7862,0x37d,0x400f6,0x272c,0x2710,0x0,0x400fa,0x270f,0x2710,0x272c,0x200f8, + 0x2710,0x50041,0x49,0x2714,0x26f6,0x7862,0x4003d,0x32,0x2715,0x2714,0x50080,0x32, + 0x274b,0x270b,0x2715,0x50051,0x1a,0x2750,0x274b,0x0,0x7000c,0x1a,0x2761,0x1, + 0x27,0x2750,0xbc1,0x7000c,0x1a,0x2766,0x1,0x2a,0x14c,0x2761,0x50051,0x1a, + 0x2758,0x274b,0x1,0x7000c,0x1a,0x276b,0x1,0x27,0x2758,0xbc9,0x7000c,0x1a, + 0x2770,0x1,0x2a,0x14c,0x276b,0x50050,0x32,0x97a6,0x2766,0x2770,0x4003d,0x1b9, + 0x2773,0x1bb,0x7005f,0x9f,0x2775,0x2773,0x97a6,0x2,0x14c,0x50051,0x13,0x2776, + 0x2775,0x0,0x4003d,0x1b9,0x277a,0x1d2,0x7005f,0x9f,0x277b,0x277a,0x1d4,0x2, + 0x14c,0x50051,0x13,0x277c,0x277b,0x0,0x500b4,0x6e,0x277e,0x277c,0x1d8,0x600a9, + 0x13,0x9511,0x277e,0x1dc,0x277c,0x50085,0x13,0x271b,0x2776,0x9511,0x50041,0x14, + 0x6a3c,0x6a3b,0x7862,0x3003e,0x6a3c,0x271b,0x4003d,0x13,0x2720,0x6a3c,0x7000c,0x13, + 0x2786,0x1,0x1a,0x2720,0x1dc,0x3003e,0x6a3c,0x2786,0x4003d,0x13,0x2726,0x6a3c, + 0x7000c,0x13,0x278b,0x1,0x28,0x2726,0x38d,0x3003e,0x6a3c,0x278b,0x50080,0x1a, + 0x272b,0x7862,0x191,0x200f9,0x270c,0x200f8,0x272c,0x4003d,0x82,0x6a41,0x6a3b,0x3003e, + 0x2795,0x3df,0x50081,0x38,0x27a3,0x2683,0xcba,0x50081,0x38,0x27a6,0x27a3,0x26d1, + 0x50051,0x13,0x27e3,0x27a6,0x0,0x500be,0x6e,0x27e4,0x27e3,0x1d8,0x300f7,0x27e9, + 0x0,0x400fa,0x27e4,0x27e5,0x27e9,0x200f8,0x27e5,0x500bc,0x6e,0x27e8,0x27e3,0x1dc, + 0x200f9,0x27e9,0x200f8,0x27e9,0x700f5,0x6e,0x27ea,0x27e4,0x272c,0x27e8,0x27e5,0x300f7, + 0x27f5,0x0,0x400fa,0x27ea,0x27eb,0x27f5,0x200f8,0x27eb,0x50051,0x13,0x27ed,0x27a6, + 0x1,0x500be,0x6e,0x27ee,0x27ed,0x1d8,0x300f7,0x27f3,0x0,0x400fa,0x27ee,0x27ef, + 0x27f3,0x200f8,0x27ef,0x500bc,0x6e,0x27f2,0x27ed,0x1dc,0x200f9,0x27f3,0x200f8,0x27f3, + 0x700f5,0x6e,0x27f4,0x27ee,0x27eb,0x27f2,0x27ef,0x200f9,0x27f5,0x200f8,0x27f5,0x700f5, + 0x6e,0x27f6,0x27ea,0x27e9,0x27f4,0x27f3,0x300f7,0x27d6,0x0,0x400fa,0x27f6,0x27ac, + 0x27d6,0x200f8,0x27ac,0x50085,0x38,0x27b0,0x27a6,0xcb9,0x6000c,0x38,0x27b1,0x1, + 0x8,0x27b0,0x4006e,0x32,0x27b2,0x27b1,0x200f9,0x27b3,0x200f8,0x27b3,0x700f5,0x1a, + 0x7868,0x14c,0x27ac,0x27d4,0x27b7,0x500b1,0x6e,0x27b6,0x7868,0x37d,0x400f6,0x27d5, + 0x27b7,0x0,0x400fa,0x27b6,0x27b7,0x27d5,0x200f8,0x27b7,0x50041,0x49,0x27bb,0x2795, + 0x7868,0x4003d,0x32,0x27bc,0x27bb,0x50080,0x32,0x280c,0x27b2,0x27bc,0x50051,0x1a, + 0x280e,0xcf7,0x0,0x50082,0x1a,0x280f,0x280e,0x191,0x50051,0x1a,0x2811,0x280c, + 0x0,0x7000c,0x1a,0x2822,0x1,0x27,0x2811,0x280f,0x7000c,0x1a,0x2827,0x1, + 0x2a,0x14c,0x2822,0x50051,0x1a,0x2816,0xcf7,0x1,0x50082,0x1a,0x2817,0x2816, + 0x191,0x50051,0x1a,0x2819,0x280c,0x1,0x7000c,0x1a,0x282c,0x1,0x27,0x2819, + 0x2817,0x7000c,0x1a,0x2831,0x1,0x2a,0x14c,0x282c,0x50050,0x32,0x97a5,0x2827, + 0x2831,0x4003d,0x1b9,0x2834,0x1c3,0x7005f,0x9f,0x2836,0x2834,0x97a5,0x2,0x14c, + 0x50051,0x13,0x2837,0x2836,0x0,0x50041,0x1a2,0x283a,0x18b,0x20b,0x4003d,0x13, + 0x283b,0x283a,0x50085,0x13,0x27c2,0x2837,0x283b,0x4003d,0x1b9,0x283f,0x1d2,0x7005f, + 0x9f,0x2840,0x283f,0x1d4,0x2,0x14c,0x50051,0x13,0x2841,0x2840,0x0,0x500b4, + 0x6e,0x2843,0x2841,0x1d8,0x600a9,0x13,0x9512,0x2843,0x1dc,0x2841,0x50085,0x13, + 0x27c4,0x27c2,0x9512,0x50041,0x14,0x7166,0x7165,0x7868,0x3003e,0x7166,0x27c4,0x4003d, + 0x13,0x27c9,0x7166,0x7000c,0x13,0x284b,0x1,0x1a,0x27c9,0x1dc,0x3003e,0x7166, + 0x284b,0x4003d,0x13,0x27cf,0x7166,0x7000c,0x13,0x2850,0x1,0x28,0x27cf,0x38d, + 0x3003e,0x7166,0x2850,0x50080,0x1a,0x27d4,0x7868,0x191,0x200f9,0x27b3,0x200f8,0x27d5, + 0x200f9,0x27d6,0x200f8,0x27d6,0x4003d,0x82,0x716b,0x7165,0x300f7,0x26ee,0x0,0x400fa, + 0x27f6,0x26e8,0x26ee,0x200f8,0x26e8,0x50051,0x13,0x714a,0x6a41,0x0,0x50051,0x13, + 0x714b,0x6a41,0x1,0x50051,0x13,0x714c,0x6a41,0x2,0x50051,0x13,0x714d,0x6a41, + 0x3,0x50051,0x13,0x714e,0x6a41,0x4,0x7000c,0x13,0x2958,0x1,0x25,0x714a, + 0x714d,0x7000c,0x13,0x295d,0x1,0x28,0x714a,0x714d,0x7000c,0x13,0x2962,0x1, + 0x25,0x714b,0x714e,0x7000c,0x13,0x2967,0x1,0x28,0x714b,0x714e,0x7000c,0x13, + 0x296c,0x1,0x25,0x2958,0x714c,0x7000c,0x13,0x2971,0x1,0x28,0x2958,0x714c, + 0x7000c,0x13,0x2976,0x1,0x25,0x2962,0x295d,0x7000c,0x13,0x297b,0x1,0x28, + 0x2962,0x295d,0x7000c,0x13,0x2980,0x1,0x25,0x296c,0x2976,0x7000c,0x13,0x2985, + 0x1,0x28,0x296c,0x2976,0x7000c,0x13,0x298a,0x1,0x25,0x2971,0x2967,0x7000c, + 0x13,0x298f,0x1,0x28,0x2971,0x2967,0x7000c,0x13,0x2994,0x1,0x25,0x2985, + 0x298a,0x7000c,0x13,0x2999,0x1,0x28,0x2985,0x298a,0x7000c,0x13,0x299e,0x1, + 0x25,0x297b,0x298f,0x7000c,0x13,0x29a3,0x1,0x28,0x297b,0x298f,0x7000c,0x13, + 0x29a8,0x1,0x25,0x2999,0x299e,0x7000c,0x13,0x29ad,0x1,0x28,0x2999,0x299e, + 0x80050,0x82,0x7154,0x2980,0x2994,0x29a8,0x29ad,0x29a3,0x3003e,0x6a4f,0x7154,0x50051, + 0x13,0x715a,0x716b,0x0,0x50051,0x13,0x715b,0x716b,0x1,0x50051,0x13,0x715c, + 0x716b,0x2,0x50051,0x13,0x715d,0x716b,0x3,0x50051,0x13,0x715e,0x716b,0x4, + 0x7000c,0x13,0x2a55,0x1,0x25,0x715a,0x715d,0x7000c,0x13,0x2a5a,0x1,0x28, + 0x715a,0x715d,0x7000c,0x13,0x2a5f,0x1,0x25,0x715b,0x715e,0x7000c,0x13,0x2a64, + 0x1,0x28,0x715b,0x715e,0x7000c,0x13,0x2a69,0x1,0x25,0x2a55,0x715c,0x7000c, + 0x13,0x2a6e,0x1,0x28,0x2a55,0x715c,0x7000c,0x13,0x2a73,0x1,0x25,0x2a5f, + 0x2a5a,0x7000c,0x13,0x2a78,0x1,0x28,0x2a5f,0x2a5a,0x7000c,0x13,0x2a7d,0x1, + 0x25,0x2a69,0x2a73,0x7000c,0x13,0x2a82,0x1,0x28,0x2a69,0x2a73,0x7000c,0x13, + 0x2a87,0x1,0x25,0x2a6e,0x2a64,0x7000c,0x13,0x2a8c,0x1,0x28,0x2a6e,0x2a64, + 0x7000c,0x13,0x2a91,0x1,0x25,0x2a82,0x2a87,0x7000c,0x13,0x2a96,0x1,0x28, + 0x2a82,0x2a87,0x7000c,0x13,0x2a9b,0x1,0x25,0x2a78,0x2a8c,0x7000c,0x13,0x2aa0, + 0x1,0x28,0x2a78,0x2a8c,0x7000c,0x13,0x2aa5,0x1,0x25,0x2a96,0x2a9b,0x7000c, + 0x13,0x2aaa,0x1,0x28,0x2a96,0x2a9b,0x80050,0x82,0x7164,0x2a7d,0x2a91,0x2aa5, + 0x2aaa,0x2aa0,0x3003e,0x6a59,0x7164,0x50041,0x14,0x6a54,0x6a4f,0x2cd,0x4003d,0x13, + 0x2864,0x6a54,0x50041,0x14,0x6a5e,0x6a59,0x2cd,0x4003d,0x13,0x2866,0x6a5e,0x7000c, + 0x13,0x2aaf,0x1,0x25,0x2864,0x2866,0x500ba,0x6e,0x2869,0x2aaf,0x372,0x300f7, + 0x28ab,0x0,0x400fa,0x2869,0x286a,0x28ab,0x200f8,0x286a,0x200f9,0x286b,0x200f8,0x286b, + 0x700f5,0x1a,0x8eba,0x14c,0x286a,0x94e0,0x28a7,0x700f5,0x1a,0x8eb9,0x14c,0x286a, + 0x94df,0x28a7,0x700f5,0x13,0x788b,0x35e,0x286a,0x9013,0x28a7,0x700f5,0x1a,0x788a, + 0x14c,0x286a,0x28a9,0x28a7,0x500b1,0x6e,0x286e,0x788a,0x37d,0x500b8,0x6e,0x2870, + 0x788b,0x380,0x500a7,0x6e,0x2871,0x286e,0x2870,0x400f6,0x28aa,0x28a7,0x0,0x400fa, + 0x2871,0x2872,0x28aa,0x200f8,0x2872,0x50041,0x14,0x6a55,0x6a4f,0x8eb9,0x4003d,0x13, + 0x2875,0x6a55,0x50041,0x14,0x6a5f,0x6a59,0x8eba,0x4003d,0x13,0x2878,0x6a5f,0x50083, + 0x13,0x2879,0x2875,0x2878,0x6000c,0x13,0x287b,0x1,0x4,0x2879,0x500ba,0x6e, + 0x287c,0x287b,0x38d,0x300f7,0x28a6,0x0,0x400fa,0x287c,0x287d,0x28a5,0x200f8,0x28a5, + 0x200f9,0x28a6,0x200f8,0x287d,0x6000c,0x13,0x287f,0x1,0x6,0x2879,0x4003d,0x13, + 0x2882,0x6a55,0x4003d,0x13,0x2885,0x6a5f,0x7000c,0x13,0x2ac6,0x1,0x28,0x2882, + 0x2885,0x500b7,0x6e,0x2aba,0x2ac6,0x1d8,0x300f7,0x2ac0,0x0,0x400fa,0x2aba,0x2abb, + 0x2abf,0x200f8,0x2abf,0x200f9,0x2ac0,0x200f8,0x2abb,0x7000c,0x13,0x2acb,0x1,0x25, + 0x2882,0x2885,0x50088,0x13,0x2abe,0x2acb,0x2ac6,0x200f9,0x2ac0,0x200f8,0x2ac0,0x700f5, + 0x13,0x8ebb,0x2abe,0x2abb,0x1d8,0x2abf,0x50083,0x13,0x2887,0x1dc,0x8ebb,0x50085, + 0x13,0x2888,0x287f,0x2887,0x6000c,0x13,0x288a,0x1,0x4,0x2888,0x6000c,0x13, + 0x288c,0x1,0x4,0x788b,0x500b8,0x6e,0x288d,0x288a,0x288c,0x600a9,0x13,0x2890, + 0x288d,0x2888,0x788b,0x4003d,0x13,0x2893,0x6a55,0x4003d,0x13,0x2896,0x6a5f,0x500b8, + 0x6e,0x2897,0x2893,0x2896,0x600a9,0x1a,0x2898,0x2897,0x191,0x14c,0x50080,0x1a, + 0x289a,0x8eb9,0x2898,0x50041,0x14,0x6a58,0x6a4f,0x289a,0x4003d,0x13,0x289d,0x6a58, + 0x4003d,0x13,0x28a0,0x6a5f,0x500be,0x6e,0x28a1,0x289d,0x28a0,0x600a9,0x1a,0x28a2, + 0x28a1,0x191,0x14c,0x50080,0x1a,0x28a4,0x8eba,0x28a2,0x200f9,0x28a6,0x200f8,0x28a6, + 0x700f5,0x1a,0x94e0,0x28a4,0x2ac0,0x8eba,0x28a5,0x700f5,0x1a,0x94df,0x289a,0x2ac0, + 0x8eb9,0x28a5,0x700f5,0x13,0x9013,0x2890,0x2ac0,0x380,0x28a5,0x200f9,0x28a7,0x200f8, + 0x28a7,0x50080,0x1a,0x28a9,0x788a,0x191,0x200f9,0x286b,0x200f8,0x28aa,0x200f9,0x28ab, + 0x200f8,0x28ab,0x700f5,0x13,0x788c,0x35e,0x26e8,0x788b,0x28aa,0x500b8,0x6e,0x28ae, + 0x788c,0x35e,0x600a9,0x13,0x28af,0x28ae,0x1dc,0x1d8,0x50085,0x13,0x28b0,0x788c, + 0x28af,0x200f9,0x26ee,0x200f8,0x26ee,0x700f5,0x13,0x788d,0x1d8,0x27d6,0x28b0,0x28ab, + 0x60052,0x9f,0x9610,0x788d,0x48e,0x0,0x500b7,0x6e,0x268b,0x788d,0x1d8,0x300f7, + 0x2690,0x0,0x400fa,0x268b,0x268c,0x268f,0x200f8,0x268f,0x200f9,0x2690,0x200f8,0x268c, + 0x6000c,0x13,0x268e,0x1,0x6,0x788d,0x200f9,0x2690,0x200f8,0x2690,0x700f5,0x13, + 0x7894,0x268e,0x268c,0x1d8,0x268f,0x60052,0x9f,0x9612,0x7894,0x9610,0x1,0x60052, + 0x9f,0x9614,0x1dc,0x9612,0x2,0x4007c,0x32,0x1d97,0x1d72,0x4006f,0x38,0x1d98, + 0x1d97,0x4006e,0x32,0x2adc,0x1d98,0x50051,0x1a,0x2b0f,0x2adc,0x0,0x7000c,0x1a, + 0x2b20,0x1,0x27,0x2b0f,0xbc1,0x7000c,0x1a,0x2b25,0x1,0x2a,0x14c,0x2b20, + 0x50051,0x1a,0x2b17,0x2adc,0x1,0x7000c,0x1a,0x2b2a,0x1,0x27,0x2b17,0xbc9, + 0x7000c,0x1a,0x2b2f,0x1,0x2a,0x14c,0x2b2a,0x50050,0x32,0x978a,0x2b25,0x2b2f, + 0x4003d,0x1b9,0x2b32,0x1ca,0x7005f,0x9f,0x2b34,0x2b32,0x978a,0x2,0x14c,0x7004f, + 0x38,0x2b35,0x2b34,0x2b34,0x0,0x1,0x4006f,0x38,0x2ae2,0x978a,0x50081,0x38, + 0x2ae4,0x2ae2,0x94fd,0x50088,0x38,0x2ae7,0x2ae4,0xb9a,0x3003e,0x2b5a,0x3df,0x50081, + 0x38,0x2b69,0x2ae7,0xc1c,0x50085,0x38,0x2b6d,0x2b69,0xb9a,0x6000c,0x38,0x2b6e, + 0x1,0x8,0x2b6d,0x4006e,0x32,0x2b6f,0x2b6e,0x200f9,0x2b70,0x200f8,0x2b70,0x700f5, + 0x1a,0x78bd,0x14c,0x2690,0x2b8f,0x2b74,0x500b1,0x6e,0x2b73,0x78bd,0x37d,0x400f6, + 0x2b90,0x2b74,0x0,0x400fa,0x2b73,0x2b74,0x2b90,0x200f8,0x2b74,0x50041,0x49,0x2b78, + 0x2b5a,0x78bd,0x4003d,0x32,0x2b79,0x2b78,0x50080,0x32,0x2baf,0x2b6f,0x2b79,0x50051, + 0x1a,0x2bb4,0x2baf,0x0,0x7000c,0x1a,0x2bc5,0x1,0x27,0x2bb4,0xbc1,0x7000c, + 0x1a,0x2bca,0x1,0x2a,0x14c,0x2bc5,0x50051,0x1a,0x2bbc,0x2baf,0x1,0x7000c, + 0x1a,0x2bcf,0x1,0x27,0x2bbc,0xbc9,0x7000c,0x1a,0x2bd4,0x1,0x2a,0x14c, + 0x2bcf,0x50050,0x32,0x97a4,0x2bca,0x2bd4,0x4003d,0x1b9,0x2bd7,0x1bb,0x7005f,0x9f, + 0x2bd9,0x2bd7,0x97a4,0x2,0x14c,0x50051,0x13,0x2bda,0x2bd9,0x0,0x4003d,0x1b9, + 0x2bde,0x1d2,0x7005f,0x9f,0x2bdf,0x2bde,0x1d4,0x2,0x14c,0x50051,0x13,0x2be0, + 0x2bdf,0x0,0x500b4,0x6e,0x2be2,0x2be0,0x1d8,0x600a9,0x13,0x9513,0x2be2,0x1dc, + 0x2be0,0x50085,0x13,0x2b7f,0x2bda,0x9513,0x50041,0x14,0x698f,0x698e,0x78bd,0x3003e, + 0x698f,0x2b7f,0x4003d,0x13,0x2b84,0x698f,0x7000c,0x13,0x2bea,0x1,0x1a,0x2b84, + 0x1dc,0x3003e,0x698f,0x2bea,0x4003d,0x13,0x2b8a,0x698f,0x7000c,0x13,0x2bef,0x1, + 0x28,0x2b8a,0x38d,0x3003e,0x698f,0x2bef,0x50080,0x1a,0x2b8f,0x78bd,0x191,0x200f9, + 0x2b70,0x200f8,0x2b90,0x4003d,0x82,0x6994,0x698e,0x3003e,0x2bf9,0x3df,0x50081,0x38, + 0x2c07,0x2ae7,0xcba,0x50081,0x38,0x2c0a,0x2c07,0x2b35,0x50051,0x13,0x2c47,0x2c0a, + 0x0,0x500be,0x6e,0x2c48,0x2c47,0x1d8,0x300f7,0x2c4d,0x0,0x400fa,0x2c48,0x2c49, + 0x2c4d,0x200f8,0x2c49,0x500bc,0x6e,0x2c4c,0x2c47,0x1dc,0x200f9,0x2c4d,0x200f8,0x2c4d, + 0x700f5,0x6e,0x2c4e,0x2c48,0x2b90,0x2c4c,0x2c49,0x300f7,0x2c59,0x0,0x400fa,0x2c4e, + 0x2c4f,0x2c59,0x200f8,0x2c4f,0x50051,0x13,0x2c51,0x2c0a,0x1,0x500be,0x6e,0x2c52, + 0x2c51,0x1d8,0x300f7,0x2c57,0x0,0x400fa,0x2c52,0x2c53,0x2c57,0x200f8,0x2c53,0x500bc, + 0x6e,0x2c56,0x2c51,0x1dc,0x200f9,0x2c57,0x200f8,0x2c57,0x700f5,0x6e,0x2c58,0x2c52, + 0x2c4f,0x2c56,0x2c53,0x200f9,0x2c59,0x200f8,0x2c59,0x700f5,0x6e,0x2c5a,0x2c4e,0x2c4d, + 0x2c58,0x2c57,0x300f7,0x2c3a,0x0,0x400fa,0x2c5a,0x2c10,0x2c3a,0x200f8,0x2c10,0x50085, + 0x38,0x2c14,0x2c0a,0xcb9,0x6000c,0x38,0x2c15,0x1,0x8,0x2c14,0x4006e,0x32, + 0x2c16,0x2c15,0x200f9,0x2c17,0x200f8,0x2c17,0x700f5,0x1a,0x78c3,0x14c,0x2c10,0x2c38, + 0x2c1b,0x500b1,0x6e,0x2c1a,0x78c3,0x37d,0x400f6,0x2c39,0x2c1b,0x0,0x400fa,0x2c1a, + 0x2c1b,0x2c39,0x200f8,0x2c1b,0x50041,0x49,0x2c1f,0x2bf9,0x78c3,0x4003d,0x32,0x2c20, + 0x2c1f,0x50080,0x32,0x2c70,0x2c16,0x2c20,0x50051,0x1a,0x2c72,0xcf7,0x0,0x50082, + 0x1a,0x2c73,0x2c72,0x191,0x50051,0x1a,0x2c75,0x2c70,0x0,0x7000c,0x1a,0x2c86, + 0x1,0x27,0x2c75,0x2c73,0x7000c,0x1a,0x2c8b,0x1,0x2a,0x14c,0x2c86,0x50051, + 0x1a,0x2c7a,0xcf7,0x1,0x50082,0x1a,0x2c7b,0x2c7a,0x191,0x50051,0x1a,0x2c7d, + 0x2c70,0x1,0x7000c,0x1a,0x2c90,0x1,0x27,0x2c7d,0x2c7b,0x7000c,0x1a,0x2c95, + 0x1,0x2a,0x14c,0x2c90,0x50050,0x32,0x97a3,0x2c8b,0x2c95,0x4003d,0x1b9,0x2c98, + 0x1c3,0x7005f,0x9f,0x2c9a,0x2c98,0x97a3,0x2,0x14c,0x50051,0x13,0x2c9b,0x2c9a, + 0x0,0x50041,0x1a2,0x2c9e,0x18b,0x20b,0x4003d,0x13,0x2c9f,0x2c9e,0x50085,0x13, + 0x2c26,0x2c9b,0x2c9f,0x4003d,0x1b9,0x2ca3,0x1d2,0x7005f,0x9f,0x2ca4,0x2ca3,0x1d4, + 0x2,0x14c,0x50051,0x13,0x2ca5,0x2ca4,0x0,0x500b4,0x6e,0x2ca7,0x2ca5,0x1d8, + 0x600a9,0x13,0x9514,0x2ca7,0x1dc,0x2ca5,0x50085,0x13,0x2c28,0x2c26,0x9514,0x50041, + 0x14,0x7116,0x7115,0x78c3,0x3003e,0x7116,0x2c28,0x4003d,0x13,0x2c2d,0x7116,0x7000c, + 0x13,0x2caf,0x1,0x1a,0x2c2d,0x1dc,0x3003e,0x7116,0x2caf,0x4003d,0x13,0x2c33, + 0x7116,0x7000c,0x13,0x2cb4,0x1,0x28,0x2c33,0x38d,0x3003e,0x7116,0x2cb4,0x50080, + 0x1a,0x2c38,0x78c3,0x191,0x200f9,0x2c17,0x200f8,0x2c39,0x200f9,0x2c3a,0x200f8,0x2c3a, + 0x4003d,0x82,0x711b,0x7115,0x300f7,0x2b52,0x0,0x400fa,0x2c5a,0x2b4c,0x2b52,0x200f8, + 0x2b4c,0x50051,0x13,0x70fa,0x6994,0x0,0x50051,0x13,0x70fb,0x6994,0x1,0x50051, + 0x13,0x70fc,0x6994,0x2,0x50051,0x13,0x70fd,0x6994,0x3,0x50051,0x13,0x70fe, + 0x6994,0x4,0x7000c,0x13,0x2dbc,0x1,0x25,0x70fa,0x70fd,0x7000c,0x13,0x2dc1, + 0x1,0x28,0x70fa,0x70fd,0x7000c,0x13,0x2dc6,0x1,0x25,0x70fb,0x70fe,0x7000c, + 0x13,0x2dcb,0x1,0x28,0x70fb,0x70fe,0x7000c,0x13,0x2dd0,0x1,0x25,0x2dbc, + 0x70fc,0x7000c,0x13,0x2dd5,0x1,0x28,0x2dbc,0x70fc,0x7000c,0x13,0x2dda,0x1, + 0x25,0x2dc6,0x2dc1,0x7000c,0x13,0x2ddf,0x1,0x28,0x2dc6,0x2dc1,0x7000c,0x13, + 0x2de4,0x1,0x25,0x2dd0,0x2dda,0x7000c,0x13,0x2de9,0x1,0x28,0x2dd0,0x2dda, + 0x7000c,0x13,0x2dee,0x1,0x25,0x2dd5,0x2dcb,0x7000c,0x13,0x2df3,0x1,0x28, + 0x2dd5,0x2dcb,0x7000c,0x13,0x2df8,0x1,0x25,0x2de9,0x2dee,0x7000c,0x13,0x2dfd, + 0x1,0x28,0x2de9,0x2dee,0x7000c,0x13,0x2e02,0x1,0x25,0x2ddf,0x2df3,0x7000c, + 0x13,0x2e07,0x1,0x28,0x2ddf,0x2df3,0x7000c,0x13,0x2e0c,0x1,0x25,0x2dfd, + 0x2e02,0x7000c,0x13,0x2e11,0x1,0x28,0x2dfd,0x2e02,0x80050,0x82,0x7104,0x2de4, + 0x2df8,0x2e0c,0x2e11,0x2e07,0x3003e,0x69a2,0x7104,0x50051,0x13,0x710a,0x711b,0x0, + 0x50051,0x13,0x710b,0x711b,0x1,0x50051,0x13,0x710c,0x711b,0x2,0x50051,0x13, + 0x710d,0x711b,0x3,0x50051,0x13,0x710e,0x711b,0x4,0x7000c,0x13,0x2eb9,0x1, + 0x25,0x710a,0x710d,0x7000c,0x13,0x2ebe,0x1,0x28,0x710a,0x710d,0x7000c,0x13, + 0x2ec3,0x1,0x25,0x710b,0x710e,0x7000c,0x13,0x2ec8,0x1,0x28,0x710b,0x710e, + 0x7000c,0x13,0x2ecd,0x1,0x25,0x2eb9,0x710c,0x7000c,0x13,0x2ed2,0x1,0x28, + 0x2eb9,0x710c,0x7000c,0x13,0x2ed7,0x1,0x25,0x2ec3,0x2ebe,0x7000c,0x13,0x2edc, + 0x1,0x28,0x2ec3,0x2ebe,0x7000c,0x13,0x2ee1,0x1,0x25,0x2ecd,0x2ed7,0x7000c, + 0x13,0x2ee6,0x1,0x28,0x2ecd,0x2ed7,0x7000c,0x13,0x2eeb,0x1,0x25,0x2ed2, + 0x2ec8,0x7000c,0x13,0x2ef0,0x1,0x28,0x2ed2,0x2ec8,0x7000c,0x13,0x2ef5,0x1, + 0x25,0x2ee6,0x2eeb,0x7000c,0x13,0x2efa,0x1,0x28,0x2ee6,0x2eeb,0x7000c,0x13, + 0x2eff,0x1,0x25,0x2edc,0x2ef0,0x7000c,0x13,0x2f04,0x1,0x28,0x2edc,0x2ef0, + 0x7000c,0x13,0x2f09,0x1,0x25,0x2efa,0x2eff,0x7000c,0x13,0x2f0e,0x1,0x28, + 0x2efa,0x2eff,0x80050,0x82,0x7114,0x2ee1,0x2ef5,0x2f09,0x2f0e,0x2f04,0x3003e,0x69ac, + 0x7114,0x50041,0x14,0x69a7,0x69a2,0x2cd,0x4003d,0x13,0x2cc8,0x69a7,0x50041,0x14, + 0x69b1,0x69ac,0x2cd,0x4003d,0x13,0x2cca,0x69b1,0x7000c,0x13,0x2f13,0x1,0x25, + 0x2cc8,0x2cca,0x500ba,0x6e,0x2ccd,0x2f13,0x372,0x300f7,0x2d0f,0x0,0x400fa,0x2ccd, + 0x2cce,0x2d0f,0x200f8,0x2cce,0x200f9,0x2ccf,0x200f8,0x2ccf,0x700f5,0x1a,0x8eac,0x14c, + 0x2cce,0x94dc,0x2d0b,0x700f5,0x1a,0x8eab,0x14c,0x2cce,0x94db,0x2d0b,0x700f5,0x13, + 0x78e6,0x35e,0x2cce,0x9030,0x2d0b,0x700f5,0x1a,0x78e5,0x14c,0x2cce,0x2d0d,0x2d0b, + 0x500b1,0x6e,0x2cd2,0x78e5,0x37d,0x500b8,0x6e,0x2cd4,0x78e6,0x380,0x500a7,0x6e, + 0x2cd5,0x2cd2,0x2cd4,0x400f6,0x2d0e,0x2d0b,0x0,0x400fa,0x2cd5,0x2cd6,0x2d0e,0x200f8, + 0x2cd6,0x50041,0x14,0x69a8,0x69a2,0x8eab,0x4003d,0x13,0x2cd9,0x69a8,0x50041,0x14, + 0x69b2,0x69ac,0x8eac,0x4003d,0x13,0x2cdc,0x69b2,0x50083,0x13,0x2cdd,0x2cd9,0x2cdc, + 0x6000c,0x13,0x2cdf,0x1,0x4,0x2cdd,0x500ba,0x6e,0x2ce0,0x2cdf,0x38d,0x300f7, + 0x2d0a,0x0,0x400fa,0x2ce0,0x2ce1,0x2d09,0x200f8,0x2d09,0x200f9,0x2d0a,0x200f8,0x2ce1, + 0x6000c,0x13,0x2ce3,0x1,0x6,0x2cdd,0x4003d,0x13,0x2ce6,0x69a8,0x4003d,0x13, + 0x2ce9,0x69b2,0x7000c,0x13,0x2f2a,0x1,0x28,0x2ce6,0x2ce9,0x500b7,0x6e,0x2f1e, + 0x2f2a,0x1d8,0x300f7,0x2f24,0x0,0x400fa,0x2f1e,0x2f1f,0x2f23,0x200f8,0x2f23,0x200f9, + 0x2f24,0x200f8,0x2f1f,0x7000c,0x13,0x2f2f,0x1,0x25,0x2ce6,0x2ce9,0x50088,0x13, + 0x2f22,0x2f2f,0x2f2a,0x200f9,0x2f24,0x200f8,0x2f24,0x700f5,0x13,0x8ead,0x2f22,0x2f1f, + 0x1d8,0x2f23,0x50083,0x13,0x2ceb,0x1dc,0x8ead,0x50085,0x13,0x2cec,0x2ce3,0x2ceb, + 0x6000c,0x13,0x2cee,0x1,0x4,0x2cec,0x6000c,0x13,0x2cf0,0x1,0x4,0x78e6, + 0x500b8,0x6e,0x2cf1,0x2cee,0x2cf0,0x600a9,0x13,0x2cf4,0x2cf1,0x2cec,0x78e6,0x4003d, + 0x13,0x2cf7,0x69a8,0x4003d,0x13,0x2cfa,0x69b2,0x500b8,0x6e,0x2cfb,0x2cf7,0x2cfa, + 0x600a9,0x1a,0x2cfc,0x2cfb,0x191,0x14c,0x50080,0x1a,0x2cfe,0x8eab,0x2cfc,0x50041, + 0x14,0x69ab,0x69a2,0x2cfe,0x4003d,0x13,0x2d01,0x69ab,0x4003d,0x13,0x2d04,0x69b2, + 0x500be,0x6e,0x2d05,0x2d01,0x2d04,0x600a9,0x1a,0x2d06,0x2d05,0x191,0x14c,0x50080, + 0x1a,0x2d08,0x8eac,0x2d06,0x200f9,0x2d0a,0x200f8,0x2d0a,0x700f5,0x1a,0x94dc,0x2d08, + 0x2f24,0x8eac,0x2d09,0x700f5,0x1a,0x94db,0x2cfe,0x2f24,0x8eab,0x2d09,0x700f5,0x13, + 0x9030,0x2cf4,0x2f24,0x380,0x2d09,0x200f9,0x2d0b,0x200f8,0x2d0b,0x50080,0x1a,0x2d0d, + 0x78e5,0x191,0x200f9,0x2ccf,0x200f8,0x2d0e,0x200f9,0x2d0f,0x200f8,0x2d0f,0x700f5,0x13, + 0x78e7,0x35e,0x2b4c,0x78e6,0x2d0e,0x500b8,0x6e,0x2d12,0x78e7,0x35e,0x600a9,0x13, + 0x2d13,0x2d12,0x1dc,0x1d8,0x50085,0x13,0x2d14,0x78e7,0x2d13,0x200f9,0x2b52,0x200f8, + 0x2b52,0x700f5,0x13,0x78e8,0x1d8,0x2c3a,0x2d14,0x2d0f,0x60052,0x9f,0x9632,0x78e8, + 0x48e,0x0,0x500b7,0x6e,0x2aef,0x78e8,0x1d8,0x300f7,0x2af4,0x0,0x400fa,0x2aef, + 0x2af0,0x2af3,0x200f8,0x2af3,0x200f9,0x2af4,0x200f8,0x2af0,0x6000c,0x13,0x2af2,0x1, + 0x6,0x78e8,0x200f9,0x2af4,0x200f8,0x2af4,0x700f5,0x13,0x78ef,0x2af2,0x2af0,0x1d8, + 0x2af3,0x60052,0x9f,0x9634,0x78ef,0x9632,0x1,0x60052,0x9f,0x9636,0x1dc,0x9634, + 0x2,0x50081,0x9f,0x2f34,0x95d0,0x95f2,0x50081,0x9f,0x2f36,0x2f34,0x9614,0x50081, + 0x9f,0x2f38,0x2f36,0x9636,0x5008e,0x9f,0x2f39,0x2f38,0x4af,0x4003d,0x1e4,0x2f4b, + 0x1e6,0x50051,0x13,0x2f4e,0x2f39,0x0,0x50051,0x13,0x2f4f,0x2f39,0x1,0x70050, + 0x9f,0x2f50,0x2f4e,0x2f4f,0x1d8,0x1d8,0x40063,0x2f4b,0xa75,0x2f50,0x50080,0x6, + 0xa89,0xa46,0x59f,0x4007c,0x1a,0xa8a,0xa89,0x50050,0x32,0xa8b,0xa44,0xa8a, + 0x50080,0x32,0xa8c,0xa41,0xa8b,0x50080,0x6,0xa94,0x98a,0x4bf,0x4007c,0x1a, + 0xa95,0xa94,0x50050,0x32,0xa96,0xa4f,0xa95,0x50080,0x32,0xa97,0xa4d,0xa96, + 0x4007c,0x2d,0xa99,0xa8c,0x50080,0x2d,0x2f8e,0xa99,0x542,0x50080,0x2d,0x2f90, + 0xa99,0x545,0x50080,0x2d,0x2f92,0xa99,0x548,0x4006f,0x38,0x2fa9,0xa8c,0x4006e, + 0x32,0x2fd0,0x2fa9,0x50051,0x1a,0x3003,0x2fd0,0x0,0x7000c,0x1a,0x3014,0x1, + 0x27,0x3003,0xbc1,0x7000c,0x1a,0x3019,0x1,0x2a,0x14c,0x3014,0x50051,0x1a, + 0x300b,0x2fd0,0x1,0x7000c,0x1a,0x301e,0x1,0x27,0x300b,0xbc9,0x7000c,0x1a, + 0x3023,0x1,0x2a,0x14c,0x301e,0x50050,0x32,0x978b,0x3019,0x3023,0x4003d,0x1b9, + 0x3026,0x1ca,0x7005f,0x9f,0x3028,0x3026,0x978b,0x2,0x14c,0x7004f,0x38,0x3029, + 0x3028,0x3028,0x0,0x1,0x4006f,0x38,0x2fd6,0x978b,0x50081,0x38,0x2fd8,0x2fd6, + 0x94fd,0x50088,0x38,0x2fdb,0x2fd8,0xb9a,0x3003e,0x304e,0x3df,0x50081,0x38,0x305d, + 0x2fdb,0xc1c,0x50085,0x38,0x3061,0x305d,0xb9a,0x6000c,0x38,0x3062,0x1,0x8, + 0x3061,0x4006e,0x32,0x3063,0x3062,0x200f9,0x3064,0x200f8,0x3064,0x700f5,0x1a,0x7a1f, + 0x14c,0x2af4,0x3083,0x3068,0x500b1,0x6e,0x3067,0x7a1f,0x37d,0x400f6,0x3084,0x3068, + 0x0,0x400fa,0x3067,0x3068,0x3084,0x200f8,0x3068,0x50041,0x49,0x306c,0x304e,0x7a1f, + 0x4003d,0x32,0x306d,0x306c,0x50080,0x32,0x30a3,0x3063,0x306d,0x50051,0x1a,0x30a8, + 0x30a3,0x0,0x7000c,0x1a,0x30b9,0x1,0x27,0x30a8,0xbc1,0x7000c,0x1a,0x30be, + 0x1,0x2a,0x14c,0x30b9,0x50051,0x1a,0x30b0,0x30a3,0x1,0x7000c,0x1a,0x30c3, + 0x1,0x27,0x30b0,0xbc9,0x7000c,0x1a,0x30c8,0x1,0x2a,0x14c,0x30c3,0x50050, + 0x32,0x97a2,0x30be,0x30c8,0x4003d,0x1b9,0x30cb,0x1bb,0x7005f,0x9f,0x30cd,0x30cb, + 0x97a2,0x2,0x14c,0x50051,0x13,0x30ce,0x30cd,0x0,0x4003d,0x1b9,0x30d2,0x1d2, + 0x7005f,0x9f,0x30d3,0x30d2,0x1d4,0x2,0x14c,0x50051,0x13,0x30d4,0x30d3,0x0, + 0x500b4,0x6e,0x30d6,0x30d4,0x1d8,0x600a9,0x13,0x9515,0x30d6,0x1dc,0x30d4,0x50085, + 0x13,0x3073,0x30ce,0x9515,0x50041,0x14,0x68e2,0x68e1,0x7a1f,0x3003e,0x68e2,0x3073, + 0x4003d,0x13,0x3078,0x68e2,0x7000c,0x13,0x30de,0x1,0x1a,0x3078,0x1dc,0x3003e, + 0x68e2,0x30de,0x4003d,0x13,0x307e,0x68e2,0x7000c,0x13,0x30e3,0x1,0x28,0x307e, + 0x38d,0x3003e,0x68e2,0x30e3,0x50080,0x1a,0x3083,0x7a1f,0x191,0x200f9,0x3064,0x200f8, + 0x3084,0x4003d,0x82,0x68e7,0x68e1,0x3003e,0x30ed,0x3df,0x50081,0x38,0x30fb,0x2fdb, + 0xcba,0x50081,0x38,0x30fe,0x30fb,0x3029,0x50051,0x13,0x313b,0x30fe,0x0,0x500be, + 0x6e,0x313c,0x313b,0x1d8,0x300f7,0x3141,0x0,0x400fa,0x313c,0x313d,0x3141,0x200f8, + 0x313d,0x500bc,0x6e,0x3140,0x313b,0x1dc,0x200f9,0x3141,0x200f8,0x3141,0x700f5,0x6e, + 0x3142,0x313c,0x3084,0x3140,0x313d,0x300f7,0x314d,0x0,0x400fa,0x3142,0x3143,0x314d, + 0x200f8,0x3143,0x50051,0x13,0x3145,0x30fe,0x1,0x500be,0x6e,0x3146,0x3145,0x1d8, + 0x300f7,0x314b,0x0,0x400fa,0x3146,0x3147,0x314b,0x200f8,0x3147,0x500bc,0x6e,0x314a, + 0x3145,0x1dc,0x200f9,0x314b,0x200f8,0x314b,0x700f5,0x6e,0x314c,0x3146,0x3143,0x314a, + 0x3147,0x200f9,0x314d,0x200f8,0x314d,0x700f5,0x6e,0x314e,0x3142,0x3141,0x314c,0x314b, + 0x300f7,0x312e,0x0,0x400fa,0x314e,0x3104,0x312e,0x200f8,0x3104,0x50085,0x38,0x3108, + 0x30fe,0xcb9,0x6000c,0x38,0x3109,0x1,0x8,0x3108,0x4006e,0x32,0x310a,0x3109, + 0x200f9,0x310b,0x200f8,0x310b,0x700f5,0x1a,0x7a25,0x14c,0x3104,0x312c,0x310f,0x500b1, + 0x6e,0x310e,0x7a25,0x37d,0x400f6,0x312d,0x310f,0x0,0x400fa,0x310e,0x310f,0x312d, + 0x200f8,0x310f,0x50041,0x49,0x3113,0x30ed,0x7a25,0x4003d,0x32,0x3114,0x3113,0x50080, + 0x32,0x3164,0x310a,0x3114,0x50051,0x1a,0x3166,0xcf7,0x0,0x50082,0x1a,0x3167, + 0x3166,0x191,0x50051,0x1a,0x3169,0x3164,0x0,0x7000c,0x1a,0x317a,0x1,0x27, + 0x3169,0x3167,0x7000c,0x1a,0x317f,0x1,0x2a,0x14c,0x317a,0x50051,0x1a,0x316e, + 0xcf7,0x1,0x50082,0x1a,0x316f,0x316e,0x191,0x50051,0x1a,0x3171,0x3164,0x1, + 0x7000c,0x1a,0x3184,0x1,0x27,0x3171,0x316f,0x7000c,0x1a,0x3189,0x1,0x2a, + 0x14c,0x3184,0x50050,0x32,0x97a1,0x317f,0x3189,0x4003d,0x1b9,0x318c,0x1c3,0x7005f, + 0x9f,0x318e,0x318c,0x97a1,0x2,0x14c,0x50051,0x13,0x318f,0x318e,0x0,0x50041, + 0x1a2,0x3192,0x18b,0x20b,0x4003d,0x13,0x3193,0x3192,0x50085,0x13,0x311a,0x318f, + 0x3193,0x4003d,0x1b9,0x3197,0x1d2,0x7005f,0x9f,0x3198,0x3197,0x1d4,0x2,0x14c, + 0x50051,0x13,0x3199,0x3198,0x0,0x500b4,0x6e,0x319b,0x3199,0x1d8,0x600a9,0x13, + 0x9516,0x319b,0x1dc,0x3199,0x50085,0x13,0x311c,0x311a,0x9516,0x50041,0x14,0x70c6, + 0x70c5,0x7a25,0x3003e,0x70c6,0x311c,0x4003d,0x13,0x3121,0x70c6,0x7000c,0x13,0x31a3, + 0x1,0x1a,0x3121,0x1dc,0x3003e,0x70c6,0x31a3,0x4003d,0x13,0x3127,0x70c6,0x7000c, + 0x13,0x31a8,0x1,0x28,0x3127,0x38d,0x3003e,0x70c6,0x31a8,0x50080,0x1a,0x312c, + 0x7a25,0x191,0x200f9,0x310b,0x200f8,0x312d,0x200f9,0x312e,0x200f8,0x312e,0x4003d,0x82, + 0x70cb,0x70c5,0x300f7,0x3046,0x0,0x400fa,0x314e,0x3040,0x3046,0x200f8,0x3040,0x50051, + 0x13,0x70aa,0x68e7,0x0,0x50051,0x13,0x70ab,0x68e7,0x1,0x50051,0x13,0x70ac, + 0x68e7,0x2,0x50051,0x13,0x70ad,0x68e7,0x3,0x50051,0x13,0x70ae,0x68e7,0x4, + 0x7000c,0x13,0x32b0,0x1,0x25,0x70aa,0x70ad,0x7000c,0x13,0x32b5,0x1,0x28, + 0x70aa,0x70ad,0x7000c,0x13,0x32ba,0x1,0x25,0x70ab,0x70ae,0x7000c,0x13,0x32bf, + 0x1,0x28,0x70ab,0x70ae,0x7000c,0x13,0x32c4,0x1,0x25,0x32b0,0x70ac,0x7000c, + 0x13,0x32c9,0x1,0x28,0x32b0,0x70ac,0x7000c,0x13,0x32ce,0x1,0x25,0x32ba, + 0x32b5,0x7000c,0x13,0x32d3,0x1,0x28,0x32ba,0x32b5,0x7000c,0x13,0x32d8,0x1, + 0x25,0x32c4,0x32ce,0x7000c,0x13,0x32dd,0x1,0x28,0x32c4,0x32ce,0x7000c,0x13, + 0x32e2,0x1,0x25,0x32c9,0x32bf,0x7000c,0x13,0x32e7,0x1,0x28,0x32c9,0x32bf, + 0x7000c,0x13,0x32ec,0x1,0x25,0x32dd,0x32e2,0x7000c,0x13,0x32f1,0x1,0x28, + 0x32dd,0x32e2,0x7000c,0x13,0x32f6,0x1,0x25,0x32d3,0x32e7,0x7000c,0x13,0x32fb, + 0x1,0x28,0x32d3,0x32e7,0x7000c,0x13,0x3300,0x1,0x25,0x32f1,0x32f6,0x7000c, + 0x13,0x3305,0x1,0x28,0x32f1,0x32f6,0x80050,0x82,0x70b4,0x32d8,0x32ec,0x3300, + 0x3305,0x32fb,0x3003e,0x68f5,0x70b4,0x50051,0x13,0x70ba,0x70cb,0x0,0x50051,0x13, + 0x70bb,0x70cb,0x1,0x50051,0x13,0x70bc,0x70cb,0x2,0x50051,0x13,0x70bd,0x70cb, + 0x3,0x50051,0x13,0x70be,0x70cb,0x4,0x7000c,0x13,0x33ad,0x1,0x25,0x70ba, + 0x70bd,0x7000c,0x13,0x33b2,0x1,0x28,0x70ba,0x70bd,0x7000c,0x13,0x33b7,0x1, + 0x25,0x70bb,0x70be,0x7000c,0x13,0x33bc,0x1,0x28,0x70bb,0x70be,0x7000c,0x13, + 0x33c1,0x1,0x25,0x33ad,0x70bc,0x7000c,0x13,0x33c6,0x1,0x28,0x33ad,0x70bc, + 0x7000c,0x13,0x33cb,0x1,0x25,0x33b7,0x33b2,0x7000c,0x13,0x33d0,0x1,0x28, + 0x33b7,0x33b2,0x7000c,0x13,0x33d5,0x1,0x25,0x33c1,0x33cb,0x7000c,0x13,0x33da, + 0x1,0x28,0x33c1,0x33cb,0x7000c,0x13,0x33df,0x1,0x25,0x33c6,0x33bc,0x7000c, + 0x13,0x33e4,0x1,0x28,0x33c6,0x33bc,0x7000c,0x13,0x33e9,0x1,0x25,0x33da, + 0x33df,0x7000c,0x13,0x33ee,0x1,0x28,0x33da,0x33df,0x7000c,0x13,0x33f3,0x1, + 0x25,0x33d0,0x33e4,0x7000c,0x13,0x33f8,0x1,0x28,0x33d0,0x33e4,0x7000c,0x13, + 0x33fd,0x1,0x25,0x33ee,0x33f3,0x7000c,0x13,0x3402,0x1,0x28,0x33ee,0x33f3, + 0x80050,0x82,0x70c4,0x33d5,0x33e9,0x33fd,0x3402,0x33f8,0x3003e,0x68ff,0x70c4,0x50041, + 0x14,0x68fa,0x68f5,0x2cd,0x4003d,0x13,0x31bc,0x68fa,0x50041,0x14,0x6904,0x68ff, + 0x2cd,0x4003d,0x13,0x31be,0x6904,0x7000c,0x13,0x3407,0x1,0x25,0x31bc,0x31be, + 0x500ba,0x6e,0x31c1,0x3407,0x372,0x300f7,0x3203,0x0,0x400fa,0x31c1,0x31c2,0x3203, + 0x200f8,0x31c2,0x200f9,0x31c3,0x200f8,0x31c3,0x700f5,0x1a,0x8e9e,0x14c,0x31c2,0x94d8, + 0x31ff,0x700f5,0x1a,0x8e9d,0x14c,0x31c2,0x94d7,0x31ff,0x700f5,0x13,0x7a48,0x35e, + 0x31c2,0x90a5,0x31ff,0x700f5,0x1a,0x7a47,0x14c,0x31c2,0x3201,0x31ff,0x500b1,0x6e, + 0x31c6,0x7a47,0x37d,0x500b8,0x6e,0x31c8,0x7a48,0x380,0x500a7,0x6e,0x31c9,0x31c6, + 0x31c8,0x400f6,0x3202,0x31ff,0x0,0x400fa,0x31c9,0x31ca,0x3202,0x200f8,0x31ca,0x50041, + 0x14,0x68fb,0x68f5,0x8e9d,0x4003d,0x13,0x31cd,0x68fb,0x50041,0x14,0x6905,0x68ff, + 0x8e9e,0x4003d,0x13,0x31d0,0x6905,0x50083,0x13,0x31d1,0x31cd,0x31d0,0x6000c,0x13, + 0x31d3,0x1,0x4,0x31d1,0x500ba,0x6e,0x31d4,0x31d3,0x38d,0x300f7,0x31fe,0x0, + 0x400fa,0x31d4,0x31d5,0x31fd,0x200f8,0x31fd,0x200f9,0x31fe,0x200f8,0x31d5,0x6000c,0x13, + 0x31d7,0x1,0x6,0x31d1,0x4003d,0x13,0x31da,0x68fb,0x4003d,0x13,0x31dd,0x6905, + 0x7000c,0x13,0x341e,0x1,0x28,0x31da,0x31dd,0x500b7,0x6e,0x3412,0x341e,0x1d8, + 0x300f7,0x3418,0x0,0x400fa,0x3412,0x3413,0x3417,0x200f8,0x3417,0x200f9,0x3418,0x200f8, + 0x3413,0x7000c,0x13,0x3423,0x1,0x25,0x31da,0x31dd,0x50088,0x13,0x3416,0x3423, + 0x341e,0x200f9,0x3418,0x200f8,0x3418,0x700f5,0x13,0x8e9f,0x3416,0x3413,0x1d8,0x3417, + 0x50083,0x13,0x31df,0x1dc,0x8e9f,0x50085,0x13,0x31e0,0x31d7,0x31df,0x6000c,0x13, + 0x31e2,0x1,0x4,0x31e0,0x6000c,0x13,0x31e4,0x1,0x4,0x7a48,0x500b8,0x6e, + 0x31e5,0x31e2,0x31e4,0x600a9,0x13,0x31e8,0x31e5,0x31e0,0x7a48,0x4003d,0x13,0x31eb, + 0x68fb,0x4003d,0x13,0x31ee,0x6905,0x500b8,0x6e,0x31ef,0x31eb,0x31ee,0x600a9,0x1a, + 0x31f0,0x31ef,0x191,0x14c,0x50080,0x1a,0x31f2,0x8e9d,0x31f0,0x50041,0x14,0x68fe, + 0x68f5,0x31f2,0x4003d,0x13,0x31f5,0x68fe,0x4003d,0x13,0x31f8,0x6905,0x500be,0x6e, + 0x31f9,0x31f5,0x31f8,0x600a9,0x1a,0x31fa,0x31f9,0x191,0x14c,0x50080,0x1a,0x31fc, + 0x8e9e,0x31fa,0x200f9,0x31fe,0x200f8,0x31fe,0x700f5,0x1a,0x94d8,0x31fc,0x3418,0x8e9e, + 0x31fd,0x700f5,0x1a,0x94d7,0x31f2,0x3418,0x8e9d,0x31fd,0x700f5,0x13,0x90a5,0x31e8, + 0x3418,0x380,0x31fd,0x200f9,0x31ff,0x200f8,0x31ff,0x50080,0x1a,0x3201,0x7a47,0x191, + 0x200f9,0x31c3,0x200f8,0x3202,0x200f9,0x3203,0x200f8,0x3203,0x700f5,0x13,0x7a49,0x35e, + 0x3040,0x7a48,0x3202,0x500b8,0x6e,0x3206,0x7a49,0x35e,0x600a9,0x13,0x3207,0x3206, + 0x1dc,0x1d8,0x50085,0x13,0x3208,0x7a49,0x3207,0x200f9,0x3046,0x200f8,0x3046,0x700f5, + 0x13,0x7a4a,0x1d8,0x312e,0x3208,0x3203,0x60052,0x9f,0x9654,0x7a4a,0x48e,0x0, + 0x500b7,0x6e,0x2fe3,0x7a4a,0x1d8,0x300f7,0x2fe8,0x0,0x400fa,0x2fe3,0x2fe4,0x2fe7, + 0x200f8,0x2fe7,0x200f9,0x2fe8,0x200f8,0x2fe4,0x6000c,0x13,0x2fe6,0x1,0x6,0x7a4a, + 0x200f9,0x2fe8,0x200f8,0x2fe8,0x700f5,0x13,0x7a51,0x2fe6,0x2fe4,0x1d8,0x2fe7,0x60052, + 0x9f,0x9656,0x7a51,0x9654,0x1,0x60052,0x9f,0x9658,0x1dc,0x9656,0x2,0x4007c, + 0x32,0x2fad,0x2f8e,0x4006f,0x38,0x2fae,0x2fad,0x4006e,0x32,0x3434,0x2fae,0x50051, + 0x1a,0x3467,0x3434,0x0,0x7000c,0x1a,0x3478,0x1,0x27,0x3467,0xbc1,0x7000c, + 0x1a,0x347d,0x1,0x2a,0x14c,0x3478,0x50051,0x1a,0x346f,0x3434,0x1,0x7000c, + 0x1a,0x3482,0x1,0x27,0x346f,0xbc9,0x7000c,0x1a,0x3487,0x1,0x2a,0x14c, + 0x3482,0x50050,0x32,0x978c,0x347d,0x3487,0x4003d,0x1b9,0x348a,0x1ca,0x7005f,0x9f, + 0x348c,0x348a,0x978c,0x2,0x14c,0x7004f,0x38,0x348d,0x348c,0x348c,0x0,0x1, + 0x4006f,0x38,0x343a,0x978c,0x50081,0x38,0x343c,0x343a,0x94fd,0x50088,0x38,0x343f, + 0x343c,0xb9a,0x3003e,0x34b2,0x3df,0x50081,0x38,0x34c1,0x343f,0xc1c,0x50085,0x38, + 0x34c5,0x34c1,0xb9a,0x6000c,0x38,0x34c6,0x1,0x8,0x34c5,0x4006e,0x32,0x34c7, + 0x34c6,0x200f9,0x34c8,0x200f8,0x34c8,0x700f5,0x1a,0x7a66,0x14c,0x2fe8,0x34e7,0x34cc, + 0x500b1,0x6e,0x34cb,0x7a66,0x37d,0x400f6,0x34e8,0x34cc,0x0,0x400fa,0x34cb,0x34cc, + 0x34e8,0x200f8,0x34cc,0x50041,0x49,0x34d0,0x34b2,0x7a66,0x4003d,0x32,0x34d1,0x34d0, + 0x50080,0x32,0x3507,0x34c7,0x34d1,0x50051,0x1a,0x350c,0x3507,0x0,0x7000c,0x1a, + 0x351d,0x1,0x27,0x350c,0xbc1,0x7000c,0x1a,0x3522,0x1,0x2a,0x14c,0x351d, + 0x50051,0x1a,0x3514,0x3507,0x1,0x7000c,0x1a,0x3527,0x1,0x27,0x3514,0xbc9, + 0x7000c,0x1a,0x352c,0x1,0x2a,0x14c,0x3527,0x50050,0x32,0x97a0,0x3522,0x352c, + 0x4003d,0x1b9,0x352f,0x1bb,0x7005f,0x9f,0x3531,0x352f,0x97a0,0x2,0x14c,0x50051, + 0x13,0x3532,0x3531,0x0,0x4003d,0x1b9,0x3536,0x1d2,0x7005f,0x9f,0x3537,0x3536, + 0x1d4,0x2,0x14c,0x50051,0x13,0x3538,0x3537,0x0,0x500b4,0x6e,0x353a,0x3538, + 0x1d8,0x600a9,0x13,0x9517,0x353a,0x1dc,0x3538,0x50085,0x13,0x34d7,0x3532,0x9517, + 0x50041,0x14,0x6835,0x6834,0x7a66,0x3003e,0x6835,0x34d7,0x4003d,0x13,0x34dc,0x6835, + 0x7000c,0x13,0x3542,0x1,0x1a,0x34dc,0x1dc,0x3003e,0x6835,0x3542,0x4003d,0x13, + 0x34e2,0x6835,0x7000c,0x13,0x3547,0x1,0x28,0x34e2,0x38d,0x3003e,0x6835,0x3547, + 0x50080,0x1a,0x34e7,0x7a66,0x191,0x200f9,0x34c8,0x200f8,0x34e8,0x4003d,0x82,0x683a, + 0x6834,0x3003e,0x3551,0x3df,0x50081,0x38,0x355f,0x343f,0xcba,0x50081,0x38,0x3562, + 0x355f,0x348d,0x50051,0x13,0x359f,0x3562,0x0,0x500be,0x6e,0x35a0,0x359f,0x1d8, + 0x300f7,0x35a5,0x0,0x400fa,0x35a0,0x35a1,0x35a5,0x200f8,0x35a1,0x500bc,0x6e,0x35a4, + 0x359f,0x1dc,0x200f9,0x35a5,0x200f8,0x35a5,0x700f5,0x6e,0x35a6,0x35a0,0x34e8,0x35a4, + 0x35a1,0x300f7,0x35b1,0x0,0x400fa,0x35a6,0x35a7,0x35b1,0x200f8,0x35a7,0x50051,0x13, + 0x35a9,0x3562,0x1,0x500be,0x6e,0x35aa,0x35a9,0x1d8,0x300f7,0x35af,0x0,0x400fa, + 0x35aa,0x35ab,0x35af,0x200f8,0x35ab,0x500bc,0x6e,0x35ae,0x35a9,0x1dc,0x200f9,0x35af, + 0x200f8,0x35af,0x700f5,0x6e,0x35b0,0x35aa,0x35a7,0x35ae,0x35ab,0x200f9,0x35b1,0x200f8, + 0x35b1,0x700f5,0x6e,0x35b2,0x35a6,0x35a5,0x35b0,0x35af,0x300f7,0x3592,0x0,0x400fa, + 0x35b2,0x3568,0x3592,0x200f8,0x3568,0x50085,0x38,0x356c,0x3562,0xcb9,0x6000c,0x38, + 0x356d,0x1,0x8,0x356c,0x4006e,0x32,0x356e,0x356d,0x200f9,0x356f,0x200f8,0x356f, + 0x700f5,0x1a,0x7a6c,0x14c,0x3568,0x3590,0x3573,0x500b1,0x6e,0x3572,0x7a6c,0x37d, + 0x400f6,0x3591,0x3573,0x0,0x400fa,0x3572,0x3573,0x3591,0x200f8,0x3573,0x50041,0x49, + 0x3577,0x3551,0x7a6c,0x4003d,0x32,0x3578,0x3577,0x50080,0x32,0x35c8,0x356e,0x3578, + 0x50051,0x1a,0x35ca,0xcf7,0x0,0x50082,0x1a,0x35cb,0x35ca,0x191,0x50051,0x1a, + 0x35cd,0x35c8,0x0,0x7000c,0x1a,0x35de,0x1,0x27,0x35cd,0x35cb,0x7000c,0x1a, + 0x35e3,0x1,0x2a,0x14c,0x35de,0x50051,0x1a,0x35d2,0xcf7,0x1,0x50082,0x1a, + 0x35d3,0x35d2,0x191,0x50051,0x1a,0x35d5,0x35c8,0x1,0x7000c,0x1a,0x35e8,0x1, + 0x27,0x35d5,0x35d3,0x7000c,0x1a,0x35ed,0x1,0x2a,0x14c,0x35e8,0x50050,0x32, + 0x979f,0x35e3,0x35ed,0x4003d,0x1b9,0x35f0,0x1c3,0x7005f,0x9f,0x35f2,0x35f0,0x979f, + 0x2,0x14c,0x50051,0x13,0x35f3,0x35f2,0x0,0x50041,0x1a2,0x35f6,0x18b,0x20b, + 0x4003d,0x13,0x35f7,0x35f6,0x50085,0x13,0x357e,0x35f3,0x35f7,0x4003d,0x1b9,0x35fb, + 0x1d2,0x7005f,0x9f,0x35fc,0x35fb,0x1d4,0x2,0x14c,0x50051,0x13,0x35fd,0x35fc, + 0x0,0x500b4,0x6e,0x35ff,0x35fd,0x1d8,0x600a9,0x13,0x9518,0x35ff,0x1dc,0x35fd, + 0x50085,0x13,0x3580,0x357e,0x9518,0x50041,0x14,0x7076,0x7075,0x7a6c,0x3003e,0x7076, + 0x3580,0x4003d,0x13,0x3585,0x7076,0x7000c,0x13,0x3607,0x1,0x1a,0x3585,0x1dc, + 0x3003e,0x7076,0x3607,0x4003d,0x13,0x358b,0x7076,0x7000c,0x13,0x360c,0x1,0x28, + 0x358b,0x38d,0x3003e,0x7076,0x360c,0x50080,0x1a,0x3590,0x7a6c,0x191,0x200f9,0x356f, + 0x200f8,0x3591,0x200f9,0x3592,0x200f8,0x3592,0x4003d,0x82,0x707b,0x7075,0x300f7,0x34aa, + 0x0,0x400fa,0x35b2,0x34a4,0x34aa,0x200f8,0x34a4,0x50051,0x13,0x705a,0x683a,0x0, + 0x50051,0x13,0x705b,0x683a,0x1,0x50051,0x13,0x705c,0x683a,0x2,0x50051,0x13, + 0x705d,0x683a,0x3,0x50051,0x13,0x705e,0x683a,0x4,0x7000c,0x13,0x3714,0x1, + 0x25,0x705a,0x705d,0x7000c,0x13,0x3719,0x1,0x28,0x705a,0x705d,0x7000c,0x13, + 0x371e,0x1,0x25,0x705b,0x705e,0x7000c,0x13,0x3723,0x1,0x28,0x705b,0x705e, + 0x7000c,0x13,0x3728,0x1,0x25,0x3714,0x705c,0x7000c,0x13,0x372d,0x1,0x28, + 0x3714,0x705c,0x7000c,0x13,0x3732,0x1,0x25,0x371e,0x3719,0x7000c,0x13,0x3737, + 0x1,0x28,0x371e,0x3719,0x7000c,0x13,0x373c,0x1,0x25,0x3728,0x3732,0x7000c, + 0x13,0x3741,0x1,0x28,0x3728,0x3732,0x7000c,0x13,0x3746,0x1,0x25,0x372d, + 0x3723,0x7000c,0x13,0x374b,0x1,0x28,0x372d,0x3723,0x7000c,0x13,0x3750,0x1, + 0x25,0x3741,0x3746,0x7000c,0x13,0x3755,0x1,0x28,0x3741,0x3746,0x7000c,0x13, + 0x375a,0x1,0x25,0x3737,0x374b,0x7000c,0x13,0x375f,0x1,0x28,0x3737,0x374b, + 0x7000c,0x13,0x3764,0x1,0x25,0x3755,0x375a,0x7000c,0x13,0x3769,0x1,0x28, + 0x3755,0x375a,0x80050,0x82,0x7064,0x373c,0x3750,0x3764,0x3769,0x375f,0x3003e,0x6848, + 0x7064,0x50051,0x13,0x706a,0x707b,0x0,0x50051,0x13,0x706b,0x707b,0x1,0x50051, + 0x13,0x706c,0x707b,0x2,0x50051,0x13,0x706d,0x707b,0x3,0x50051,0x13,0x706e, + 0x707b,0x4,0x7000c,0x13,0x3811,0x1,0x25,0x706a,0x706d,0x7000c,0x13,0x3816, + 0x1,0x28,0x706a,0x706d,0x7000c,0x13,0x381b,0x1,0x25,0x706b,0x706e,0x7000c, + 0x13,0x3820,0x1,0x28,0x706b,0x706e,0x7000c,0x13,0x3825,0x1,0x25,0x3811, + 0x706c,0x7000c,0x13,0x382a,0x1,0x28,0x3811,0x706c,0x7000c,0x13,0x382f,0x1, + 0x25,0x381b,0x3816,0x7000c,0x13,0x3834,0x1,0x28,0x381b,0x3816,0x7000c,0x13, + 0x3839,0x1,0x25,0x3825,0x382f,0x7000c,0x13,0x383e,0x1,0x28,0x3825,0x382f, + 0x7000c,0x13,0x3843,0x1,0x25,0x382a,0x3820,0x7000c,0x13,0x3848,0x1,0x28, + 0x382a,0x3820,0x7000c,0x13,0x384d,0x1,0x25,0x383e,0x3843,0x7000c,0x13,0x3852, + 0x1,0x28,0x383e,0x3843,0x7000c,0x13,0x3857,0x1,0x25,0x3834,0x3848,0x7000c, + 0x13,0x385c,0x1,0x28,0x3834,0x3848,0x7000c,0x13,0x3861,0x1,0x25,0x3852, + 0x3857,0x7000c,0x13,0x3866,0x1,0x28,0x3852,0x3857,0x80050,0x82,0x7074,0x3839, + 0x384d,0x3861,0x3866,0x385c,0x3003e,0x6852,0x7074,0x50041,0x14,0x684d,0x6848,0x2cd, + 0x4003d,0x13,0x3620,0x684d,0x50041,0x14,0x6857,0x6852,0x2cd,0x4003d,0x13,0x3622, + 0x6857,0x7000c,0x13,0x386b,0x1,0x25,0x3620,0x3622,0x500ba,0x6e,0x3625,0x386b, + 0x372,0x300f7,0x3667,0x0,0x400fa,0x3625,0x3626,0x3667,0x200f8,0x3626,0x200f9,0x3627, + 0x200f8,0x3627,0x700f5,0x1a,0x8e90,0x14c,0x3626,0x94d4,0x3663,0x700f5,0x1a,0x8e8f, + 0x14c,0x3626,0x94d3,0x3663,0x700f5,0x13,0x7a8f,0x35e,0x3626,0x90ba,0x3663,0x700f5, + 0x1a,0x7a8e,0x14c,0x3626,0x3665,0x3663,0x500b1,0x6e,0x362a,0x7a8e,0x37d,0x500b8, + 0x6e,0x362c,0x7a8f,0x380,0x500a7,0x6e,0x362d,0x362a,0x362c,0x400f6,0x3666,0x3663, + 0x0,0x400fa,0x362d,0x362e,0x3666,0x200f8,0x362e,0x50041,0x14,0x684e,0x6848,0x8e8f, + 0x4003d,0x13,0x3631,0x684e,0x50041,0x14,0x6858,0x6852,0x8e90,0x4003d,0x13,0x3634, + 0x6858,0x50083,0x13,0x3635,0x3631,0x3634,0x6000c,0x13,0x3637,0x1,0x4,0x3635, + 0x500ba,0x6e,0x3638,0x3637,0x38d,0x300f7,0x3662,0x0,0x400fa,0x3638,0x3639,0x3661, + 0x200f8,0x3661,0x200f9,0x3662,0x200f8,0x3639,0x6000c,0x13,0x363b,0x1,0x6,0x3635, + 0x4003d,0x13,0x363e,0x684e,0x4003d,0x13,0x3641,0x6858,0x7000c,0x13,0x3882,0x1, + 0x28,0x363e,0x3641,0x500b7,0x6e,0x3876,0x3882,0x1d8,0x300f7,0x387c,0x0,0x400fa, + 0x3876,0x3877,0x387b,0x200f8,0x387b,0x200f9,0x387c,0x200f8,0x3877,0x7000c,0x13,0x3887, + 0x1,0x25,0x363e,0x3641,0x50088,0x13,0x387a,0x3887,0x3882,0x200f9,0x387c,0x200f8, + 0x387c,0x700f5,0x13,0x8e91,0x387a,0x3877,0x1d8,0x387b,0x50083,0x13,0x3643,0x1dc, + 0x8e91,0x50085,0x13,0x3644,0x363b,0x3643,0x6000c,0x13,0x3646,0x1,0x4,0x3644, + 0x6000c,0x13,0x3648,0x1,0x4,0x7a8f,0x500b8,0x6e,0x3649,0x3646,0x3648,0x600a9, + 0x13,0x364c,0x3649,0x3644,0x7a8f,0x4003d,0x13,0x364f,0x684e,0x4003d,0x13,0x3652, + 0x6858,0x500b8,0x6e,0x3653,0x364f,0x3652,0x600a9,0x1a,0x3654,0x3653,0x191,0x14c, + 0x50080,0x1a,0x3656,0x8e8f,0x3654,0x50041,0x14,0x6851,0x6848,0x3656,0x4003d,0x13, + 0x3659,0x6851,0x4003d,0x13,0x365c,0x6858,0x500be,0x6e,0x365d,0x3659,0x365c,0x600a9, + 0x1a,0x365e,0x365d,0x191,0x14c,0x50080,0x1a,0x3660,0x8e90,0x365e,0x200f9,0x3662, + 0x200f8,0x3662,0x700f5,0x1a,0x94d4,0x3660,0x387c,0x8e90,0x3661,0x700f5,0x1a,0x94d3, + 0x3656,0x387c,0x8e8f,0x3661,0x700f5,0x13,0x90ba,0x364c,0x387c,0x380,0x3661,0x200f9, + 0x3663,0x200f8,0x3663,0x50080,0x1a,0x3665,0x7a8e,0x191,0x200f9,0x3627,0x200f8,0x3666, + 0x200f9,0x3667,0x200f8,0x3667,0x700f5,0x13,0x7a90,0x35e,0x34a4,0x7a8f,0x3666,0x500b8, + 0x6e,0x366a,0x7a90,0x35e,0x600a9,0x13,0x366b,0x366a,0x1dc,0x1d8,0x50085,0x13, + 0x366c,0x7a90,0x366b,0x200f9,0x34aa,0x200f8,0x34aa,0x700f5,0x13,0x7a91,0x1d8,0x3592, + 0x366c,0x3667,0x60052,0x9f,0x9676,0x7a91,0x48e,0x0,0x500b7,0x6e,0x3447,0x7a91, + 0x1d8,0x300f7,0x344c,0x0,0x400fa,0x3447,0x3448,0x344b,0x200f8,0x344b,0x200f9,0x344c, + 0x200f8,0x3448,0x6000c,0x13,0x344a,0x1,0x6,0x7a91,0x200f9,0x344c,0x200f8,0x344c, + 0x700f5,0x13,0x7a98,0x344a,0x3448,0x1d8,0x344b,0x60052,0x9f,0x9678,0x7a98,0x9676, + 0x1,0x60052,0x9f,0x967a,0x1dc,0x9678,0x2,0x4007c,0x32,0x2fb2,0x2f90,0x4006f, + 0x38,0x2fb3,0x2fb2,0x4006e,0x32,0x3898,0x2fb3,0x50051,0x1a,0x38cb,0x3898,0x0, + 0x7000c,0x1a,0x38dc,0x1,0x27,0x38cb,0xbc1,0x7000c,0x1a,0x38e1,0x1,0x2a, + 0x14c,0x38dc,0x50051,0x1a,0x38d3,0x3898,0x1,0x7000c,0x1a,0x38e6,0x1,0x27, + 0x38d3,0xbc9,0x7000c,0x1a,0x38eb,0x1,0x2a,0x14c,0x38e6,0x50050,0x32,0x978d, + 0x38e1,0x38eb,0x4003d,0x1b9,0x38ee,0x1ca,0x7005f,0x9f,0x38f0,0x38ee,0x978d,0x2, + 0x14c,0x7004f,0x38,0x38f1,0x38f0,0x38f0,0x0,0x1,0x4006f,0x38,0x389e,0x978d, + 0x50081,0x38,0x38a0,0x389e,0x94fd,0x50088,0x38,0x38a3,0x38a0,0xb9a,0x3003e,0x3916, + 0x3df,0x50081,0x38,0x3925,0x38a3,0xc1c,0x50085,0x38,0x3929,0x3925,0xb9a,0x6000c, + 0x38,0x392a,0x1,0x8,0x3929,0x4006e,0x32,0x392b,0x392a,0x200f9,0x392c,0x200f8, + 0x392c,0x700f5,0x1a,0x7ab7,0x14c,0x344c,0x394b,0x3930,0x500b1,0x6e,0x392f,0x7ab7, + 0x37d,0x400f6,0x394c,0x3930,0x0,0x400fa,0x392f,0x3930,0x394c,0x200f8,0x3930,0x50041, + 0x49,0x3934,0x3916,0x7ab7,0x4003d,0x32,0x3935,0x3934,0x50080,0x32,0x396b,0x392b, + 0x3935,0x50051,0x1a,0x3970,0x396b,0x0,0x7000c,0x1a,0x3981,0x1,0x27,0x3970, + 0xbc1,0x7000c,0x1a,0x3986,0x1,0x2a,0x14c,0x3981,0x50051,0x1a,0x3978,0x396b, + 0x1,0x7000c,0x1a,0x398b,0x1,0x27,0x3978,0xbc9,0x7000c,0x1a,0x3990,0x1, + 0x2a,0x14c,0x398b,0x50050,0x32,0x979e,0x3986,0x3990,0x4003d,0x1b9,0x3993,0x1bb, + 0x7005f,0x9f,0x3995,0x3993,0x979e,0x2,0x14c,0x50051,0x13,0x3996,0x3995,0x0, + 0x4003d,0x1b9,0x399a,0x1d2,0x7005f,0x9f,0x399b,0x399a,0x1d4,0x2,0x14c,0x50051, + 0x13,0x399c,0x399b,0x0,0x500b4,0x6e,0x399e,0x399c,0x1d8,0x600a9,0x13,0x9519, + 0x399e,0x1dc,0x399c,0x50085,0x13,0x393b,0x3996,0x9519,0x50041,0x14,0x6788,0x6787, + 0x7ab7,0x3003e,0x6788,0x393b,0x4003d,0x13,0x3940,0x6788,0x7000c,0x13,0x39a6,0x1, + 0x1a,0x3940,0x1dc,0x3003e,0x6788,0x39a6,0x4003d,0x13,0x3946,0x6788,0x7000c,0x13, + 0x39ab,0x1,0x28,0x3946,0x38d,0x3003e,0x6788,0x39ab,0x50080,0x1a,0x394b,0x7ab7, + 0x191,0x200f9,0x392c,0x200f8,0x394c,0x4003d,0x82,0x678d,0x6787,0x3003e,0x39b5,0x3df, + 0x50081,0x38,0x39c3,0x38a3,0xcba,0x50081,0x38,0x39c6,0x39c3,0x38f1,0x50051,0x13, + 0x3a03,0x39c6,0x0,0x500be,0x6e,0x3a04,0x3a03,0x1d8,0x300f7,0x3a09,0x0,0x400fa, + 0x3a04,0x3a05,0x3a09,0x200f8,0x3a05,0x500bc,0x6e,0x3a08,0x3a03,0x1dc,0x200f9,0x3a09, + 0x200f8,0x3a09,0x700f5,0x6e,0x3a0a,0x3a04,0x394c,0x3a08,0x3a05,0x300f7,0x3a15,0x0, + 0x400fa,0x3a0a,0x3a0b,0x3a15,0x200f8,0x3a0b,0x50051,0x13,0x3a0d,0x39c6,0x1,0x500be, + 0x6e,0x3a0e,0x3a0d,0x1d8,0x300f7,0x3a13,0x0,0x400fa,0x3a0e,0x3a0f,0x3a13,0x200f8, + 0x3a0f,0x500bc,0x6e,0x3a12,0x3a0d,0x1dc,0x200f9,0x3a13,0x200f8,0x3a13,0x700f5,0x6e, + 0x3a14,0x3a0e,0x3a0b,0x3a12,0x3a0f,0x200f9,0x3a15,0x200f8,0x3a15,0x700f5,0x6e,0x3a16, + 0x3a0a,0x3a09,0x3a14,0x3a13,0x300f7,0x39f6,0x0,0x400fa,0x3a16,0x39cc,0x39f6,0x200f8, + 0x39cc,0x50085,0x38,0x39d0,0x39c6,0xcb9,0x6000c,0x38,0x39d1,0x1,0x8,0x39d0, + 0x4006e,0x32,0x39d2,0x39d1,0x200f9,0x39d3,0x200f8,0x39d3,0x700f5,0x1a,0x7abd,0x14c, + 0x39cc,0x39f4,0x39d7,0x500b1,0x6e,0x39d6,0x7abd,0x37d,0x400f6,0x39f5,0x39d7,0x0, + 0x400fa,0x39d6,0x39d7,0x39f5,0x200f8,0x39d7,0x50041,0x49,0x39db,0x39b5,0x7abd,0x4003d, + 0x32,0x39dc,0x39db,0x50080,0x32,0x3a2c,0x39d2,0x39dc,0x50051,0x1a,0x3a2e,0xcf7, + 0x0,0x50082,0x1a,0x3a2f,0x3a2e,0x191,0x50051,0x1a,0x3a31,0x3a2c,0x0,0x7000c, + 0x1a,0x3a42,0x1,0x27,0x3a31,0x3a2f,0x7000c,0x1a,0x3a47,0x1,0x2a,0x14c, + 0x3a42,0x50051,0x1a,0x3a36,0xcf7,0x1,0x50082,0x1a,0x3a37,0x3a36,0x191,0x50051, + 0x1a,0x3a39,0x3a2c,0x1,0x7000c,0x1a,0x3a4c,0x1,0x27,0x3a39,0x3a37,0x7000c, + 0x1a,0x3a51,0x1,0x2a,0x14c,0x3a4c,0x50050,0x32,0x979d,0x3a47,0x3a51,0x4003d, + 0x1b9,0x3a54,0x1c3,0x7005f,0x9f,0x3a56,0x3a54,0x979d,0x2,0x14c,0x50051,0x13, + 0x3a57,0x3a56,0x0,0x50041,0x1a2,0x3a5a,0x18b,0x20b,0x4003d,0x13,0x3a5b,0x3a5a, + 0x50085,0x13,0x39e2,0x3a57,0x3a5b,0x4003d,0x1b9,0x3a5f,0x1d2,0x7005f,0x9f,0x3a60, + 0x3a5f,0x1d4,0x2,0x14c,0x50051,0x13,0x3a61,0x3a60,0x0,0x500b4,0x6e,0x3a63, + 0x3a61,0x1d8,0x600a9,0x13,0x951a,0x3a63,0x1dc,0x3a61,0x50085,0x13,0x39e4,0x39e2, + 0x951a,0x50041,0x14,0x7026,0x7025,0x7abd,0x3003e,0x7026,0x39e4,0x4003d,0x13,0x39e9, + 0x7026,0x7000c,0x13,0x3a6b,0x1,0x1a,0x39e9,0x1dc,0x3003e,0x7026,0x3a6b,0x4003d, + 0x13,0x39ef,0x7026,0x7000c,0x13,0x3a70,0x1,0x28,0x39ef,0x38d,0x3003e,0x7026, + 0x3a70,0x50080,0x1a,0x39f4,0x7abd,0x191,0x200f9,0x39d3,0x200f8,0x39f5,0x200f9,0x39f6, + 0x200f8,0x39f6,0x4003d,0x82,0x702b,0x7025,0x300f7,0x390e,0x0,0x400fa,0x3a16,0x3908, + 0x390e,0x200f8,0x3908,0x50051,0x13,0x700a,0x678d,0x0,0x50051,0x13,0x700b,0x678d, + 0x1,0x50051,0x13,0x700c,0x678d,0x2,0x50051,0x13,0x700d,0x678d,0x3,0x50051, + 0x13,0x700e,0x678d,0x4,0x7000c,0x13,0x3b78,0x1,0x25,0x700a,0x700d,0x7000c, + 0x13,0x3b7d,0x1,0x28,0x700a,0x700d,0x7000c,0x13,0x3b82,0x1,0x25,0x700b, + 0x700e,0x7000c,0x13,0x3b87,0x1,0x28,0x700b,0x700e,0x7000c,0x13,0x3b8c,0x1, + 0x25,0x3b78,0x700c,0x7000c,0x13,0x3b91,0x1,0x28,0x3b78,0x700c,0x7000c,0x13, + 0x3b96,0x1,0x25,0x3b82,0x3b7d,0x7000c,0x13,0x3b9b,0x1,0x28,0x3b82,0x3b7d, + 0x7000c,0x13,0x3ba0,0x1,0x25,0x3b8c,0x3b96,0x7000c,0x13,0x3ba5,0x1,0x28, + 0x3b8c,0x3b96,0x7000c,0x13,0x3baa,0x1,0x25,0x3b91,0x3b87,0x7000c,0x13,0x3baf, + 0x1,0x28,0x3b91,0x3b87,0x7000c,0x13,0x3bb4,0x1,0x25,0x3ba5,0x3baa,0x7000c, + 0x13,0x3bb9,0x1,0x28,0x3ba5,0x3baa,0x7000c,0x13,0x3bbe,0x1,0x25,0x3b9b, + 0x3baf,0x7000c,0x13,0x3bc3,0x1,0x28,0x3b9b,0x3baf,0x7000c,0x13,0x3bc8,0x1, + 0x25,0x3bb9,0x3bbe,0x7000c,0x13,0x3bcd,0x1,0x28,0x3bb9,0x3bbe,0x80050,0x82, + 0x7014,0x3ba0,0x3bb4,0x3bc8,0x3bcd,0x3bc3,0x3003e,0x679b,0x7014,0x50051,0x13,0x701a, + 0x702b,0x0,0x50051,0x13,0x701b,0x702b,0x1,0x50051,0x13,0x701c,0x702b,0x2, + 0x50051,0x13,0x701d,0x702b,0x3,0x50051,0x13,0x701e,0x702b,0x4,0x7000c,0x13, + 0x3c75,0x1,0x25,0x701a,0x701d,0x7000c,0x13,0x3c7a,0x1,0x28,0x701a,0x701d, + 0x7000c,0x13,0x3c7f,0x1,0x25,0x701b,0x701e,0x7000c,0x13,0x3c84,0x1,0x28, + 0x701b,0x701e,0x7000c,0x13,0x3c89,0x1,0x25,0x3c75,0x701c,0x7000c,0x13,0x3c8e, + 0x1,0x28,0x3c75,0x701c,0x7000c,0x13,0x3c93,0x1,0x25,0x3c7f,0x3c7a,0x7000c, + 0x13,0x3c98,0x1,0x28,0x3c7f,0x3c7a,0x7000c,0x13,0x3c9d,0x1,0x25,0x3c89, + 0x3c93,0x7000c,0x13,0x3ca2,0x1,0x28,0x3c89,0x3c93,0x7000c,0x13,0x3ca7,0x1, + 0x25,0x3c8e,0x3c84,0x7000c,0x13,0x3cac,0x1,0x28,0x3c8e,0x3c84,0x7000c,0x13, + 0x3cb1,0x1,0x25,0x3ca2,0x3ca7,0x7000c,0x13,0x3cb6,0x1,0x28,0x3ca2,0x3ca7, + 0x7000c,0x13,0x3cbb,0x1,0x25,0x3c98,0x3cac,0x7000c,0x13,0x3cc0,0x1,0x28, + 0x3c98,0x3cac,0x7000c,0x13,0x3cc5,0x1,0x25,0x3cb6,0x3cbb,0x7000c,0x13,0x3cca, + 0x1,0x28,0x3cb6,0x3cbb,0x80050,0x82,0x7024,0x3c9d,0x3cb1,0x3cc5,0x3cca,0x3cc0, + 0x3003e,0x67a5,0x7024,0x50041,0x14,0x67a0,0x679b,0x2cd,0x4003d,0x13,0x3a84,0x67a0, + 0x50041,0x14,0x67aa,0x67a5,0x2cd,0x4003d,0x13,0x3a86,0x67aa,0x7000c,0x13,0x3ccf, + 0x1,0x25,0x3a84,0x3a86,0x500ba,0x6e,0x3a89,0x3ccf,0x372,0x300f7,0x3acb,0x0, + 0x400fa,0x3a89,0x3a8a,0x3acb,0x200f8,0x3a8a,0x200f9,0x3a8b,0x200f8,0x3a8b,0x700f5,0x1a, + 0x8e82,0x14c,0x3a8a,0x94d0,0x3ac7,0x700f5,0x1a,0x8e81,0x14c,0x3a8a,0x94cf,0x3ac7, + 0x700f5,0x13,0x7ae0,0x35e,0x3a8a,0x90d3,0x3ac7,0x700f5,0x1a,0x7adf,0x14c,0x3a8a, + 0x3ac9,0x3ac7,0x500b1,0x6e,0x3a8e,0x7adf,0x37d,0x500b8,0x6e,0x3a90,0x7ae0,0x380, + 0x500a7,0x6e,0x3a91,0x3a8e,0x3a90,0x400f6,0x3aca,0x3ac7,0x0,0x400fa,0x3a91,0x3a92, + 0x3aca,0x200f8,0x3a92,0x50041,0x14,0x67a1,0x679b,0x8e81,0x4003d,0x13,0x3a95,0x67a1, + 0x50041,0x14,0x67ab,0x67a5,0x8e82,0x4003d,0x13,0x3a98,0x67ab,0x50083,0x13,0x3a99, + 0x3a95,0x3a98,0x6000c,0x13,0x3a9b,0x1,0x4,0x3a99,0x500ba,0x6e,0x3a9c,0x3a9b, + 0x38d,0x300f7,0x3ac6,0x0,0x400fa,0x3a9c,0x3a9d,0x3ac5,0x200f8,0x3ac5,0x200f9,0x3ac6, + 0x200f8,0x3a9d,0x6000c,0x13,0x3a9f,0x1,0x6,0x3a99,0x4003d,0x13,0x3aa2,0x67a1, + 0x4003d,0x13,0x3aa5,0x67ab,0x7000c,0x13,0x3ce6,0x1,0x28,0x3aa2,0x3aa5,0x500b7, + 0x6e,0x3cda,0x3ce6,0x1d8,0x300f7,0x3ce0,0x0,0x400fa,0x3cda,0x3cdb,0x3cdf,0x200f8, + 0x3cdf,0x200f9,0x3ce0,0x200f8,0x3cdb,0x7000c,0x13,0x3ceb,0x1,0x25,0x3aa2,0x3aa5, + 0x50088,0x13,0x3cde,0x3ceb,0x3ce6,0x200f9,0x3ce0,0x200f8,0x3ce0,0x700f5,0x13,0x8e83, + 0x3cde,0x3cdb,0x1d8,0x3cdf,0x50083,0x13,0x3aa7,0x1dc,0x8e83,0x50085,0x13,0x3aa8, + 0x3a9f,0x3aa7,0x6000c,0x13,0x3aaa,0x1,0x4,0x3aa8,0x6000c,0x13,0x3aac,0x1, + 0x4,0x7ae0,0x500b8,0x6e,0x3aad,0x3aaa,0x3aac,0x600a9,0x13,0x3ab0,0x3aad,0x3aa8, + 0x7ae0,0x4003d,0x13,0x3ab3,0x67a1,0x4003d,0x13,0x3ab6,0x67ab,0x500b8,0x6e,0x3ab7, + 0x3ab3,0x3ab6,0x600a9,0x1a,0x3ab8,0x3ab7,0x191,0x14c,0x50080,0x1a,0x3aba,0x8e81, + 0x3ab8,0x50041,0x14,0x67a4,0x679b,0x3aba,0x4003d,0x13,0x3abd,0x67a4,0x4003d,0x13, + 0x3ac0,0x67ab,0x500be,0x6e,0x3ac1,0x3abd,0x3ac0,0x600a9,0x1a,0x3ac2,0x3ac1,0x191, + 0x14c,0x50080,0x1a,0x3ac4,0x8e82,0x3ac2,0x200f9,0x3ac6,0x200f8,0x3ac6,0x700f5,0x1a, + 0x94d0,0x3ac4,0x3ce0,0x8e82,0x3ac5,0x700f5,0x1a,0x94cf,0x3aba,0x3ce0,0x8e81,0x3ac5, + 0x700f5,0x13,0x90d3,0x3ab0,0x3ce0,0x380,0x3ac5,0x200f9,0x3ac7,0x200f8,0x3ac7,0x50080, + 0x1a,0x3ac9,0x7adf,0x191,0x200f9,0x3a8b,0x200f8,0x3aca,0x200f9,0x3acb,0x200f8,0x3acb, + 0x700f5,0x13,0x7ae1,0x35e,0x3908,0x7ae0,0x3aca,0x500b8,0x6e,0x3ace,0x7ae1,0x35e, + 0x600a9,0x13,0x3acf,0x3ace,0x1dc,0x1d8,0x50085,0x13,0x3ad0,0x7ae1,0x3acf,0x200f9, + 0x390e,0x200f8,0x390e,0x700f5,0x13,0x7ae2,0x1d8,0x39f6,0x3ad0,0x3acb,0x60052,0x9f, + 0x9698,0x7ae2,0x48e,0x0,0x500b7,0x6e,0x38ab,0x7ae2,0x1d8,0x300f7,0x38b0,0x0, + 0x400fa,0x38ab,0x38ac,0x38af,0x200f8,0x38af,0x200f9,0x38b0,0x200f8,0x38ac,0x6000c,0x13, + 0x38ae,0x1,0x6,0x7ae2,0x200f9,0x38b0,0x200f8,0x38b0,0x700f5,0x13,0x7ae9,0x38ae, + 0x38ac,0x1d8,0x38af,0x60052,0x9f,0x969a,0x7ae9,0x9698,0x1,0x60052,0x9f,0x969c, + 0x1dc,0x969a,0x2,0x4007c,0x32,0x2fb7,0x2f92,0x4006f,0x38,0x2fb8,0x2fb7,0x4006e, + 0x32,0x3cfc,0x2fb8,0x50051,0x1a,0x3d2f,0x3cfc,0x0,0x7000c,0x1a,0x3d40,0x1, + 0x27,0x3d2f,0xbc1,0x7000c,0x1a,0x3d45,0x1,0x2a,0x14c,0x3d40,0x50051,0x1a, + 0x3d37,0x3cfc,0x1,0x7000c,0x1a,0x3d4a,0x1,0x27,0x3d37,0xbc9,0x7000c,0x1a, + 0x3d4f,0x1,0x2a,0x14c,0x3d4a,0x50050,0x32,0x978e,0x3d45,0x3d4f,0x4003d,0x1b9, + 0x3d52,0x1ca,0x7005f,0x9f,0x3d54,0x3d52,0x978e,0x2,0x14c,0x7004f,0x38,0x3d55, + 0x3d54,0x3d54,0x0,0x1,0x4006f,0x38,0x3d02,0x978e,0x50081,0x38,0x3d04,0x3d02, + 0x94fd,0x50088,0x38,0x3d07,0x3d04,0xb9a,0x3003e,0x3d7a,0x3df,0x50081,0x38,0x3d89, + 0x3d07,0xc1c,0x50085,0x38,0x3d8d,0x3d89,0xb9a,0x6000c,0x38,0x3d8e,0x1,0x8, + 0x3d8d,0x4006e,0x32,0x3d8f,0x3d8e,0x200f9,0x3d90,0x200f8,0x3d90,0x700f5,0x1a,0x7b12, + 0x14c,0x38b0,0x3daf,0x3d94,0x500b1,0x6e,0x3d93,0x7b12,0x37d,0x400f6,0x3db0,0x3d94, + 0x0,0x400fa,0x3d93,0x3d94,0x3db0,0x200f8,0x3d94,0x50041,0x49,0x3d98,0x3d7a,0x7b12, + 0x4003d,0x32,0x3d99,0x3d98,0x50080,0x32,0x3dcf,0x3d8f,0x3d99,0x50051,0x1a,0x3dd4, + 0x3dcf,0x0,0x7000c,0x1a,0x3de5,0x1,0x27,0x3dd4,0xbc1,0x7000c,0x1a,0x3dea, + 0x1,0x2a,0x14c,0x3de5,0x50051,0x1a,0x3ddc,0x3dcf,0x1,0x7000c,0x1a,0x3def, + 0x1,0x27,0x3ddc,0xbc9,0x7000c,0x1a,0x3df4,0x1,0x2a,0x14c,0x3def,0x50050, + 0x32,0x979c,0x3dea,0x3df4,0x4003d,0x1b9,0x3df7,0x1bb,0x7005f,0x9f,0x3df9,0x3df7, + 0x979c,0x2,0x14c,0x50051,0x13,0x3dfa,0x3df9,0x0,0x4003d,0x1b9,0x3dfe,0x1d2, + 0x7005f,0x9f,0x3dff,0x3dfe,0x1d4,0x2,0x14c,0x50051,0x13,0x3e00,0x3dff,0x0, + 0x500b4,0x6e,0x3e02,0x3e00,0x1d8,0x600a9,0x13,0x951b,0x3e02,0x1dc,0x3e00,0x50085, + 0x13,0x3d9f,0x3dfa,0x951b,0x50041,0x14,0x66db,0x66da,0x7b12,0x3003e,0x66db,0x3d9f, + 0x4003d,0x13,0x3da4,0x66db,0x7000c,0x13,0x3e0a,0x1,0x1a,0x3da4,0x1dc,0x3003e, + 0x66db,0x3e0a,0x4003d,0x13,0x3daa,0x66db,0x7000c,0x13,0x3e0f,0x1,0x28,0x3daa, + 0x38d,0x3003e,0x66db,0x3e0f,0x50080,0x1a,0x3daf,0x7b12,0x191,0x200f9,0x3d90,0x200f8, + 0x3db0,0x4003d,0x82,0x66e0,0x66da,0x3003e,0x3e19,0x3df,0x50081,0x38,0x3e27,0x3d07, + 0xcba,0x50081,0x38,0x3e2a,0x3e27,0x3d55,0x50051,0x13,0x3e67,0x3e2a,0x0,0x500be, + 0x6e,0x3e68,0x3e67,0x1d8,0x300f7,0x3e6d,0x0,0x400fa,0x3e68,0x3e69,0x3e6d,0x200f8, + 0x3e69,0x500bc,0x6e,0x3e6c,0x3e67,0x1dc,0x200f9,0x3e6d,0x200f8,0x3e6d,0x700f5,0x6e, + 0x3e6e,0x3e68,0x3db0,0x3e6c,0x3e69,0x300f7,0x3e79,0x0,0x400fa,0x3e6e,0x3e6f,0x3e79, + 0x200f8,0x3e6f,0x50051,0x13,0x3e71,0x3e2a,0x1,0x500be,0x6e,0x3e72,0x3e71,0x1d8, + 0x300f7,0x3e77,0x0,0x400fa,0x3e72,0x3e73,0x3e77,0x200f8,0x3e73,0x500bc,0x6e,0x3e76, + 0x3e71,0x1dc,0x200f9,0x3e77,0x200f8,0x3e77,0x700f5,0x6e,0x3e78,0x3e72,0x3e6f,0x3e76, + 0x3e73,0x200f9,0x3e79,0x200f8,0x3e79,0x700f5,0x6e,0x3e7a,0x3e6e,0x3e6d,0x3e78,0x3e77, + 0x300f7,0x3e5a,0x0,0x400fa,0x3e7a,0x3e30,0x3e5a,0x200f8,0x3e30,0x50085,0x38,0x3e34, + 0x3e2a,0xcb9,0x6000c,0x38,0x3e35,0x1,0x8,0x3e34,0x4006e,0x32,0x3e36,0x3e35, + 0x200f9,0x3e37,0x200f8,0x3e37,0x700f5,0x1a,0x7b18,0x14c,0x3e30,0x3e58,0x3e3b,0x500b1, + 0x6e,0x3e3a,0x7b18,0x37d,0x400f6,0x3e59,0x3e3b,0x0,0x400fa,0x3e3a,0x3e3b,0x3e59, + 0x200f8,0x3e3b,0x50041,0x49,0x3e3f,0x3e19,0x7b18,0x4003d,0x32,0x3e40,0x3e3f,0x50080, + 0x32,0x3e90,0x3e36,0x3e40,0x50051,0x1a,0x3e92,0xcf7,0x0,0x50082,0x1a,0x3e93, + 0x3e92,0x191,0x50051,0x1a,0x3e95,0x3e90,0x0,0x7000c,0x1a,0x3ea6,0x1,0x27, + 0x3e95,0x3e93,0x7000c,0x1a,0x3eab,0x1,0x2a,0x14c,0x3ea6,0x50051,0x1a,0x3e9a, + 0xcf7,0x1,0x50082,0x1a,0x3e9b,0x3e9a,0x191,0x50051,0x1a,0x3e9d,0x3e90,0x1, + 0x7000c,0x1a,0x3eb0,0x1,0x27,0x3e9d,0x3e9b,0x7000c,0x1a,0x3eb5,0x1,0x2a, + 0x14c,0x3eb0,0x50050,0x32,0x979b,0x3eab,0x3eb5,0x4003d,0x1b9,0x3eb8,0x1c3,0x7005f, + 0x9f,0x3eba,0x3eb8,0x979b,0x2,0x14c,0x50051,0x13,0x3ebb,0x3eba,0x0,0x50041, + 0x1a2,0x3ebe,0x18b,0x20b,0x4003d,0x13,0x3ebf,0x3ebe,0x50085,0x13,0x3e46,0x3ebb, + 0x3ebf,0x4003d,0x1b9,0x3ec3,0x1d2,0x7005f,0x9f,0x3ec4,0x3ec3,0x1d4,0x2,0x14c, + 0x50051,0x13,0x3ec5,0x3ec4,0x0,0x500b4,0x6e,0x3ec7,0x3ec5,0x1d8,0x600a9,0x13, + 0x951c,0x3ec7,0x1dc,0x3ec5,0x50085,0x13,0x3e48,0x3e46,0x951c,0x50041,0x14,0x6fd6, + 0x6fd5,0x7b18,0x3003e,0x6fd6,0x3e48,0x4003d,0x13,0x3e4d,0x6fd6,0x7000c,0x13,0x3ecf, + 0x1,0x1a,0x3e4d,0x1dc,0x3003e,0x6fd6,0x3ecf,0x4003d,0x13,0x3e53,0x6fd6,0x7000c, + 0x13,0x3ed4,0x1,0x28,0x3e53,0x38d,0x3003e,0x6fd6,0x3ed4,0x50080,0x1a,0x3e58, + 0x7b18,0x191,0x200f9,0x3e37,0x200f8,0x3e59,0x200f9,0x3e5a,0x200f8,0x3e5a,0x4003d,0x82, + 0x6fdb,0x6fd5,0x300f7,0x3d72,0x0,0x400fa,0x3e7a,0x3d6c,0x3d72,0x200f8,0x3d6c,0x50051, + 0x13,0x6fba,0x66e0,0x0,0x50051,0x13,0x6fbb,0x66e0,0x1,0x50051,0x13,0x6fbc, + 0x66e0,0x2,0x50051,0x13,0x6fbd,0x66e0,0x3,0x50051,0x13,0x6fbe,0x66e0,0x4, + 0x7000c,0x13,0x3fdc,0x1,0x25,0x6fba,0x6fbd,0x7000c,0x13,0x3fe1,0x1,0x28, + 0x6fba,0x6fbd,0x7000c,0x13,0x3fe6,0x1,0x25,0x6fbb,0x6fbe,0x7000c,0x13,0x3feb, + 0x1,0x28,0x6fbb,0x6fbe,0x7000c,0x13,0x3ff0,0x1,0x25,0x3fdc,0x6fbc,0x7000c, + 0x13,0x3ff5,0x1,0x28,0x3fdc,0x6fbc,0x7000c,0x13,0x3ffa,0x1,0x25,0x3fe6, + 0x3fe1,0x7000c,0x13,0x3fff,0x1,0x28,0x3fe6,0x3fe1,0x7000c,0x13,0x4004,0x1, + 0x25,0x3ff0,0x3ffa,0x7000c,0x13,0x4009,0x1,0x28,0x3ff0,0x3ffa,0x7000c,0x13, + 0x400e,0x1,0x25,0x3ff5,0x3feb,0x7000c,0x13,0x4013,0x1,0x28,0x3ff5,0x3feb, + 0x7000c,0x13,0x4018,0x1,0x25,0x4009,0x400e,0x7000c,0x13,0x401d,0x1,0x28, + 0x4009,0x400e,0x7000c,0x13,0x4022,0x1,0x25,0x3fff,0x4013,0x7000c,0x13,0x4027, + 0x1,0x28,0x3fff,0x4013,0x7000c,0x13,0x402c,0x1,0x25,0x401d,0x4022,0x7000c, + 0x13,0x4031,0x1,0x28,0x401d,0x4022,0x80050,0x82,0x6fc4,0x4004,0x4018,0x402c, + 0x4031,0x4027,0x3003e,0x66ee,0x6fc4,0x50051,0x13,0x6fca,0x6fdb,0x0,0x50051,0x13, + 0x6fcb,0x6fdb,0x1,0x50051,0x13,0x6fcc,0x6fdb,0x2,0x50051,0x13,0x6fcd,0x6fdb, + 0x3,0x50051,0x13,0x6fce,0x6fdb,0x4,0x7000c,0x13,0x40d9,0x1,0x25,0x6fca, + 0x6fcd,0x7000c,0x13,0x40de,0x1,0x28,0x6fca,0x6fcd,0x7000c,0x13,0x40e3,0x1, + 0x25,0x6fcb,0x6fce,0x7000c,0x13,0x40e8,0x1,0x28,0x6fcb,0x6fce,0x7000c,0x13, + 0x40ed,0x1,0x25,0x40d9,0x6fcc,0x7000c,0x13,0x40f2,0x1,0x28,0x40d9,0x6fcc, + 0x7000c,0x13,0x40f7,0x1,0x25,0x40e3,0x40de,0x7000c,0x13,0x40fc,0x1,0x28, + 0x40e3,0x40de,0x7000c,0x13,0x4101,0x1,0x25,0x40ed,0x40f7,0x7000c,0x13,0x4106, + 0x1,0x28,0x40ed,0x40f7,0x7000c,0x13,0x410b,0x1,0x25,0x40f2,0x40e8,0x7000c, + 0x13,0x4110,0x1,0x28,0x40f2,0x40e8,0x7000c,0x13,0x4115,0x1,0x25,0x4106, + 0x410b,0x7000c,0x13,0x411a,0x1,0x28,0x4106,0x410b,0x7000c,0x13,0x411f,0x1, + 0x25,0x40fc,0x4110,0x7000c,0x13,0x4124,0x1,0x28,0x40fc,0x4110,0x7000c,0x13, + 0x4129,0x1,0x25,0x411a,0x411f,0x7000c,0x13,0x412e,0x1,0x28,0x411a,0x411f, + 0x80050,0x82,0x6fd4,0x4101,0x4115,0x4129,0x412e,0x4124,0x3003e,0x66f8,0x6fd4,0x50041, + 0x14,0x66f3,0x66ee,0x2cd,0x4003d,0x13,0x3ee8,0x66f3,0x50041,0x14,0x66fd,0x66f8, + 0x2cd,0x4003d,0x13,0x3eea,0x66fd,0x7000c,0x13,0x4133,0x1,0x25,0x3ee8,0x3eea, + 0x500ba,0x6e,0x3eed,0x4133,0x372,0x300f7,0x3f2f,0x0,0x400fa,0x3eed,0x3eee,0x3f2f, + 0x200f8,0x3eee,0x200f9,0x3eef,0x200f8,0x3eef,0x700f5,0x1a,0x8e74,0x14c,0x3eee,0x94cc, + 0x3f2b,0x700f5,0x1a,0x8e73,0x14c,0x3eee,0x94cb,0x3f2b,0x700f5,0x13,0x7b3b,0x35e, + 0x3eee,0x90f0,0x3f2b,0x700f5,0x1a,0x7b3a,0x14c,0x3eee,0x3f2d,0x3f2b,0x500b1,0x6e, + 0x3ef2,0x7b3a,0x37d,0x500b8,0x6e,0x3ef4,0x7b3b,0x380,0x500a7,0x6e,0x3ef5,0x3ef2, + 0x3ef4,0x400f6,0x3f2e,0x3f2b,0x0,0x400fa,0x3ef5,0x3ef6,0x3f2e,0x200f8,0x3ef6,0x50041, + 0x14,0x66f4,0x66ee,0x8e73,0x4003d,0x13,0x3ef9,0x66f4,0x50041,0x14,0x66fe,0x66f8, + 0x8e74,0x4003d,0x13,0x3efc,0x66fe,0x50083,0x13,0x3efd,0x3ef9,0x3efc,0x6000c,0x13, + 0x3eff,0x1,0x4,0x3efd,0x500ba,0x6e,0x3f00,0x3eff,0x38d,0x300f7,0x3f2a,0x0, + 0x400fa,0x3f00,0x3f01,0x3f29,0x200f8,0x3f29,0x200f9,0x3f2a,0x200f8,0x3f01,0x6000c,0x13, + 0x3f03,0x1,0x6,0x3efd,0x4003d,0x13,0x3f06,0x66f4,0x4003d,0x13,0x3f09,0x66fe, + 0x7000c,0x13,0x414a,0x1,0x28,0x3f06,0x3f09,0x500b7,0x6e,0x413e,0x414a,0x1d8, + 0x300f7,0x4144,0x0,0x400fa,0x413e,0x413f,0x4143,0x200f8,0x4143,0x200f9,0x4144,0x200f8, + 0x413f,0x7000c,0x13,0x414f,0x1,0x25,0x3f06,0x3f09,0x50088,0x13,0x4142,0x414f, + 0x414a,0x200f9,0x4144,0x200f8,0x4144,0x700f5,0x13,0x8e75,0x4142,0x413f,0x1d8,0x4143, + 0x50083,0x13,0x3f0b,0x1dc,0x8e75,0x50085,0x13,0x3f0c,0x3f03,0x3f0b,0x6000c,0x13, + 0x3f0e,0x1,0x4,0x3f0c,0x6000c,0x13,0x3f10,0x1,0x4,0x7b3b,0x500b8,0x6e, + 0x3f11,0x3f0e,0x3f10,0x600a9,0x13,0x3f14,0x3f11,0x3f0c,0x7b3b,0x4003d,0x13,0x3f17, + 0x66f4,0x4003d,0x13,0x3f1a,0x66fe,0x500b8,0x6e,0x3f1b,0x3f17,0x3f1a,0x600a9,0x1a, + 0x3f1c,0x3f1b,0x191,0x14c,0x50080,0x1a,0x3f1e,0x8e73,0x3f1c,0x50041,0x14,0x66f7, + 0x66ee,0x3f1e,0x4003d,0x13,0x3f21,0x66f7,0x4003d,0x13,0x3f24,0x66fe,0x500be,0x6e, + 0x3f25,0x3f21,0x3f24,0x600a9,0x1a,0x3f26,0x3f25,0x191,0x14c,0x50080,0x1a,0x3f28, + 0x8e74,0x3f26,0x200f9,0x3f2a,0x200f8,0x3f2a,0x700f5,0x1a,0x94cc,0x3f28,0x4144,0x8e74, + 0x3f29,0x700f5,0x1a,0x94cb,0x3f1e,0x4144,0x8e73,0x3f29,0x700f5,0x13,0x90f0,0x3f14, + 0x4144,0x380,0x3f29,0x200f9,0x3f2b,0x200f8,0x3f2b,0x50080,0x1a,0x3f2d,0x7b3a,0x191, + 0x200f9,0x3eef,0x200f8,0x3f2e,0x200f9,0x3f2f,0x200f8,0x3f2f,0x700f5,0x13,0x7b3c,0x35e, + 0x3d6c,0x7b3b,0x3f2e,0x500b8,0x6e,0x3f32,0x7b3c,0x35e,0x600a9,0x13,0x3f33,0x3f32, + 0x1dc,0x1d8,0x50085,0x13,0x3f34,0x7b3c,0x3f33,0x200f9,0x3d72,0x200f8,0x3d72,0x700f5, + 0x13,0x7b3d,0x1d8,0x3e5a,0x3f34,0x3f2f,0x60052,0x9f,0x96ba,0x7b3d,0x48e,0x0, + 0x500b7,0x6e,0x3d0f,0x7b3d,0x1d8,0x300f7,0x3d14,0x0,0x400fa,0x3d0f,0x3d10,0x3d13, + 0x200f8,0x3d13,0x200f9,0x3d14,0x200f8,0x3d10,0x6000c,0x13,0x3d12,0x1,0x6,0x7b3d, + 0x200f9,0x3d14,0x200f8,0x3d14,0x700f5,0x13,0x7b44,0x3d12,0x3d10,0x1d8,0x3d13,0x60052, + 0x9f,0x96bc,0x7b44,0x96ba,0x1,0x60052,0x9f,0x96be,0x1dc,0x96bc,0x2,0x50081, + 0x9f,0x4154,0x9658,0x967a,0x50081,0x9f,0x4156,0x4154,0x969c,0x50081,0x9f,0x4158, + 0x4156,0x96be,0x5008e,0x9f,0x4159,0x4158,0x4af,0x4003d,0x1e4,0x416b,0x1e6,0x50051, + 0x13,0x416e,0x4159,0x0,0x50051,0x13,0x416f,0x4159,0x1,0x70050,0x9f,0x4170, + 0x416e,0x416f,0x1d8,0x1d8,0x40063,0x416b,0xa97,0x4170,0x50050,0x32,0xaae,0xa65, + 0xa8a,0x50080,0x32,0xaaf,0xa41,0xaae,0x50050,0x32,0xaba,0xa71,0xa95,0x50080, + 0x32,0xabb,0xa4d,0xaba,0x4007c,0x2d,0xabd,0xaaf,0x50080,0x2d,0x41ae,0xabd, + 0x542,0x50080,0x2d,0x41b0,0xabd,0x545,0x50080,0x2d,0x41b2,0xabd,0x548,0x4006f, + 0x38,0x41c9,0xaaf,0x4006e,0x32,0x41f0,0x41c9,0x50051,0x1a,0x4223,0x41f0,0x0, + 0x7000c,0x1a,0x4234,0x1,0x27,0x4223,0xbc1,0x7000c,0x1a,0x4239,0x1,0x2a, + 0x14c,0x4234,0x50051,0x1a,0x422b,0x41f0,0x1,0x7000c,0x1a,0x423e,0x1,0x27, + 0x422b,0xbc9,0x7000c,0x1a,0x4243,0x1,0x2a,0x14c,0x423e,0x50050,0x32,0x978f, + 0x4239,0x4243,0x4003d,0x1b9,0x4246,0x1ca,0x7005f,0x9f,0x4248,0x4246,0x978f,0x2, + 0x14c,0x7004f,0x38,0x4249,0x4248,0x4248,0x0,0x1,0x4006f,0x38,0x41f6,0x978f, + 0x50081,0x38,0x41f8,0x41f6,0x94fd,0x50088,0x38,0x41fb,0x41f8,0xb9a,0x3003e,0x426e, + 0x3df,0x50081,0x38,0x427d,0x41fb,0xc1c,0x50085,0x38,0x4281,0x427d,0xb9a,0x6000c, + 0x38,0x4282,0x1,0x8,0x4281,0x4006e,0x32,0x4283,0x4282,0x200f9,0x4284,0x200f8, + 0x4284,0x700f5,0x1a,0x7c74,0x14c,0x3d14,0x42a3,0x4288,0x500b1,0x6e,0x4287,0x7c74, + 0x37d,0x400f6,0x42a4,0x4288,0x0,0x400fa,0x4287,0x4288,0x42a4,0x200f8,0x4288,0x50041, + 0x49,0x428c,0x426e,0x7c74,0x4003d,0x32,0x428d,0x428c,0x50080,0x32,0x42c3,0x4283, + 0x428d,0x50051,0x1a,0x42c8,0x42c3,0x0,0x7000c,0x1a,0x42d9,0x1,0x27,0x42c8, + 0xbc1,0x7000c,0x1a,0x42de,0x1,0x2a,0x14c,0x42d9,0x50051,0x1a,0x42d0,0x42c3, + 0x1,0x7000c,0x1a,0x42e3,0x1,0x27,0x42d0,0xbc9,0x7000c,0x1a,0x42e8,0x1, + 0x2a,0x14c,0x42e3,0x50050,0x32,0x979a,0x42de,0x42e8,0x4003d,0x1b9,0x42eb,0x1bb, + 0x7005f,0x9f,0x42ed,0x42eb,0x979a,0x2,0x14c,0x50051,0x13,0x42ee,0x42ed,0x0, + 0x4003d,0x1b9,0x42f2,0x1d2,0x7005f,0x9f,0x42f3,0x42f2,0x1d4,0x2,0x14c,0x50051, + 0x13,0x42f4,0x42f3,0x0,0x500b4,0x6e,0x42f6,0x42f4,0x1d8,0x600a9,0x13,0x951d, + 0x42f6,0x1dc,0x42f4,0x50085,0x13,0x4293,0x42ee,0x951d,0x50041,0x14,0x662e,0x662d, + 0x7c74,0x3003e,0x662e,0x4293,0x4003d,0x13,0x4298,0x662e,0x7000c,0x13,0x42fe,0x1, + 0x1a,0x4298,0x1dc,0x3003e,0x662e,0x42fe,0x4003d,0x13,0x429e,0x662e,0x7000c,0x13, + 0x4303,0x1,0x28,0x429e,0x38d,0x3003e,0x662e,0x4303,0x50080,0x1a,0x42a3,0x7c74, + 0x191,0x200f9,0x4284,0x200f8,0x42a4,0x4003d,0x82,0x6633,0x662d,0x3003e,0x430d,0x3df, + 0x50081,0x38,0x431b,0x41fb,0xcba,0x50081,0x38,0x431e,0x431b,0x4249,0x50051,0x13, + 0x435b,0x431e,0x0,0x500be,0x6e,0x435c,0x435b,0x1d8,0x300f7,0x4361,0x0,0x400fa, + 0x435c,0x435d,0x4361,0x200f8,0x435d,0x500bc,0x6e,0x4360,0x435b,0x1dc,0x200f9,0x4361, + 0x200f8,0x4361,0x700f5,0x6e,0x4362,0x435c,0x42a4,0x4360,0x435d,0x300f7,0x436d,0x0, + 0x400fa,0x4362,0x4363,0x436d,0x200f8,0x4363,0x50051,0x13,0x4365,0x431e,0x1,0x500be, + 0x6e,0x4366,0x4365,0x1d8,0x300f7,0x436b,0x0,0x400fa,0x4366,0x4367,0x436b,0x200f8, + 0x4367,0x500bc,0x6e,0x436a,0x4365,0x1dc,0x200f9,0x436b,0x200f8,0x436b,0x700f5,0x6e, + 0x436c,0x4366,0x4363,0x436a,0x4367,0x200f9,0x436d,0x200f8,0x436d,0x700f5,0x6e,0x436e, + 0x4362,0x4361,0x436c,0x436b,0x300f7,0x434e,0x0,0x400fa,0x436e,0x4324,0x434e,0x200f8, + 0x4324,0x50085,0x38,0x4328,0x431e,0xcb9,0x6000c,0x38,0x4329,0x1,0x8,0x4328, + 0x4006e,0x32,0x432a,0x4329,0x200f9,0x432b,0x200f8,0x432b,0x700f5,0x1a,0x7c7a,0x14c, + 0x4324,0x434c,0x432f,0x500b1,0x6e,0x432e,0x7c7a,0x37d,0x400f6,0x434d,0x432f,0x0, + 0x400fa,0x432e,0x432f,0x434d,0x200f8,0x432f,0x50041,0x49,0x4333,0x430d,0x7c7a,0x4003d, + 0x32,0x4334,0x4333,0x50080,0x32,0x4384,0x432a,0x4334,0x50051,0x1a,0x4386,0xcf7, + 0x0,0x50082,0x1a,0x4387,0x4386,0x191,0x50051,0x1a,0x4389,0x4384,0x0,0x7000c, + 0x1a,0x439a,0x1,0x27,0x4389,0x4387,0x7000c,0x1a,0x439f,0x1,0x2a,0x14c, + 0x439a,0x50051,0x1a,0x438e,0xcf7,0x1,0x50082,0x1a,0x438f,0x438e,0x191,0x50051, + 0x1a,0x4391,0x4384,0x1,0x7000c,0x1a,0x43a4,0x1,0x27,0x4391,0x438f,0x7000c, + 0x1a,0x43a9,0x1,0x2a,0x14c,0x43a4,0x50050,0x32,0x9799,0x439f,0x43a9,0x4003d, + 0x1b9,0x43ac,0x1c3,0x7005f,0x9f,0x43ae,0x43ac,0x9799,0x2,0x14c,0x50051,0x13, + 0x43af,0x43ae,0x0,0x50041,0x1a2,0x43b2,0x18b,0x20b,0x4003d,0x13,0x43b3,0x43b2, + 0x50085,0x13,0x433a,0x43af,0x43b3,0x4003d,0x1b9,0x43b7,0x1d2,0x7005f,0x9f,0x43b8, + 0x43b7,0x1d4,0x2,0x14c,0x50051,0x13,0x43b9,0x43b8,0x0,0x500b4,0x6e,0x43bb, + 0x43b9,0x1d8,0x600a9,0x13,0x951e,0x43bb,0x1dc,0x43b9,0x50085,0x13,0x433c,0x433a, + 0x951e,0x50041,0x14,0x6f86,0x6f85,0x7c7a,0x3003e,0x6f86,0x433c,0x4003d,0x13,0x4341, + 0x6f86,0x7000c,0x13,0x43c3,0x1,0x1a,0x4341,0x1dc,0x3003e,0x6f86,0x43c3,0x4003d, + 0x13,0x4347,0x6f86,0x7000c,0x13,0x43c8,0x1,0x28,0x4347,0x38d,0x3003e,0x6f86, + 0x43c8,0x50080,0x1a,0x434c,0x7c7a,0x191,0x200f9,0x432b,0x200f8,0x434d,0x200f9,0x434e, + 0x200f8,0x434e,0x4003d,0x82,0x6f8b,0x6f85,0x300f7,0x4266,0x0,0x400fa,0x436e,0x4260, + 0x4266,0x200f8,0x4260,0x50051,0x13,0x6f6a,0x6633,0x0,0x50051,0x13,0x6f6b,0x6633, + 0x1,0x50051,0x13,0x6f6c,0x6633,0x2,0x50051,0x13,0x6f6d,0x6633,0x3,0x50051, + 0x13,0x6f6e,0x6633,0x4,0x7000c,0x13,0x44d0,0x1,0x25,0x6f6a,0x6f6d,0x7000c, + 0x13,0x44d5,0x1,0x28,0x6f6a,0x6f6d,0x7000c,0x13,0x44da,0x1,0x25,0x6f6b, + 0x6f6e,0x7000c,0x13,0x44df,0x1,0x28,0x6f6b,0x6f6e,0x7000c,0x13,0x44e4,0x1, + 0x25,0x44d0,0x6f6c,0x7000c,0x13,0x44e9,0x1,0x28,0x44d0,0x6f6c,0x7000c,0x13, + 0x44ee,0x1,0x25,0x44da,0x44d5,0x7000c,0x13,0x44f3,0x1,0x28,0x44da,0x44d5, + 0x7000c,0x13,0x44f8,0x1,0x25,0x44e4,0x44ee,0x7000c,0x13,0x44fd,0x1,0x28, + 0x44e4,0x44ee,0x7000c,0x13,0x4502,0x1,0x25,0x44e9,0x44df,0x7000c,0x13,0x4507, + 0x1,0x28,0x44e9,0x44df,0x7000c,0x13,0x450c,0x1,0x25,0x44fd,0x4502,0x7000c, + 0x13,0x4511,0x1,0x28,0x44fd,0x4502,0x7000c,0x13,0x4516,0x1,0x25,0x44f3, + 0x4507,0x7000c,0x13,0x451b,0x1,0x28,0x44f3,0x4507,0x7000c,0x13,0x4520,0x1, + 0x25,0x4511,0x4516,0x7000c,0x13,0x4525,0x1,0x28,0x4511,0x4516,0x80050,0x82, + 0x6f74,0x44f8,0x450c,0x4520,0x4525,0x451b,0x3003e,0x6641,0x6f74,0x50051,0x13,0x6f7a, + 0x6f8b,0x0,0x50051,0x13,0x6f7b,0x6f8b,0x1,0x50051,0x13,0x6f7c,0x6f8b,0x2, + 0x50051,0x13,0x6f7d,0x6f8b,0x3,0x50051,0x13,0x6f7e,0x6f8b,0x4,0x7000c,0x13, + 0x45cd,0x1,0x25,0x6f7a,0x6f7d,0x7000c,0x13,0x45d2,0x1,0x28,0x6f7a,0x6f7d, + 0x7000c,0x13,0x45d7,0x1,0x25,0x6f7b,0x6f7e,0x7000c,0x13,0x45dc,0x1,0x28, + 0x6f7b,0x6f7e,0x7000c,0x13,0x45e1,0x1,0x25,0x45cd,0x6f7c,0x7000c,0x13,0x45e6, + 0x1,0x28,0x45cd,0x6f7c,0x7000c,0x13,0x45eb,0x1,0x25,0x45d7,0x45d2,0x7000c, + 0x13,0x45f0,0x1,0x28,0x45d7,0x45d2,0x7000c,0x13,0x45f5,0x1,0x25,0x45e1, + 0x45eb,0x7000c,0x13,0x45fa,0x1,0x28,0x45e1,0x45eb,0x7000c,0x13,0x45ff,0x1, + 0x25,0x45e6,0x45dc,0x7000c,0x13,0x4604,0x1,0x28,0x45e6,0x45dc,0x7000c,0x13, + 0x4609,0x1,0x25,0x45fa,0x45ff,0x7000c,0x13,0x460e,0x1,0x28,0x45fa,0x45ff, + 0x7000c,0x13,0x4613,0x1,0x25,0x45f0,0x4604,0x7000c,0x13,0x4618,0x1,0x28, + 0x45f0,0x4604,0x7000c,0x13,0x461d,0x1,0x25,0x460e,0x4613,0x7000c,0x13,0x4622, + 0x1,0x28,0x460e,0x4613,0x80050,0x82,0x6f84,0x45f5,0x4609,0x461d,0x4622,0x4618, + 0x3003e,0x664b,0x6f84,0x50041,0x14,0x6646,0x6641,0x2cd,0x4003d,0x13,0x43dc,0x6646, + 0x50041,0x14,0x6650,0x664b,0x2cd,0x4003d,0x13,0x43de,0x6650,0x7000c,0x13,0x4627, + 0x1,0x25,0x43dc,0x43de,0x500ba,0x6e,0x43e1,0x4627,0x372,0x300f7,0x4423,0x0, + 0x400fa,0x43e1,0x43e2,0x4423,0x200f8,0x43e2,0x200f9,0x43e3,0x200f8,0x43e3,0x700f5,0x1a, + 0x8e66,0x14c,0x43e2,0x94c8,0x441f,0x700f5,0x1a,0x8e65,0x14c,0x43e2,0x94c7,0x441f, + 0x700f5,0x13,0x7c9d,0x35e,0x43e2,0x9165,0x441f,0x700f5,0x1a,0x7c9c,0x14c,0x43e2, + 0x4421,0x441f,0x500b1,0x6e,0x43e6,0x7c9c,0x37d,0x500b8,0x6e,0x43e8,0x7c9d,0x380, + 0x500a7,0x6e,0x43e9,0x43e6,0x43e8,0x400f6,0x4422,0x441f,0x0,0x400fa,0x43e9,0x43ea, + 0x4422,0x200f8,0x43ea,0x50041,0x14,0x6647,0x6641,0x8e65,0x4003d,0x13,0x43ed,0x6647, + 0x50041,0x14,0x6651,0x664b,0x8e66,0x4003d,0x13,0x43f0,0x6651,0x50083,0x13,0x43f1, + 0x43ed,0x43f0,0x6000c,0x13,0x43f3,0x1,0x4,0x43f1,0x500ba,0x6e,0x43f4,0x43f3, + 0x38d,0x300f7,0x441e,0x0,0x400fa,0x43f4,0x43f5,0x441d,0x200f8,0x441d,0x200f9,0x441e, + 0x200f8,0x43f5,0x6000c,0x13,0x43f7,0x1,0x6,0x43f1,0x4003d,0x13,0x43fa,0x6647, + 0x4003d,0x13,0x43fd,0x6651,0x7000c,0x13,0x463e,0x1,0x28,0x43fa,0x43fd,0x500b7, + 0x6e,0x4632,0x463e,0x1d8,0x300f7,0x4638,0x0,0x400fa,0x4632,0x4633,0x4637,0x200f8, + 0x4637,0x200f9,0x4638,0x200f8,0x4633,0x7000c,0x13,0x4643,0x1,0x25,0x43fa,0x43fd, + 0x50088,0x13,0x4636,0x4643,0x463e,0x200f9,0x4638,0x200f8,0x4638,0x700f5,0x13,0x8e67, + 0x4636,0x4633,0x1d8,0x4637,0x50083,0x13,0x43ff,0x1dc,0x8e67,0x50085,0x13,0x4400, + 0x43f7,0x43ff,0x6000c,0x13,0x4402,0x1,0x4,0x4400,0x6000c,0x13,0x4404,0x1, + 0x4,0x7c9d,0x500b8,0x6e,0x4405,0x4402,0x4404,0x600a9,0x13,0x4408,0x4405,0x4400, + 0x7c9d,0x4003d,0x13,0x440b,0x6647,0x4003d,0x13,0x440e,0x6651,0x500b8,0x6e,0x440f, + 0x440b,0x440e,0x600a9,0x1a,0x4410,0x440f,0x191,0x14c,0x50080,0x1a,0x4412,0x8e65, + 0x4410,0x50041,0x14,0x664a,0x6641,0x4412,0x4003d,0x13,0x4415,0x664a,0x4003d,0x13, + 0x4418,0x6651,0x500be,0x6e,0x4419,0x4415,0x4418,0x600a9,0x1a,0x441a,0x4419,0x191, + 0x14c,0x50080,0x1a,0x441c,0x8e66,0x441a,0x200f9,0x441e,0x200f8,0x441e,0x700f5,0x1a, + 0x94c8,0x441c,0x4638,0x8e66,0x441d,0x700f5,0x1a,0x94c7,0x4412,0x4638,0x8e65,0x441d, + 0x700f5,0x13,0x9165,0x4408,0x4638,0x380,0x441d,0x200f9,0x441f,0x200f8,0x441f,0x50080, + 0x1a,0x4421,0x7c9c,0x191,0x200f9,0x43e3,0x200f8,0x4422,0x200f9,0x4423,0x200f8,0x4423, + 0x700f5,0x13,0x7c9e,0x35e,0x4260,0x7c9d,0x4422,0x500b8,0x6e,0x4426,0x7c9e,0x35e, + 0x600a9,0x13,0x4427,0x4426,0x1dc,0x1d8,0x50085,0x13,0x4428,0x7c9e,0x4427,0x200f9, + 0x4266,0x200f8,0x4266,0x700f5,0x13,0x7c9f,0x1d8,0x434e,0x4428,0x4423,0x60052,0x9f, + 0x96dc,0x7c9f,0x48e,0x0,0x500b7,0x6e,0x4203,0x7c9f,0x1d8,0x300f7,0x4208,0x0, + 0x400fa,0x4203,0x4204,0x4207,0x200f8,0x4207,0x200f9,0x4208,0x200f8,0x4204,0x6000c,0x13, + 0x4206,0x1,0x6,0x7c9f,0x200f9,0x4208,0x200f8,0x4208,0x700f5,0x13,0x7ca6,0x4206, + 0x4204,0x1d8,0x4207,0x60052,0x9f,0x96de,0x7ca6,0x96dc,0x1,0x60052,0x9f,0x96e0, + 0x1dc,0x96de,0x2,0x4007c,0x32,0x41cd,0x41ae,0x4006f,0x38,0x41ce,0x41cd,0x4006e, + 0x32,0x4654,0x41ce,0x50051,0x1a,0x4687,0x4654,0x0,0x7000c,0x1a,0x4698,0x1, + 0x27,0x4687,0xbc1,0x7000c,0x1a,0x469d,0x1,0x2a,0x14c,0x4698,0x50051,0x1a, + 0x468f,0x4654,0x1,0x7000c,0x1a,0x46a2,0x1,0x27,0x468f,0xbc9,0x7000c,0x1a, + 0x46a7,0x1,0x2a,0x14c,0x46a2,0x50050,0x32,0x9790,0x469d,0x46a7,0x4003d,0x1b9, + 0x46aa,0x1ca,0x7005f,0x9f,0x46ac,0x46aa,0x9790,0x2,0x14c,0x7004f,0x38,0x46ad, + 0x46ac,0x46ac,0x0,0x1,0x4006f,0x38,0x465a,0x9790,0x50081,0x38,0x465c,0x465a, + 0x94fd,0x50088,0x38,0x465f,0x465c,0xb9a,0x3003e,0x46d2,0x3df,0x50081,0x38,0x46e1, + 0x465f,0xc1c,0x50085,0x38,0x46e5,0x46e1,0xb9a,0x6000c,0x38,0x46e6,0x1,0x8, + 0x46e5,0x4006e,0x32,0x46e7,0x46e6,0x200f9,0x46e8,0x200f8,0x46e8,0x700f5,0x1a,0x7cbb, + 0x14c,0x4208,0x4707,0x46ec,0x500b1,0x6e,0x46eb,0x7cbb,0x37d,0x400f6,0x4708,0x46ec, + 0x0,0x400fa,0x46eb,0x46ec,0x4708,0x200f8,0x46ec,0x50041,0x49,0x46f0,0x46d2,0x7cbb, + 0x4003d,0x32,0x46f1,0x46f0,0x50080,0x32,0x4727,0x46e7,0x46f1,0x50051,0x1a,0x472c, + 0x4727,0x0,0x7000c,0x1a,0x473d,0x1,0x27,0x472c,0xbc1,0x7000c,0x1a,0x4742, + 0x1,0x2a,0x14c,0x473d,0x50051,0x1a,0x4734,0x4727,0x1,0x7000c,0x1a,0x4747, + 0x1,0x27,0x4734,0xbc9,0x7000c,0x1a,0x474c,0x1,0x2a,0x14c,0x4747,0x50050, + 0x32,0x9798,0x4742,0x474c,0x4003d,0x1b9,0x474f,0x1bb,0x7005f,0x9f,0x4751,0x474f, + 0x9798,0x2,0x14c,0x50051,0x13,0x4752,0x4751,0x0,0x4003d,0x1b9,0x4756,0x1d2, + 0x7005f,0x9f,0x4757,0x4756,0x1d4,0x2,0x14c,0x50051,0x13,0x4758,0x4757,0x0, + 0x500b4,0x6e,0x475a,0x4758,0x1d8,0x600a9,0x13,0x951f,0x475a,0x1dc,0x4758,0x50085, + 0x13,0x46f7,0x4752,0x951f,0x50041,0x14,0x6581,0x6580,0x7cbb,0x3003e,0x6581,0x46f7, + 0x4003d,0x13,0x46fc,0x6581,0x7000c,0x13,0x4762,0x1,0x1a,0x46fc,0x1dc,0x3003e, + 0x6581,0x4762,0x4003d,0x13,0x4702,0x6581,0x7000c,0x13,0x4767,0x1,0x28,0x4702, + 0x38d,0x3003e,0x6581,0x4767,0x50080,0x1a,0x4707,0x7cbb,0x191,0x200f9,0x46e8,0x200f8, + 0x4708,0x4003d,0x82,0x6586,0x6580,0x3003e,0x4771,0x3df,0x50081,0x38,0x477f,0x465f, + 0xcba,0x50081,0x38,0x4782,0x477f,0x46ad,0x50051,0x13,0x47bf,0x4782,0x0,0x500be, + 0x6e,0x47c0,0x47bf,0x1d8,0x300f7,0x47c5,0x0,0x400fa,0x47c0,0x47c1,0x47c5,0x200f8, + 0x47c1,0x500bc,0x6e,0x47c4,0x47bf,0x1dc,0x200f9,0x47c5,0x200f8,0x47c5,0x700f5,0x6e, + 0x47c6,0x47c0,0x4708,0x47c4,0x47c1,0x300f7,0x47d1,0x0,0x400fa,0x47c6,0x47c7,0x47d1, + 0x200f8,0x47c7,0x50051,0x13,0x47c9,0x4782,0x1,0x500be,0x6e,0x47ca,0x47c9,0x1d8, + 0x300f7,0x47cf,0x0,0x400fa,0x47ca,0x47cb,0x47cf,0x200f8,0x47cb,0x500bc,0x6e,0x47ce, + 0x47c9,0x1dc,0x200f9,0x47cf,0x200f8,0x47cf,0x700f5,0x6e,0x47d0,0x47ca,0x47c7,0x47ce, + 0x47cb,0x200f9,0x47d1,0x200f8,0x47d1,0x700f5,0x6e,0x47d2,0x47c6,0x47c5,0x47d0,0x47cf, + 0x300f7,0x47b2,0x0,0x400fa,0x47d2,0x4788,0x47b2,0x200f8,0x4788,0x50085,0x38,0x478c, + 0x4782,0xcb9,0x6000c,0x38,0x478d,0x1,0x8,0x478c,0x4006e,0x32,0x478e,0x478d, + 0x200f9,0x478f,0x200f8,0x478f,0x700f5,0x1a,0x7cc1,0x14c,0x4788,0x47b0,0x4793,0x500b1, + 0x6e,0x4792,0x7cc1,0x37d,0x400f6,0x47b1,0x4793,0x0,0x400fa,0x4792,0x4793,0x47b1, + 0x200f8,0x4793,0x50041,0x49,0x4797,0x4771,0x7cc1,0x4003d,0x32,0x4798,0x4797,0x50080, + 0x32,0x47e8,0x478e,0x4798,0x50051,0x1a,0x47ea,0xcf7,0x0,0x50082,0x1a,0x47eb, + 0x47ea,0x191,0x50051,0x1a,0x47ed,0x47e8,0x0,0x7000c,0x1a,0x47fe,0x1,0x27, + 0x47ed,0x47eb,0x7000c,0x1a,0x4803,0x1,0x2a,0x14c,0x47fe,0x50051,0x1a,0x47f2, + 0xcf7,0x1,0x50082,0x1a,0x47f3,0x47f2,0x191,0x50051,0x1a,0x47f5,0x47e8,0x1, + 0x7000c,0x1a,0x4808,0x1,0x27,0x47f5,0x47f3,0x7000c,0x1a,0x480d,0x1,0x2a, + 0x14c,0x4808,0x50050,0x32,0x9797,0x4803,0x480d,0x4003d,0x1b9,0x4810,0x1c3,0x7005f, + 0x9f,0x4812,0x4810,0x9797,0x2,0x14c,0x50051,0x13,0x4813,0x4812,0x0,0x50041, + 0x1a2,0x4816,0x18b,0x20b,0x4003d,0x13,0x4817,0x4816,0x50085,0x13,0x479e,0x4813, + 0x4817,0x4003d,0x1b9,0x481b,0x1d2,0x7005f,0x9f,0x481c,0x481b,0x1d4,0x2,0x14c, + 0x50051,0x13,0x481d,0x481c,0x0,0x500b4,0x6e,0x481f,0x481d,0x1d8,0x600a9,0x13, + 0x9520,0x481f,0x1dc,0x481d,0x50085,0x13,0x47a0,0x479e,0x9520,0x50041,0x14,0x6f36, + 0x6f35,0x7cc1,0x3003e,0x6f36,0x47a0,0x4003d,0x13,0x47a5,0x6f36,0x7000c,0x13,0x4827, + 0x1,0x1a,0x47a5,0x1dc,0x3003e,0x6f36,0x4827,0x4003d,0x13,0x47ab,0x6f36,0x7000c, + 0x13,0x482c,0x1,0x28,0x47ab,0x38d,0x3003e,0x6f36,0x482c,0x50080,0x1a,0x47b0, + 0x7cc1,0x191,0x200f9,0x478f,0x200f8,0x47b1,0x200f9,0x47b2,0x200f8,0x47b2,0x4003d,0x82, + 0x6f3b,0x6f35,0x300f7,0x46ca,0x0,0x400fa,0x47d2,0x46c4,0x46ca,0x200f8,0x46c4,0x50051, + 0x13,0x6f1a,0x6586,0x0,0x50051,0x13,0x6f1b,0x6586,0x1,0x50051,0x13,0x6f1c, + 0x6586,0x2,0x50051,0x13,0x6f1d,0x6586,0x3,0x50051,0x13,0x6f1e,0x6586,0x4, + 0x7000c,0x13,0x4934,0x1,0x25,0x6f1a,0x6f1d,0x7000c,0x13,0x4939,0x1,0x28, + 0x6f1a,0x6f1d,0x7000c,0x13,0x493e,0x1,0x25,0x6f1b,0x6f1e,0x7000c,0x13,0x4943, + 0x1,0x28,0x6f1b,0x6f1e,0x7000c,0x13,0x4948,0x1,0x25,0x4934,0x6f1c,0x7000c, + 0x13,0x494d,0x1,0x28,0x4934,0x6f1c,0x7000c,0x13,0x4952,0x1,0x25,0x493e, + 0x4939,0x7000c,0x13,0x4957,0x1,0x28,0x493e,0x4939,0x7000c,0x13,0x495c,0x1, + 0x25,0x4948,0x4952,0x7000c,0x13,0x4961,0x1,0x28,0x4948,0x4952,0x7000c,0x13, + 0x4966,0x1,0x25,0x494d,0x4943,0x7000c,0x13,0x496b,0x1,0x28,0x494d,0x4943, + 0x7000c,0x13,0x4970,0x1,0x25,0x4961,0x4966,0x7000c,0x13,0x4975,0x1,0x28, + 0x4961,0x4966,0x7000c,0x13,0x497a,0x1,0x25,0x4957,0x496b,0x7000c,0x13,0x497f, + 0x1,0x28,0x4957,0x496b,0x7000c,0x13,0x4984,0x1,0x25,0x4975,0x497a,0x7000c, + 0x13,0x4989,0x1,0x28,0x4975,0x497a,0x80050,0x82,0x6f24,0x495c,0x4970,0x4984, + 0x4989,0x497f,0x3003e,0x6594,0x6f24,0x50051,0x13,0x6f2a,0x6f3b,0x0,0x50051,0x13, + 0x6f2b,0x6f3b,0x1,0x50051,0x13,0x6f2c,0x6f3b,0x2,0x50051,0x13,0x6f2d,0x6f3b, + 0x3,0x50051,0x13,0x6f2e,0x6f3b,0x4,0x7000c,0x13,0x4a31,0x1,0x25,0x6f2a, + 0x6f2d,0x7000c,0x13,0x4a36,0x1,0x28,0x6f2a,0x6f2d,0x7000c,0x13,0x4a3b,0x1, + 0x25,0x6f2b,0x6f2e,0x7000c,0x13,0x4a40,0x1,0x28,0x6f2b,0x6f2e,0x7000c,0x13, + 0x4a45,0x1,0x25,0x4a31,0x6f2c,0x7000c,0x13,0x4a4a,0x1,0x28,0x4a31,0x6f2c, + 0x7000c,0x13,0x4a4f,0x1,0x25,0x4a3b,0x4a36,0x7000c,0x13,0x4a54,0x1,0x28, + 0x4a3b,0x4a36,0x7000c,0x13,0x4a59,0x1,0x25,0x4a45,0x4a4f,0x7000c,0x13,0x4a5e, + 0x1,0x28,0x4a45,0x4a4f,0x7000c,0x13,0x4a63,0x1,0x25,0x4a4a,0x4a40,0x7000c, + 0x13,0x4a68,0x1,0x28,0x4a4a,0x4a40,0x7000c,0x13,0x4a6d,0x1,0x25,0x4a5e, + 0x4a63,0x7000c,0x13,0x4a72,0x1,0x28,0x4a5e,0x4a63,0x7000c,0x13,0x4a77,0x1, + 0x25,0x4a54,0x4a68,0x7000c,0x13,0x4a7c,0x1,0x28,0x4a54,0x4a68,0x7000c,0x13, + 0x4a81,0x1,0x25,0x4a72,0x4a77,0x7000c,0x13,0x4a86,0x1,0x28,0x4a72,0x4a77, + 0x80050,0x82,0x6f34,0x4a59,0x4a6d,0x4a81,0x4a86,0x4a7c,0x3003e,0x659e,0x6f34,0x50041, + 0x14,0x6599,0x6594,0x2cd,0x4003d,0x13,0x4840,0x6599,0x50041,0x14,0x65a3,0x659e, + 0x2cd,0x4003d,0x13,0x4842,0x65a3,0x7000c,0x13,0x4a8b,0x1,0x25,0x4840,0x4842, + 0x500ba,0x6e,0x4845,0x4a8b,0x372,0x300f7,0x4887,0x0,0x400fa,0x4845,0x4846,0x4887, + 0x200f8,0x4846,0x200f9,0x4847,0x200f8,0x4847,0x700f5,0x1a,0x8e58,0x14c,0x4846,0x94c4, + 0x4883,0x700f5,0x1a,0x8e57,0x14c,0x4846,0x94c3,0x4883,0x700f5,0x13,0x7ce4,0x35e, + 0x4846,0x917a,0x4883,0x700f5,0x1a,0x7ce3,0x14c,0x4846,0x4885,0x4883,0x500b1,0x6e, + 0x484a,0x7ce3,0x37d,0x500b8,0x6e,0x484c,0x7ce4,0x380,0x500a7,0x6e,0x484d,0x484a, + 0x484c,0x400f6,0x4886,0x4883,0x0,0x400fa,0x484d,0x484e,0x4886,0x200f8,0x484e,0x50041, + 0x14,0x659a,0x6594,0x8e57,0x4003d,0x13,0x4851,0x659a,0x50041,0x14,0x65a4,0x659e, + 0x8e58,0x4003d,0x13,0x4854,0x65a4,0x50083,0x13,0x4855,0x4851,0x4854,0x6000c,0x13, + 0x4857,0x1,0x4,0x4855,0x500ba,0x6e,0x4858,0x4857,0x38d,0x300f7,0x4882,0x0, + 0x400fa,0x4858,0x4859,0x4881,0x200f8,0x4881,0x200f9,0x4882,0x200f8,0x4859,0x6000c,0x13, + 0x485b,0x1,0x6,0x4855,0x4003d,0x13,0x485e,0x659a,0x4003d,0x13,0x4861,0x65a4, + 0x7000c,0x13,0x4aa2,0x1,0x28,0x485e,0x4861,0x500b7,0x6e,0x4a96,0x4aa2,0x1d8, + 0x300f7,0x4a9c,0x0,0x400fa,0x4a96,0x4a97,0x4a9b,0x200f8,0x4a9b,0x200f9,0x4a9c,0x200f8, + 0x4a97,0x7000c,0x13,0x4aa7,0x1,0x25,0x485e,0x4861,0x50088,0x13,0x4a9a,0x4aa7, + 0x4aa2,0x200f9,0x4a9c,0x200f8,0x4a9c,0x700f5,0x13,0x8e59,0x4a9a,0x4a97,0x1d8,0x4a9b, + 0x50083,0x13,0x4863,0x1dc,0x8e59,0x50085,0x13,0x4864,0x485b,0x4863,0x6000c,0x13, + 0x4866,0x1,0x4,0x4864,0x6000c,0x13,0x4868,0x1,0x4,0x7ce4,0x500b8,0x6e, + 0x4869,0x4866,0x4868,0x600a9,0x13,0x486c,0x4869,0x4864,0x7ce4,0x4003d,0x13,0x486f, + 0x659a,0x4003d,0x13,0x4872,0x65a4,0x500b8,0x6e,0x4873,0x486f,0x4872,0x600a9,0x1a, + 0x4874,0x4873,0x191,0x14c,0x50080,0x1a,0x4876,0x8e57,0x4874,0x50041,0x14,0x659d, + 0x6594,0x4876,0x4003d,0x13,0x4879,0x659d,0x4003d,0x13,0x487c,0x65a4,0x500be,0x6e, + 0x487d,0x4879,0x487c,0x600a9,0x1a,0x487e,0x487d,0x191,0x14c,0x50080,0x1a,0x4880, + 0x8e58,0x487e,0x200f9,0x4882,0x200f8,0x4882,0x700f5,0x1a,0x94c4,0x4880,0x4a9c,0x8e58, + 0x4881,0x700f5,0x1a,0x94c3,0x4876,0x4a9c,0x8e57,0x4881,0x700f5,0x13,0x917a,0x486c, + 0x4a9c,0x380,0x4881,0x200f9,0x4883,0x200f8,0x4883,0x50080,0x1a,0x4885,0x7ce3,0x191, + 0x200f9,0x4847,0x200f8,0x4886,0x200f9,0x4887,0x200f8,0x4887,0x700f5,0x13,0x7ce5,0x35e, + 0x46c4,0x7ce4,0x4886,0x500b8,0x6e,0x488a,0x7ce5,0x35e,0x600a9,0x13,0x488b,0x488a, + 0x1dc,0x1d8,0x50085,0x13,0x488c,0x7ce5,0x488b,0x200f9,0x46ca,0x200f8,0x46ca,0x700f5, + 0x13,0x7ce6,0x1d8,0x47b2,0x488c,0x4887,0x60052,0x9f,0x96fe,0x7ce6,0x48e,0x0, + 0x500b7,0x6e,0x4667,0x7ce6,0x1d8,0x300f7,0x466c,0x0,0x400fa,0x4667,0x4668,0x466b, + 0x200f8,0x466b,0x200f9,0x466c,0x200f8,0x4668,0x6000c,0x13,0x466a,0x1,0x6,0x7ce6, + 0x200f9,0x466c,0x200f8,0x466c,0x700f5,0x13,0x7ced,0x466a,0x4668,0x1d8,0x466b,0x60052, + 0x9f,0x9700,0x7ced,0x96fe,0x1,0x60052,0x9f,0x9702,0x1dc,0x9700,0x2,0x4007c, + 0x32,0x41d2,0x41b0,0x4006f,0x38,0x41d3,0x41d2,0x4006e,0x32,0x4ab8,0x41d3,0x50051, + 0x1a,0x4aeb,0x4ab8,0x0,0x7000c,0x1a,0x4afc,0x1,0x27,0x4aeb,0xbc1,0x7000c, + 0x1a,0x4b01,0x1,0x2a,0x14c,0x4afc,0x50051,0x1a,0x4af3,0x4ab8,0x1,0x7000c, + 0x1a,0x4b06,0x1,0x27,0x4af3,0xbc9,0x7000c,0x1a,0x4b0b,0x1,0x2a,0x14c, + 0x4b06,0x50050,0x32,0x9791,0x4b01,0x4b0b,0x4003d,0x1b9,0x4b0e,0x1ca,0x7005f,0x9f, + 0x4b10,0x4b0e,0x9791,0x2,0x14c,0x7004f,0x38,0x4b11,0x4b10,0x4b10,0x0,0x1, + 0x4006f,0x38,0x4abe,0x9791,0x50081,0x38,0x4ac0,0x4abe,0x94fd,0x50088,0x38,0x4ac3, + 0x4ac0,0xb9a,0x3003e,0x4b36,0x3df,0x50081,0x38,0x4b45,0x4ac3,0xc1c,0x50085,0x38, + 0x4b49,0x4b45,0xb9a,0x6000c,0x38,0x4b4a,0x1,0x8,0x4b49,0x4006e,0x32,0x4b4b, + 0x4b4a,0x200f9,0x4b4c,0x200f8,0x4b4c,0x700f5,0x1a,0x7d0c,0x14c,0x466c,0x4b6b,0x4b50, + 0x500b1,0x6e,0x4b4f,0x7d0c,0x37d,0x400f6,0x4b6c,0x4b50,0x0,0x400fa,0x4b4f,0x4b50, + 0x4b6c,0x200f8,0x4b50,0x50041,0x49,0x4b54,0x4b36,0x7d0c,0x4003d,0x32,0x4b55,0x4b54, + 0x50080,0x32,0x4b8b,0x4b4b,0x4b55,0x50051,0x1a,0x4b90,0x4b8b,0x0,0x7000c,0x1a, + 0x4ba1,0x1,0x27,0x4b90,0xbc1,0x7000c,0x1a,0x4ba6,0x1,0x2a,0x14c,0x4ba1, + 0x50051,0x1a,0x4b98,0x4b8b,0x1,0x7000c,0x1a,0x4bab,0x1,0x27,0x4b98,0xbc9, + 0x7000c,0x1a,0x4bb0,0x1,0x2a,0x14c,0x4bab,0x50050,0x32,0x9796,0x4ba6,0x4bb0, + 0x4003d,0x1b9,0x4bb3,0x1bb,0x7005f,0x9f,0x4bb5,0x4bb3,0x9796,0x2,0x14c,0x50051, + 0x13,0x4bb6,0x4bb5,0x0,0x4003d,0x1b9,0x4bba,0x1d2,0x7005f,0x9f,0x4bbb,0x4bba, + 0x1d4,0x2,0x14c,0x50051,0x13,0x4bbc,0x4bbb,0x0,0x500b4,0x6e,0x4bbe,0x4bbc, + 0x1d8,0x600a9,0x13,0x9521,0x4bbe,0x1dc,0x4bbc,0x50085,0x13,0x4b5b,0x4bb6,0x9521, + 0x50041,0x14,0x64d4,0x64d3,0x7d0c,0x3003e,0x64d4,0x4b5b,0x4003d,0x13,0x4b60,0x64d4, + 0x7000c,0x13,0x4bc6,0x1,0x1a,0x4b60,0x1dc,0x3003e,0x64d4,0x4bc6,0x4003d,0x13, + 0x4b66,0x64d4,0x7000c,0x13,0x4bcb,0x1,0x28,0x4b66,0x38d,0x3003e,0x64d4,0x4bcb, + 0x50080,0x1a,0x4b6b,0x7d0c,0x191,0x200f9,0x4b4c,0x200f8,0x4b6c,0x4003d,0x82,0x64d9, + 0x64d3,0x3003e,0x4bd5,0x3df,0x50081,0x38,0x4be3,0x4ac3,0xcba,0x50081,0x38,0x4be6, + 0x4be3,0x4b11,0x50051,0x13,0x4c23,0x4be6,0x0,0x500be,0x6e,0x4c24,0x4c23,0x1d8, + 0x300f7,0x4c29,0x0,0x400fa,0x4c24,0x4c25,0x4c29,0x200f8,0x4c25,0x500bc,0x6e,0x4c28, + 0x4c23,0x1dc,0x200f9,0x4c29,0x200f8,0x4c29,0x700f5,0x6e,0x4c2a,0x4c24,0x4b6c,0x4c28, + 0x4c25,0x300f7,0x4c35,0x0,0x400fa,0x4c2a,0x4c2b,0x4c35,0x200f8,0x4c2b,0x50051,0x13, + 0x4c2d,0x4be6,0x1,0x500be,0x6e,0x4c2e,0x4c2d,0x1d8,0x300f7,0x4c33,0x0,0x400fa, + 0x4c2e,0x4c2f,0x4c33,0x200f8,0x4c2f,0x500bc,0x6e,0x4c32,0x4c2d,0x1dc,0x200f9,0x4c33, + 0x200f8,0x4c33,0x700f5,0x6e,0x4c34,0x4c2e,0x4c2b,0x4c32,0x4c2f,0x200f9,0x4c35,0x200f8, + 0x4c35,0x700f5,0x6e,0x4c36,0x4c2a,0x4c29,0x4c34,0x4c33,0x300f7,0x4c16,0x0,0x400fa, + 0x4c36,0x4bec,0x4c16,0x200f8,0x4bec,0x50085,0x38,0x4bf0,0x4be6,0xcb9,0x6000c,0x38, + 0x4bf1,0x1,0x8,0x4bf0,0x4006e,0x32,0x4bf2,0x4bf1,0x200f9,0x4bf3,0x200f8,0x4bf3, + 0x700f5,0x1a,0x7d12,0x14c,0x4bec,0x4c14,0x4bf7,0x500b1,0x6e,0x4bf6,0x7d12,0x37d, + 0x400f6,0x4c15,0x4bf7,0x0,0x400fa,0x4bf6,0x4bf7,0x4c15,0x200f8,0x4bf7,0x50041,0x49, + 0x4bfb,0x4bd5,0x7d12,0x4003d,0x32,0x4bfc,0x4bfb,0x50080,0x32,0x4c4c,0x4bf2,0x4bfc, + 0x50051,0x1a,0x4c4e,0xcf7,0x0,0x50082,0x1a,0x4c4f,0x4c4e,0x191,0x50051,0x1a, + 0x4c51,0x4c4c,0x0,0x7000c,0x1a,0x4c62,0x1,0x27,0x4c51,0x4c4f,0x7000c,0x1a, + 0x4c67,0x1,0x2a,0x14c,0x4c62,0x50051,0x1a,0x4c56,0xcf7,0x1,0x50082,0x1a, + 0x4c57,0x4c56,0x191,0x50051,0x1a,0x4c59,0x4c4c,0x1,0x7000c,0x1a,0x4c6c,0x1, + 0x27,0x4c59,0x4c57,0x7000c,0x1a,0x4c71,0x1,0x2a,0x14c,0x4c6c,0x50050,0x32, + 0x9795,0x4c67,0x4c71,0x4003d,0x1b9,0x4c74,0x1c3,0x7005f,0x9f,0x4c76,0x4c74,0x9795, + 0x2,0x14c,0x50051,0x13,0x4c77,0x4c76,0x0,0x50041,0x1a2,0x4c7a,0x18b,0x20b, + 0x4003d,0x13,0x4c7b,0x4c7a,0x50085,0x13,0x4c02,0x4c77,0x4c7b,0x4003d,0x1b9,0x4c7f, + 0x1d2,0x7005f,0x9f,0x4c80,0x4c7f,0x1d4,0x2,0x14c,0x50051,0x13,0x4c81,0x4c80, + 0x0,0x500b4,0x6e,0x4c83,0x4c81,0x1d8,0x600a9,0x13,0x9522,0x4c83,0x1dc,0x4c81, + 0x50085,0x13,0x4c04,0x4c02,0x9522,0x50041,0x14,0x6ee6,0x6ee5,0x7d12,0x3003e,0x6ee6, + 0x4c04,0x4003d,0x13,0x4c09,0x6ee6,0x7000c,0x13,0x4c8b,0x1,0x1a,0x4c09,0x1dc, + 0x3003e,0x6ee6,0x4c8b,0x4003d,0x13,0x4c0f,0x6ee6,0x7000c,0x13,0x4c90,0x1,0x28, + 0x4c0f,0x38d,0x3003e,0x6ee6,0x4c90,0x50080,0x1a,0x4c14,0x7d12,0x191,0x200f9,0x4bf3, + 0x200f8,0x4c15,0x200f9,0x4c16,0x200f8,0x4c16,0x4003d,0x82,0x6eeb,0x6ee5,0x300f7,0x4b2e, + 0x0,0x400fa,0x4c36,0x4b28,0x4b2e,0x200f8,0x4b28,0x50051,0x13,0x6eca,0x64d9,0x0, + 0x50051,0x13,0x6ecb,0x64d9,0x1,0x50051,0x13,0x6ecc,0x64d9,0x2,0x50051,0x13, + 0x6ecd,0x64d9,0x3,0x50051,0x13,0x6ece,0x64d9,0x4,0x7000c,0x13,0x4d98,0x1, + 0x25,0x6eca,0x6ecd,0x7000c,0x13,0x4d9d,0x1,0x28,0x6eca,0x6ecd,0x7000c,0x13, + 0x4da2,0x1,0x25,0x6ecb,0x6ece,0x7000c,0x13,0x4da7,0x1,0x28,0x6ecb,0x6ece, + 0x7000c,0x13,0x4dac,0x1,0x25,0x4d98,0x6ecc,0x7000c,0x13,0x4db1,0x1,0x28, + 0x4d98,0x6ecc,0x7000c,0x13,0x4db6,0x1,0x25,0x4da2,0x4d9d,0x7000c,0x13,0x4dbb, + 0x1,0x28,0x4da2,0x4d9d,0x7000c,0x13,0x4dc0,0x1,0x25,0x4dac,0x4db6,0x7000c, + 0x13,0x4dc5,0x1,0x28,0x4dac,0x4db6,0x7000c,0x13,0x4dca,0x1,0x25,0x4db1, + 0x4da7,0x7000c,0x13,0x4dcf,0x1,0x28,0x4db1,0x4da7,0x7000c,0x13,0x4dd4,0x1, + 0x25,0x4dc5,0x4dca,0x7000c,0x13,0x4dd9,0x1,0x28,0x4dc5,0x4dca,0x7000c,0x13, + 0x4dde,0x1,0x25,0x4dbb,0x4dcf,0x7000c,0x13,0x4de3,0x1,0x28,0x4dbb,0x4dcf, + 0x7000c,0x13,0x4de8,0x1,0x25,0x4dd9,0x4dde,0x7000c,0x13,0x4ded,0x1,0x28, + 0x4dd9,0x4dde,0x80050,0x82,0x6ed4,0x4dc0,0x4dd4,0x4de8,0x4ded,0x4de3,0x3003e,0x64e7, + 0x6ed4,0x50051,0x13,0x6eda,0x6eeb,0x0,0x50051,0x13,0x6edb,0x6eeb,0x1,0x50051, + 0x13,0x6edc,0x6eeb,0x2,0x50051,0x13,0x6edd,0x6eeb,0x3,0x50051,0x13,0x6ede, + 0x6eeb,0x4,0x7000c,0x13,0x4e95,0x1,0x25,0x6eda,0x6edd,0x7000c,0x13,0x4e9a, + 0x1,0x28,0x6eda,0x6edd,0x7000c,0x13,0x4e9f,0x1,0x25,0x6edb,0x6ede,0x7000c, + 0x13,0x4ea4,0x1,0x28,0x6edb,0x6ede,0x7000c,0x13,0x4ea9,0x1,0x25,0x4e95, + 0x6edc,0x7000c,0x13,0x4eae,0x1,0x28,0x4e95,0x6edc,0x7000c,0x13,0x4eb3,0x1, + 0x25,0x4e9f,0x4e9a,0x7000c,0x13,0x4eb8,0x1,0x28,0x4e9f,0x4e9a,0x7000c,0x13, + 0x4ebd,0x1,0x25,0x4ea9,0x4eb3,0x7000c,0x13,0x4ec2,0x1,0x28,0x4ea9,0x4eb3, + 0x7000c,0x13,0x4ec7,0x1,0x25,0x4eae,0x4ea4,0x7000c,0x13,0x4ecc,0x1,0x28, + 0x4eae,0x4ea4,0x7000c,0x13,0x4ed1,0x1,0x25,0x4ec2,0x4ec7,0x7000c,0x13,0x4ed6, + 0x1,0x28,0x4ec2,0x4ec7,0x7000c,0x13,0x4edb,0x1,0x25,0x4eb8,0x4ecc,0x7000c, + 0x13,0x4ee0,0x1,0x28,0x4eb8,0x4ecc,0x7000c,0x13,0x4ee5,0x1,0x25,0x4ed6, + 0x4edb,0x7000c,0x13,0x4eea,0x1,0x28,0x4ed6,0x4edb,0x80050,0x82,0x6ee4,0x4ebd, + 0x4ed1,0x4ee5,0x4eea,0x4ee0,0x3003e,0x64f1,0x6ee4,0x50041,0x14,0x64ec,0x64e7,0x2cd, + 0x4003d,0x13,0x4ca4,0x64ec,0x50041,0x14,0x64f6,0x64f1,0x2cd,0x4003d,0x13,0x4ca6, + 0x64f6,0x7000c,0x13,0x4eef,0x1,0x25,0x4ca4,0x4ca6,0x500ba,0x6e,0x4ca9,0x4eef, + 0x372,0x300f7,0x4ceb,0x0,0x400fa,0x4ca9,0x4caa,0x4ceb,0x200f8,0x4caa,0x200f9,0x4cab, + 0x200f8,0x4cab,0x700f5,0x1a,0x8e4a,0x14c,0x4caa,0x94c0,0x4ce7,0x700f5,0x1a,0x8e49, + 0x14c,0x4caa,0x94bf,0x4ce7,0x700f5,0x13,0x7d35,0x35e,0x4caa,0x9193,0x4ce7,0x700f5, + 0x1a,0x7d34,0x14c,0x4caa,0x4ce9,0x4ce7,0x500b1,0x6e,0x4cae,0x7d34,0x37d,0x500b8, + 0x6e,0x4cb0,0x7d35,0x380,0x500a7,0x6e,0x4cb1,0x4cae,0x4cb0,0x400f6,0x4cea,0x4ce7, + 0x0,0x400fa,0x4cb1,0x4cb2,0x4cea,0x200f8,0x4cb2,0x50041,0x14,0x64ed,0x64e7,0x8e49, + 0x4003d,0x13,0x4cb5,0x64ed,0x50041,0x14,0x64f7,0x64f1,0x8e4a,0x4003d,0x13,0x4cb8, + 0x64f7,0x50083,0x13,0x4cb9,0x4cb5,0x4cb8,0x6000c,0x13,0x4cbb,0x1,0x4,0x4cb9, + 0x500ba,0x6e,0x4cbc,0x4cbb,0x38d,0x300f7,0x4ce6,0x0,0x400fa,0x4cbc,0x4cbd,0x4ce5, + 0x200f8,0x4ce5,0x200f9,0x4ce6,0x200f8,0x4cbd,0x6000c,0x13,0x4cbf,0x1,0x6,0x4cb9, + 0x4003d,0x13,0x4cc2,0x64ed,0x4003d,0x13,0x4cc5,0x64f7,0x7000c,0x13,0x4f06,0x1, + 0x28,0x4cc2,0x4cc5,0x500b7,0x6e,0x4efa,0x4f06,0x1d8,0x300f7,0x4f00,0x0,0x400fa, + 0x4efa,0x4efb,0x4eff,0x200f8,0x4eff,0x200f9,0x4f00,0x200f8,0x4efb,0x7000c,0x13,0x4f0b, + 0x1,0x25,0x4cc2,0x4cc5,0x50088,0x13,0x4efe,0x4f0b,0x4f06,0x200f9,0x4f00,0x200f8, + 0x4f00,0x700f5,0x13,0x8e4b,0x4efe,0x4efb,0x1d8,0x4eff,0x50083,0x13,0x4cc7,0x1dc, + 0x8e4b,0x50085,0x13,0x4cc8,0x4cbf,0x4cc7,0x6000c,0x13,0x4cca,0x1,0x4,0x4cc8, + 0x6000c,0x13,0x4ccc,0x1,0x4,0x7d35,0x500b8,0x6e,0x4ccd,0x4cca,0x4ccc,0x600a9, + 0x13,0x4cd0,0x4ccd,0x4cc8,0x7d35,0x4003d,0x13,0x4cd3,0x64ed,0x4003d,0x13,0x4cd6, + 0x64f7,0x500b8,0x6e,0x4cd7,0x4cd3,0x4cd6,0x600a9,0x1a,0x4cd8,0x4cd7,0x191,0x14c, + 0x50080,0x1a,0x4cda,0x8e49,0x4cd8,0x50041,0x14,0x64f0,0x64e7,0x4cda,0x4003d,0x13, + 0x4cdd,0x64f0,0x4003d,0x13,0x4ce0,0x64f7,0x500be,0x6e,0x4ce1,0x4cdd,0x4ce0,0x600a9, + 0x1a,0x4ce2,0x4ce1,0x191,0x14c,0x50080,0x1a,0x4ce4,0x8e4a,0x4ce2,0x200f9,0x4ce6, + 0x200f8,0x4ce6,0x700f5,0x1a,0x94c0,0x4ce4,0x4f00,0x8e4a,0x4ce5,0x700f5,0x1a,0x94bf, + 0x4cda,0x4f00,0x8e49,0x4ce5,0x700f5,0x13,0x9193,0x4cd0,0x4f00,0x380,0x4ce5,0x200f9, + 0x4ce7,0x200f8,0x4ce7,0x50080,0x1a,0x4ce9,0x7d34,0x191,0x200f9,0x4cab,0x200f8,0x4cea, + 0x200f9,0x4ceb,0x200f8,0x4ceb,0x700f5,0x13,0x7d36,0x35e,0x4b28,0x7d35,0x4cea,0x500b8, + 0x6e,0x4cee,0x7d36,0x35e,0x600a9,0x13,0x4cef,0x4cee,0x1dc,0x1d8,0x50085,0x13, + 0x4cf0,0x7d36,0x4cef,0x200f9,0x4b2e,0x200f8,0x4b2e,0x700f5,0x13,0x7d37,0x1d8,0x4c16, + 0x4cf0,0x4ceb,0x60052,0x9f,0x9720,0x7d37,0x48e,0x0,0x500b7,0x6e,0x4acb,0x7d37, + 0x1d8,0x300f7,0x4ad0,0x0,0x400fa,0x4acb,0x4acc,0x4acf,0x200f8,0x4acf,0x200f9,0x4ad0, + 0x200f8,0x4acc,0x6000c,0x13,0x4ace,0x1,0x6,0x7d37,0x200f9,0x4ad0,0x200f8,0x4ad0, + 0x700f5,0x13,0x7d3e,0x4ace,0x4acc,0x1d8,0x4acf,0x60052,0x9f,0x9722,0x7d3e,0x9720, + 0x1,0x60052,0x9f,0x9724,0x1dc,0x9722,0x2,0x4007c,0x32,0x41d7,0x41b2,0x4006f, + 0x38,0x41d8,0x41d7,0x4006e,0x32,0x4f1c,0x41d8,0x50051,0x1a,0x4f4f,0x4f1c,0x0, + 0x7000c,0x1a,0x4f60,0x1,0x27,0x4f4f,0xbc1,0x7000c,0x1a,0x4f65,0x1,0x2a, + 0x14c,0x4f60,0x50051,0x1a,0x4f57,0x4f1c,0x1,0x7000c,0x1a,0x4f6a,0x1,0x27, + 0x4f57,0xbc9,0x7000c,0x1a,0x4f6f,0x1,0x2a,0x14c,0x4f6a,0x50050,0x32,0x9792, + 0x4f65,0x4f6f,0x4003d,0x1b9,0x4f72,0x1ca,0x7005f,0x9f,0x4f74,0x4f72,0x9792,0x2, + 0x14c,0x7004f,0x38,0x4f75,0x4f74,0x4f74,0x0,0x1,0x4006f,0x38,0x4f22,0x9792, + 0x50081,0x38,0x4f24,0x4f22,0x94fd,0x50088,0x38,0x4f27,0x4f24,0xb9a,0x3003e,0x4f9a, + 0x3df,0x50081,0x38,0x4fa9,0x4f27,0xc1c,0x50085,0x38,0x4fad,0x4fa9,0xb9a,0x6000c, + 0x38,0x4fae,0x1,0x8,0x4fad,0x4006e,0x32,0x4faf,0x4fae,0x200f9,0x4fb0,0x200f8, + 0x4fb0,0x700f5,0x1a,0x7d67,0x14c,0x4ad0,0x4fcf,0x4fb4,0x500b1,0x6e,0x4fb3,0x7d67, + 0x37d,0x400f6,0x4fd0,0x4fb4,0x0,0x400fa,0x4fb3,0x4fb4,0x4fd0,0x200f8,0x4fb4,0x50041, + 0x49,0x4fb8,0x4f9a,0x7d67,0x4003d,0x32,0x4fb9,0x4fb8,0x50080,0x32,0x4fef,0x4faf, + 0x4fb9,0x50051,0x1a,0x4ff4,0x4fef,0x0,0x7000c,0x1a,0x5005,0x1,0x27,0x4ff4, + 0xbc1,0x7000c,0x1a,0x500a,0x1,0x2a,0x14c,0x5005,0x50051,0x1a,0x4ffc,0x4fef, + 0x1,0x7000c,0x1a,0x500f,0x1,0x27,0x4ffc,0xbc9,0x7000c,0x1a,0x5014,0x1, + 0x2a,0x14c,0x500f,0x50050,0x32,0x9794,0x500a,0x5014,0x4003d,0x1b9,0x5017,0x1bb, + 0x7005f,0x9f,0x5019,0x5017,0x9794,0x2,0x14c,0x50051,0x13,0x501a,0x5019,0x0, + 0x4003d,0x1b9,0x501e,0x1d2,0x7005f,0x9f,0x501f,0x501e,0x1d4,0x2,0x14c,0x50051, + 0x13,0x5020,0x501f,0x0,0x500b4,0x6e,0x5022,0x5020,0x1d8,0x600a9,0x13,0x9523, + 0x5022,0x1dc,0x5020,0x50085,0x13,0x4fbf,0x501a,0x9523,0x50041,0x14,0x6427,0x6426, + 0x7d67,0x3003e,0x6427,0x4fbf,0x4003d,0x13,0x4fc4,0x6427,0x7000c,0x13,0x502a,0x1, + 0x1a,0x4fc4,0x1dc,0x3003e,0x6427,0x502a,0x4003d,0x13,0x4fca,0x6427,0x7000c,0x13, + 0x502f,0x1,0x28,0x4fca,0x38d,0x3003e,0x6427,0x502f,0x50080,0x1a,0x4fcf,0x7d67, + 0x191,0x200f9,0x4fb0,0x200f8,0x4fd0,0x4003d,0x82,0x642c,0x6426,0x3003e,0x5039,0x3df, + 0x50081,0x38,0x5047,0x4f27,0xcba,0x50081,0x38,0x504a,0x5047,0x4f75,0x50051,0x13, + 0x5087,0x504a,0x0,0x500be,0x6e,0x5088,0x5087,0x1d8,0x300f7,0x508d,0x0,0x400fa, + 0x5088,0x5089,0x508d,0x200f8,0x5089,0x500bc,0x6e,0x508c,0x5087,0x1dc,0x200f9,0x508d, + 0x200f8,0x508d,0x700f5,0x6e,0x508e,0x5088,0x4fd0,0x508c,0x5089,0x300f7,0x5099,0x0, + 0x400fa,0x508e,0x508f,0x5099,0x200f8,0x508f,0x50051,0x13,0x5091,0x504a,0x1,0x500be, + 0x6e,0x5092,0x5091,0x1d8,0x300f7,0x5097,0x0,0x400fa,0x5092,0x5093,0x5097,0x200f8, + 0x5093,0x500bc,0x6e,0x5096,0x5091,0x1dc,0x200f9,0x5097,0x200f8,0x5097,0x700f5,0x6e, + 0x5098,0x5092,0x508f,0x5096,0x5093,0x200f9,0x5099,0x200f8,0x5099,0x700f5,0x6e,0x509a, + 0x508e,0x508d,0x5098,0x5097,0x300f7,0x507a,0x0,0x400fa,0x509a,0x5050,0x507a,0x200f8, + 0x5050,0x50085,0x38,0x5054,0x504a,0xcb9,0x6000c,0x38,0x5055,0x1,0x8,0x5054, + 0x4006e,0x32,0x5056,0x5055,0x200f9,0x5057,0x200f8,0x5057,0x700f5,0x1a,0x7d6d,0x14c, + 0x5050,0x5078,0x505b,0x500b1,0x6e,0x505a,0x7d6d,0x37d,0x400f6,0x5079,0x505b,0x0, + 0x400fa,0x505a,0x505b,0x5079,0x200f8,0x505b,0x50041,0x49,0x505f,0x5039,0x7d6d,0x4003d, + 0x32,0x5060,0x505f,0x50080,0x32,0x50b0,0x5056,0x5060,0x50051,0x1a,0x50b2,0xcf7, + 0x0,0x50082,0x1a,0x50b3,0x50b2,0x191,0x50051,0x1a,0x50b5,0x50b0,0x0,0x7000c, + 0x1a,0x50c6,0x1,0x27,0x50b5,0x50b3,0x7000c,0x1a,0x50cb,0x1,0x2a,0x14c, + 0x50c6,0x50051,0x1a,0x50ba,0xcf7,0x1,0x50082,0x1a,0x50bb,0x50ba,0x191,0x50051, + 0x1a,0x50bd,0x50b0,0x1,0x7000c,0x1a,0x50d0,0x1,0x27,0x50bd,0x50bb,0x7000c, + 0x1a,0x50d5,0x1,0x2a,0x14c,0x50d0,0x50050,0x32,0x9793,0x50cb,0x50d5,0x4003d, + 0x1b9,0x50d8,0x1c3,0x7005f,0x9f,0x50da,0x50d8,0x9793,0x2,0x14c,0x50051,0x13, + 0x50db,0x50da,0x0,0x50041,0x1a2,0x50de,0x18b,0x20b,0x4003d,0x13,0x50df,0x50de, + 0x50085,0x13,0x5066,0x50db,0x50df,0x4003d,0x1b9,0x50e3,0x1d2,0x7005f,0x9f,0x50e4, + 0x50e3,0x1d4,0x2,0x14c,0x50051,0x13,0x50e5,0x50e4,0x0,0x500b4,0x6e,0x50e7, + 0x50e5,0x1d8,0x600a9,0x13,0x9524,0x50e7,0x1dc,0x50e5,0x50085,0x13,0x5068,0x5066, + 0x9524,0x50041,0x14,0x6e96,0x6e95,0x7d6d,0x3003e,0x6e96,0x5068,0x4003d,0x13,0x506d, + 0x6e96,0x7000c,0x13,0x50ef,0x1,0x1a,0x506d,0x1dc,0x3003e,0x6e96,0x50ef,0x4003d, + 0x13,0x5073,0x6e96,0x7000c,0x13,0x50f4,0x1,0x28,0x5073,0x38d,0x3003e,0x6e96, + 0x50f4,0x50080,0x1a,0x5078,0x7d6d,0x191,0x200f9,0x5057,0x200f8,0x5079,0x200f9,0x507a, + 0x200f8,0x507a,0x4003d,0x82,0x6e9b,0x6e95,0x300f7,0x4f92,0x0,0x400fa,0x509a,0x4f8c, + 0x4f92,0x200f8,0x4f8c,0x50051,0x13,0x6e7a,0x642c,0x0,0x50051,0x13,0x6e7b,0x642c, + 0x1,0x50051,0x13,0x6e7c,0x642c,0x2,0x50051,0x13,0x6e7d,0x642c,0x3,0x50051, + 0x13,0x6e7e,0x642c,0x4,0x7000c,0x13,0x51fc,0x1,0x25,0x6e7a,0x6e7d,0x7000c, + 0x13,0x5201,0x1,0x28,0x6e7a,0x6e7d,0x7000c,0x13,0x5206,0x1,0x25,0x6e7b, + 0x6e7e,0x7000c,0x13,0x520b,0x1,0x28,0x6e7b,0x6e7e,0x7000c,0x13,0x5210,0x1, + 0x25,0x51fc,0x6e7c,0x7000c,0x13,0x5215,0x1,0x28,0x51fc,0x6e7c,0x7000c,0x13, + 0x521a,0x1,0x25,0x5206,0x5201,0x7000c,0x13,0x521f,0x1,0x28,0x5206,0x5201, + 0x7000c,0x13,0x5224,0x1,0x25,0x5210,0x521a,0x7000c,0x13,0x5229,0x1,0x28, + 0x5210,0x521a,0x7000c,0x13,0x522e,0x1,0x25,0x5215,0x520b,0x7000c,0x13,0x5233, + 0x1,0x28,0x5215,0x520b,0x7000c,0x13,0x5238,0x1,0x25,0x5229,0x522e,0x7000c, + 0x13,0x523d,0x1,0x28,0x5229,0x522e,0x7000c,0x13,0x5242,0x1,0x25,0x521f, + 0x5233,0x7000c,0x13,0x5247,0x1,0x28,0x521f,0x5233,0x7000c,0x13,0x524c,0x1, + 0x25,0x523d,0x5242,0x7000c,0x13,0x5251,0x1,0x28,0x523d,0x5242,0x80050,0x82, + 0x6e84,0x5224,0x5238,0x524c,0x5251,0x5247,0x3003e,0x643a,0x6e84,0x50051,0x13,0x6e8a, + 0x6e9b,0x0,0x50051,0x13,0x6e8b,0x6e9b,0x1,0x50051,0x13,0x6e8c,0x6e9b,0x2, + 0x50051,0x13,0x6e8d,0x6e9b,0x3,0x50051,0x13,0x6e8e,0x6e9b,0x4,0x7000c,0x13, + 0x52f9,0x1,0x25,0x6e8a,0x6e8d,0x7000c,0x13,0x52fe,0x1,0x28,0x6e8a,0x6e8d, + 0x7000c,0x13,0x5303,0x1,0x25,0x6e8b,0x6e8e,0x7000c,0x13,0x5308,0x1,0x28, + 0x6e8b,0x6e8e,0x7000c,0x13,0x530d,0x1,0x25,0x52f9,0x6e8c,0x7000c,0x13,0x5312, + 0x1,0x28,0x52f9,0x6e8c,0x7000c,0x13,0x5317,0x1,0x25,0x5303,0x52fe,0x7000c, + 0x13,0x531c,0x1,0x28,0x5303,0x52fe,0x7000c,0x13,0x5321,0x1,0x25,0x530d, + 0x5317,0x7000c,0x13,0x5326,0x1,0x28,0x530d,0x5317,0x7000c,0x13,0x532b,0x1, + 0x25,0x5312,0x5308,0x7000c,0x13,0x5330,0x1,0x28,0x5312,0x5308,0x7000c,0x13, + 0x5335,0x1,0x25,0x5326,0x532b,0x7000c,0x13,0x533a,0x1,0x28,0x5326,0x532b, + 0x7000c,0x13,0x533f,0x1,0x25,0x531c,0x5330,0x7000c,0x13,0x5344,0x1,0x28, + 0x531c,0x5330,0x7000c,0x13,0x5349,0x1,0x25,0x533a,0x533f,0x7000c,0x13,0x534e, + 0x1,0x28,0x533a,0x533f,0x80050,0x82,0x6e94,0x5321,0x5335,0x5349,0x534e,0x5344, + 0x3003e,0x6444,0x6e94,0x50041,0x14,0x643f,0x643a,0x2cd,0x4003d,0x13,0x5108,0x643f, + 0x50041,0x14,0x6449,0x6444,0x2cd,0x4003d,0x13,0x510a,0x6449,0x7000c,0x13,0x5353, + 0x1,0x25,0x5108,0x510a,0x500ba,0x6e,0x510d,0x5353,0x372,0x300f7,0x514f,0x0, + 0x400fa,0x510d,0x510e,0x514f,0x200f8,0x510e,0x200f9,0x510f,0x200f8,0x510f,0x700f5,0x1a, + 0x8e3c,0x14c,0x510e,0x94bc,0x514b,0x700f5,0x1a,0x8e3b,0x14c,0x510e,0x94bb,0x514b, + 0x700f5,0x13,0x7d90,0x35e,0x510e,0x91b0,0x514b,0x700f5,0x1a,0x7d8f,0x14c,0x510e, + 0x514d,0x514b,0x500b1,0x6e,0x5112,0x7d8f,0x37d,0x500b8,0x6e,0x5114,0x7d90,0x380, + 0x500a7,0x6e,0x5115,0x5112,0x5114,0x400f6,0x514e,0x514b,0x0,0x400fa,0x5115,0x5116, + 0x514e,0x200f8,0x5116,0x50041,0x14,0x6440,0x643a,0x8e3b,0x4003d,0x13,0x5119,0x6440, + 0x50041,0x14,0x644a,0x6444,0x8e3c,0x4003d,0x13,0x511c,0x644a,0x50083,0x13,0x511d, + 0x5119,0x511c,0x6000c,0x13,0x511f,0x1,0x4,0x511d,0x500ba,0x6e,0x5120,0x511f, + 0x38d,0x300f7,0x514a,0x0,0x400fa,0x5120,0x5121,0x5149,0x200f8,0x5149,0x200f9,0x514a, + 0x200f8,0x5121,0x6000c,0x13,0x5123,0x1,0x6,0x511d,0x4003d,0x13,0x5126,0x6440, + 0x4003d,0x13,0x5129,0x644a,0x7000c,0x13,0x536a,0x1,0x28,0x5126,0x5129,0x500b7, + 0x6e,0x535e,0x536a,0x1d8,0x300f7,0x5364,0x0,0x400fa,0x535e,0x535f,0x5363,0x200f8, + 0x5363,0x200f9,0x5364,0x200f8,0x535f,0x7000c,0x13,0x536f,0x1,0x25,0x5126,0x5129, + 0x50088,0x13,0x5362,0x536f,0x536a,0x200f9,0x5364,0x200f8,0x5364,0x700f5,0x13,0x8e3d, + 0x5362,0x535f,0x1d8,0x5363,0x50083,0x13,0x512b,0x1dc,0x8e3d,0x50085,0x13,0x512c, + 0x5123,0x512b,0x6000c,0x13,0x512e,0x1,0x4,0x512c,0x6000c,0x13,0x5130,0x1, + 0x4,0x7d90,0x500b8,0x6e,0x5131,0x512e,0x5130,0x600a9,0x13,0x5134,0x5131,0x512c, + 0x7d90,0x4003d,0x13,0x5137,0x6440,0x4003d,0x13,0x513a,0x644a,0x500b8,0x6e,0x513b, + 0x5137,0x513a,0x600a9,0x1a,0x513c,0x513b,0x191,0x14c,0x50080,0x1a,0x513e,0x8e3b, + 0x513c,0x50041,0x14,0x6443,0x643a,0x513e,0x4003d,0x13,0x5141,0x6443,0x4003d,0x13, + 0x5144,0x644a,0x500be,0x6e,0x5145,0x5141,0x5144,0x600a9,0x1a,0x5146,0x5145,0x191, + 0x14c,0x50080,0x1a,0x5148,0x8e3c,0x5146,0x200f9,0x514a,0x200f8,0x514a,0x700f5,0x1a, + 0x94bc,0x5148,0x5364,0x8e3c,0x5149,0x700f5,0x1a,0x94bb,0x513e,0x5364,0x8e3b,0x5149, + 0x700f5,0x13,0x91b0,0x5134,0x5364,0x380,0x5149,0x200f9,0x514b,0x200f8,0x514b,0x50080, + 0x1a,0x514d,0x7d8f,0x191,0x200f9,0x510f,0x200f8,0x514e,0x200f9,0x514f,0x200f8,0x514f, + 0x700f5,0x13,0x7d91,0x35e,0x4f8c,0x7d90,0x514e,0x500b8,0x6e,0x5152,0x7d91,0x35e, + 0x600a9,0x13,0x5153,0x5152,0x1dc,0x1d8,0x50085,0x13,0x5154,0x7d91,0x5153,0x200f9, + 0x4f92,0x200f8,0x4f92,0x700f5,0x13,0x7d92,0x1d8,0x507a,0x5154,0x514f,0x60052,0x9f, + 0x9742,0x7d92,0x48e,0x0,0x500b7,0x6e,0x4f2f,0x7d92,0x1d8,0x300f7,0x4f34,0x0, + 0x400fa,0x4f2f,0x4f30,0x4f33,0x200f8,0x4f33,0x200f9,0x4f34,0x200f8,0x4f30,0x6000c,0x13, + 0x4f32,0x1,0x6,0x7d92,0x200f9,0x4f34,0x200f8,0x4f34,0x700f5,0x13,0x7d99,0x4f32, + 0x4f30,0x1d8,0x4f33,0x60052,0x9f,0x9744,0x7d99,0x9742,0x1,0x60052,0x9f,0x9746, + 0x1dc,0x9744,0x2,0x50081,0x9f,0x5374,0x96e0,0x9702,0x50081,0x9f,0x5376,0x5374, + 0x9724,0x50081,0x9f,0x5378,0x5376,0x9746,0x5008e,0x9f,0x5379,0x5378,0x4af,0x4003d, + 0x1e4,0x538b,0x1e6,0x50051,0x13,0x538e,0x5379,0x0,0x50051,0x13,0x538f,0x5379, + 0x1,0x70050,0x9f,0x5390,0x538e,0x538f,0x1d8,0x1d8,0x40063,0x538b,0xabb,0x5390, + 0x500b2,0x6e,0xac7,0x941,0x172,0x300f7,0xac9,0x0,0x400fa,0xac7,0xac8,0xac9, + 0x200f8,0xac8,0x200f9,0xb43,0x200f8,0xac9,0x6016e,0x9f,0x53d0,0x16c,0x1d19,0x1bf, + 0x6016e,0x9f,0x53d2,0x16c,0x1d19,0x172,0x6016e,0x9f,0x53d4,0x16c,0x1d19,0x16b, + 0x50081,0x9f,0x53de,0x1d19,0x53d0,0x50081,0x9f,0x53e0,0x53de,0x53d2,0x50081,0x9f, + 0x53e2,0x53e0,0x53d4,0x5008e,0x9f,0x53e3,0x53e2,0x4af,0x6016e,0x9f,0x53f0,0x16c, + 0x2f39,0x1bf,0x6016e,0x9f,0x53f2,0x16c,0x2f39,0x172,0x6016e,0x9f,0x53f4,0x16c, + 0x2f39,0x16b,0x50081,0x9f,0x53fe,0x2f39,0x53f0,0x50081,0x9f,0x5400,0x53fe,0x53f2, + 0x50081,0x9f,0x5402,0x5400,0x53f4,0x5008e,0x9f,0x5403,0x5402,0x4af,0x6016e,0x9f, + 0x5410,0x16c,0x4159,0x1bf,0x6016e,0x9f,0x5412,0x16c,0x4159,0x172,0x6016e,0x9f, + 0x5414,0x16c,0x4159,0x16b,0x50081,0x9f,0x541e,0x4159,0x5410,0x50081,0x9f,0x5420, + 0x541e,0x5412,0x50081,0x9f,0x5422,0x5420,0x5414,0x5008e,0x9f,0x5423,0x5422,0x4af, + 0x6016e,0x9f,0x5430,0x16c,0x5379,0x1bf,0x6016e,0x9f,0x5432,0x16c,0x5379,0x172, + 0x6016e,0x9f,0x5434,0x16c,0x5379,0x16b,0x50081,0x9f,0x543e,0x5379,0x5430,0x50081, + 0x9f,0x5440,0x543e,0x5432,0x50081,0x9f,0x5442,0x5440,0x5434,0x5008e,0x9f,0x5443, + 0x5442,0x4af,0x50089,0x6,0xadb,0x90b,0x20b,0x500aa,0x6e,0xadc,0xadb,0x1bf, + 0x300f7,0xb42,0x0,0x400fa,0xadc,0xadd,0xb42,0x200f8,0xadd,0x50084,0x2d,0xae0, + 0x952,0x94fe,0x4007c,0x32,0xae1,0xae0,0x50086,0x6,0xae3,0x984,0x16b,0x4007c, + 0x1a,0xae4,0xae3,0x50086,0x6,0xae6,0x98a,0x16b,0x4007c,0x1a,0xae7,0xae6, + 0x50050,0x32,0xae8,0xae4,0xae7,0x50080,0x32,0xae9,0xae1,0xae8,0x4003d,0x1e4, + 0x545f,0x1f0,0x50051,0x13,0x5462,0x53e3,0x0,0x50051,0x13,0x5463,0x53e3,0x1, + 0x70050,0x9f,0x5464,0x5462,0x5463,0x1d8,0x1d8,0x40063,0x545f,0xae9,0x5464,0x60041, + 0x4c6,0x5493,0x4c3,0xae3,0xae6,0x3003e,0x5493,0x5462,0x60041,0x4c6,0x5498,0x4c9, + 0xae3,0xae6,0x3003e,0x5498,0x5463,0x50051,0x13,0x549c,0x53e3,0x2,0x60041,0x4c6, + 0x549d,0x4ce,0xae3,0xae6,0x3003e,0x549d,0x549c,0x50051,0x13,0x54a1,0x53e3,0x3, + 0x60041,0x4c6,0x54a2,0x4d3,0xae3,0xae6,0x3003e,0x54a2,0x54a1,0x50080,0x6,0xafb, + 0xae3,0x678,0x4007c,0x1a,0xafc,0xafb,0x50050,0x32,0xb00,0xafc,0xae7,0x50080, + 0x32,0xb01,0xae1,0xb00,0x4003d,0x1e4,0x54be,0x1f0,0x50051,0x13,0x54c1,0x5403, + 0x0,0x50051,0x13,0x54c2,0x5403,0x1,0x70050,0x9f,0x54c3,0x54c1,0x54c2,0x1d8, + 0x1d8,0x40063,0x54be,0xb01,0x54c3,0x60041,0x4c6,0x54f2,0x4c3,0xafb,0xae6,0x3003e, + 0x54f2,0x54c1,0x60041,0x4c6,0x54f7,0x4c9,0xafb,0xae6,0x3003e,0x54f7,0x54c2,0x50051, + 0x13,0x54fb,0x5403,0x2,0x60041,0x4c6,0x54fc,0x4ce,0xafb,0xae6,0x3003e,0x54fc, + 0x54fb,0x50051,0x13,0x5500,0x5403,0x3,0x60041,0x4c6,0x5501,0x4d3,0xafb,0xae6, + 0x3003e,0x5501,0x5500,0x50080,0x6,0xb17,0xae6,0x678,0x4007c,0x1a,0xb18,0xb17, + 0x50050,0x32,0xb19,0xae4,0xb18,0x50080,0x32,0xb1a,0xae1,0xb19,0x4003d,0x1e4, + 0x551d,0x1f0,0x50051,0x13,0x5520,0x5423,0x0,0x50051,0x13,0x5521,0x5423,0x1, + 0x70050,0x9f,0x5522,0x5520,0x5521,0x1d8,0x1d8,0x40063,0x551d,0xb1a,0x5522,0x60041, + 0x4c6,0x5551,0x4c3,0xae3,0xb17,0x3003e,0x5551,0x5520,0x60041,0x4c6,0x5556,0x4c9, + 0xae3,0xb17,0x3003e,0x5556,0x5521,0x50051,0x13,0x555a,0x5423,0x2,0x60041,0x4c6, + 0x555b,0x4ce,0xae3,0xb17,0x3003e,0x555b,0x555a,0x50051,0x13,0x555f,0x5423,0x3, + 0x60041,0x4c6,0x5560,0x4d3,0xae3,0xb17,0x3003e,0x5560,0x555f,0x50050,0x32,0xb33, + 0xafc,0xb18,0x50080,0x32,0xb34,0xae1,0xb33,0x4003d,0x1e4,0x557c,0x1f0,0x50051, + 0x13,0x557f,0x5443,0x0,0x50051,0x13,0x5580,0x5443,0x1,0x70050,0x9f,0x5581, + 0x557f,0x5580,0x1d8,0x1d8,0x40063,0x557c,0xb34,0x5581,0x60041,0x4c6,0x55b0,0x4c3, + 0xafb,0xb17,0x3003e,0x55b0,0x557f,0x60041,0x4c6,0x55b5,0x4c9,0xafb,0xb17,0x3003e, + 0x55b5,0x5580,0x50051,0x13,0x55b9,0x5443,0x2,0x60041,0x4c6,0x55ba,0x4ce,0xafb, + 0xb17,0x3003e,0x55ba,0x55b9,0x50051,0x13,0x55be,0x5443,0x3,0x60041,0x4c6,0x55bf, + 0x4d3,0xafb,0xb17,0x3003e,0x55bf,0x55be,0x200f9,0xb42,0x200f8,0xb42,0x200f9,0xb43, + 0x200f8,0xb43,0x300f7,0x5611,0x0,0x300fb,0x1bf,0x55d8,0x200f8,0x55d8,0x500b2,0x6e, + 0x55db,0x941,0x16b,0x300f7,0x55dd,0x0,0x400fa,0x55db,0x55dc,0x55dd,0x200f8,0x55dc, + 0x200f9,0x5611,0x200f8,0x55dd,0x300e1,0x16b,0x4ef,0x400e0,0x16b,0x16b,0x4f0,0x60041, + 0x4c6,0x5645,0x4c3,0x984,0x98a,0x4003d,0x13,0x5646,0x5645,0x60041,0x4c6,0x5649, + 0x4c9,0x984,0x98a,0x4003d,0x13,0x564a,0x5649,0x60041,0x4c6,0x564d,0x4ce,0x984, + 0x98a,0x4003d,0x13,0x564e,0x564d,0x60041,0x4c6,0x5651,0x4d3,0x984,0x98a,0x4003d, + 0x13,0x5652,0x5651,0x70050,0x9f,0x5653,0x5646,0x564a,0x564e,0x5652,0x6016e,0x9f, + 0x5660,0x16c,0x5653,0x1bf,0x6016e,0x9f,0x5662,0x16c,0x5653,0x172,0x6016e,0x9f, + 0x5664,0x16c,0x5653,0x16b,0x50081,0x9f,0x566e,0x5653,0x5660,0x50081,0x9f,0x5670, + 0x566e,0x5662,0x50081,0x9f,0x5672,0x5670,0x5664,0x5008e,0x9f,0x5673,0x5672,0x4af, + 0x50089,0x6,0x5625,0x90b,0x20b,0x500aa,0x6e,0x5626,0x5625,0x1bf,0x300f7,0x5640, + 0x0,0x400fa,0x5626,0x5627,0x5640,0x200f8,0x5627,0x50084,0x2d,0x562a,0x952,0x94ff, + 0x4007c,0x32,0x562b,0x562a,0x50086,0x6,0x562d,0x984,0x16b,0x4007c,0x1a,0x562e, + 0x562d,0x50086,0x6,0x5630,0x98a,0x16b,0x4007c,0x1a,0x5631,0x5630,0x50050,0x32, + 0x5632,0x562e,0x5631,0x50080,0x32,0x5633,0x562b,0x5632,0x4003d,0x1e4,0x5699,0x1fa, + 0x50051,0x13,0x569c,0x5673,0x0,0x50051,0x13,0x569d,0x5673,0x1,0x70050,0x9f, + 0x569e,0x569c,0x569d,0x1d8,0x1d8,0x40063,0x5699,0x5633,0x569e,0x50089,0x6,0x563b, + 0x5630,0x16b,0x50080,0x6,0x563c,0x984,0x563b,0x60041,0x4c6,0x56c3,0x4c3,0x563c, + 0x98a,0x3003e,0x56c3,0x569c,0x60041,0x4c6,0x56c8,0x4c9,0x563c,0x98a,0x3003e,0x56c8, + 0x569d,0x50051,0x13,0x56cc,0x5673,0x2,0x60041,0x4c6,0x56cd,0x4ce,0x563c,0x98a, + 0x3003e,0x56cd,0x56cc,0x50051,0x13,0x56d1,0x5673,0x3,0x60041,0x4c6,0x56d2,0x4d3, + 0x563c,0x98a,0x3003e,0x56d2,0x56d1,0x200f9,0x5640,0x200f8,0x5640,0x500b2,0x6e,0x55e9, + 0x941,0x16c,0x300f7,0x55eb,0x0,0x400fa,0x55e9,0x55ea,0x55eb,0x200f8,0x55ea,0x200f9, + 0x5611,0x200f8,0x55eb,0x300e1,0x16b,0x4ef,0x400e0,0x16b,0x16b,0x4f0,0x500b0,0x6e, + 0x56e1,0x90b,0x591,0x300f7,0x570b,0x0,0x400fa,0x56e1,0x56e2,0x570b,0x200f8,0x56e2, + 0x50089,0x6,0x56e6,0x98a,0x16b,0x50080,0x6,0x56e7,0xa43,0x56e6,0x60041,0x4c6, + 0x5710,0x4c3,0x56e7,0xa46,0x4003d,0x13,0x5711,0x5710,0x60041,0x4c6,0x5714,0x4c9, + 0x56e7,0xa46,0x4003d,0x13,0x5715,0x5714,0x60041,0x4c6,0x5718,0x4ce,0x56e7,0xa46, + 0x4003d,0x13,0x5719,0x5718,0x60041,0x4c6,0x571c,0x4d3,0x56e7,0xa46,0x4003d,0x13, + 0x571d,0x571c,0x70050,0x9f,0x571e,0x5711,0x5715,0x5719,0x571d,0x6016e,0x9f,0x572b, + 0x16c,0x571e,0x1bf,0x6016e,0x9f,0x572d,0x16c,0x571e,0x172,0x6016e,0x9f,0x572f, + 0x16c,0x571e,0x16b,0x50081,0x9f,0x5739,0x571e,0x572b,0x50081,0x9f,0x573b,0x5739, + 0x572d,0x50081,0x9f,0x573d,0x573b,0x572f,0x5008e,0x9f,0x573e,0x573d,0x4af,0x300f7, + 0x570a,0x0,0x400fa,0x5626,0x56f0,0x570a,0x200f8,0x56f0,0x50084,0x2d,0x56f3,0x952, + 0x9500,0x4007c,0x32,0x56f4,0x56f3,0x50086,0x6,0x56f6,0x984,0x16b,0x4007c,0x1a, + 0x56f7,0x56f6,0x50086,0x6,0x56f9,0x98a,0x16b,0x4007c,0x1a,0x56fa,0x56f9,0x50050, + 0x32,0x56fb,0x56f7,0x56fa,0x50080,0x32,0x56fc,0x56f4,0x56fb,0x4003d,0x1e4,0x576e, + 0x204,0x50051,0x13,0x5771,0x573e,0x0,0x50051,0x13,0x5772,0x573e,0x1,0x70050, + 0x9f,0x5773,0x5771,0x5772,0x1d8,0x1d8,0x40063,0x576e,0x56fc,0x5773,0x50080,0x6, + 0x5705,0xa43,0x56f9,0x60041,0x4c6,0x578e,0x4c3,0x5705,0xa46,0x3003e,0x578e,0x5771, + 0x60041,0x4c6,0x5793,0x4c9,0x5705,0xa46,0x3003e,0x5793,0x5772,0x50051,0x13,0x5797, + 0x573e,0x2,0x60041,0x4c6,0x5798,0x4ce,0x5705,0xa46,0x3003e,0x5798,0x5797,0x50051, + 0x13,0x579c,0x573e,0x3,0x60041,0x4c6,0x579d,0x4d3,0x5705,0xa46,0x3003e,0x579d, + 0x579c,0x200f9,0x570a,0x200f8,0x570a,0x200f9,0x570b,0x200f8,0x570b,0x500b2,0x6e,0x55f8, + 0x941,0x20b,0x300f7,0x55fa,0x0,0x400fa,0x55f8,0x55f9,0x55fa,0x200f8,0x55f9,0x200f9, + 0x5611,0x200f8,0x55fa,0x300e1,0x16b,0x4ef,0x400e0,0x16b,0x16b,0x4f0,0x500b0,0x6e, + 0x57ac,0x90b,0x4bf,0x300f7,0x57d2,0x0,0x400fa,0x57ac,0x57ad,0x57d2,0x200f8,0x57ad, + 0x50084,0x6,0x57af,0x984,0x20b,0x50080,0x6,0x57b1,0x57af,0x98a,0x50084,0x6, + 0x57b3,0x98a,0x20b,0x60041,0x4c6,0x57d7,0x4c3,0x57b1,0x57b3,0x4003d,0x13,0x57d8, + 0x57d7,0x60041,0x4c6,0x57db,0x4c9,0x57b1,0x57b3,0x4003d,0x13,0x57dc,0x57db,0x60041, + 0x4c6,0x57df,0x4ce,0x57b1,0x57b3,0x4003d,0x13,0x57e0,0x57df,0x60041,0x4c6,0x57e3, + 0x4d3,0x57b1,0x57b3,0x4003d,0x13,0x57e4,0x57e3,0x70050,0x9f,0x57e5,0x57d8,0x57dc, + 0x57e0,0x57e4,0x6016e,0x9f,0x57f2,0x16c,0x57e5,0x1bf,0x6016e,0x9f,0x57f4,0x16c, + 0x57e5,0x172,0x6016e,0x9f,0x57f6,0x16c,0x57e5,0x16b,0x50081,0x9f,0x5800,0x57e5, + 0x57f2,0x50081,0x9f,0x5802,0x5800,0x57f4,0x50081,0x9f,0x5804,0x5802,0x57f6,0x5008e, + 0x9f,0x5805,0x5804,0x4af,0x300f7,0x57d1,0x0,0x400fa,0x5626,0x57ba,0x57d1,0x200f8, + 0x57ba,0x50084,0x2d,0x57bd,0x952,0x9501,0x4007c,0x32,0x57be,0x57bd,0x50086,0x6, + 0x57c0,0x984,0x16b,0x4007c,0x1a,0x57c1,0x57c0,0x50086,0x6,0x57c3,0x98a,0x16b, + 0x4007c,0x1a,0x57c4,0x57c3,0x50050,0x32,0x57c5,0x57c1,0x57c4,0x50080,0x32,0x57c6, + 0x57be,0x57c5,0x4003d,0x1e4,0x583f,0x20f,0x50051,0x13,0x5842,0x5805,0x0,0x50051, + 0x13,0x5843,0x5805,0x1,0x70050,0x9f,0x5844,0x5842,0x5843,0x1d8,0x1d8,0x40063, + 0x583f,0x57c6,0x5844,0x50080,0x6,0x57ce,0x57c0,0x98a,0x60041,0x4c6,0x5855,0x4c3, + 0x57ce,0x1bf,0x3003e,0x5855,0x5842,0x60041,0x4c6,0x585a,0x4c9,0x57ce,0x1bf,0x3003e, + 0x585a,0x5843,0x50051,0x13,0x585e,0x5805,0x2,0x60041,0x4c6,0x585f,0x4ce,0x57ce, + 0x1bf,0x3003e,0x585f,0x585e,0x50051,0x13,0x5863,0x5805,0x3,0x60041,0x4c6,0x5864, + 0x4d3,0x57ce,0x1bf,0x3003e,0x5864,0x5863,0x200f9,0x57d1,0x200f8,0x57d1,0x200f9,0x57d2, + 0x200f8,0x57d2,0x500b2,0x6e,0x5607,0x941,0x81,0x300f7,0x5609,0x0,0x400fa,0x5607, + 0x5608,0x5609,0x200f8,0x5608,0x200f9,0x5611,0x200f8,0x5609,0x300e1,0x16b,0x4ef,0x400e0, + 0x16b,0x16b,0x4f0,0x500b0,0x6e,0x5870,0x90b,0x20b,0x300f7,0x5881,0x0,0x400fa, + 0x5870,0x5871,0x5881,0x200f8,0x5871,0x60041,0x4c6,0x5886,0x4c3,0x90b,0x1bf,0x4003d, + 0x13,0x5887,0x5886,0x60041,0x4c6,0x588a,0x4c9,0x90b,0x1bf,0x4003d,0x13,0x588b, + 0x588a,0x60041,0x4c6,0x588e,0x4ce,0x90b,0x1bf,0x4003d,0x13,0x588f,0x588e,0x60041, + 0x4c6,0x5892,0x4d3,0x90b,0x1bf,0x4003d,0x13,0x5893,0x5892,0x70050,0x9f,0x5894, + 0x5887,0x588b,0x588f,0x5893,0x6016e,0x9f,0x58a1,0x16c,0x5894,0x1bf,0x6016e,0x9f, + 0x58a3,0x16c,0x5894,0x172,0x6016e,0x9f,0x58a5,0x16c,0x5894,0x16b,0x50081,0x9f, + 0x58af,0x5894,0x58a1,0x50081,0x9f,0x58b1,0x58af,0x58a3,0x50081,0x9f,0x58b3,0x58b1, + 0x58a5,0x5008e,0x9f,0x58b4,0x58b3,0x4af,0x300f7,0x5880,0x0,0x400fa,0x5626,0x5879, + 0x5880,0x200f8,0x5879,0x4007c,0x32,0x587b,0x952,0x4003d,0x1e4,0x58f8,0x219,0x50051, + 0x13,0x58fb,0x58b4,0x0,0x50051,0x13,0x58fc,0x58b4,0x1,0x70050,0x9f,0x58fd, + 0x58fb,0x58fc,0x1d8,0x1d8,0x40063,0x58f8,0x587b,0x58fd,0x200f9,0x5880,0x200f8,0x5880, + 0x200f9,0x5881,0x200f8,0x5881,0x200f9,0x5611,0x200f8,0x5611,0x500b2,0x6e,0x99a,0x941, + 0x7af,0x300f7,0x99c,0x0,0x400fa,0x99a,0x99b,0x99c,0x200f8,0x99b,0x200f9,0x9b0, + 0x200f8,0x99c,0x500aa,0x6e,0x5903,0x90b,0x1bf,0x300f7,0x5907,0x0,0x400fa,0x5903, + 0x5904,0x5907,0x200f8,0x5904,0x6003c,0x261,0x5913,0x260,0x1d4,0x1bf,0x700ea,0x6, + 0x5914,0x5913,0x172,0x1bf,0x172,0x3003e,0x2b0,0x5914,0x200f9,0x5907,0x200f8,0x5907, + 0x300e1,0x16b,0x4ef,0x400e0,0x16b,0x16b,0x4f0,0x4003d,0x6,0x5918,0x2b0,0x50082, + 0x6,0x590b,0x945,0x172,0x500ab,0x6e,0x590c,0x5918,0x590b,0x300f7,0x9a2,0x0, + 0x400fa,0x590c,0x9a1,0x9a2,0x200f8,0x9a1,0x200f9,0x9b0,0x200f8,0x9a2,0x4003d,0x25e, + 0x591c,0x260,0x50063,0x591c,0x1d4,0x266,0x2000,0x300f7,0x59c7,0x0,0x300fb,0x1bf, + 0x5949,0x200f8,0x5949,0x50084,0x6,0x594b,0x984,0x20b,0x4007c,0x1a,0x594d,0x594b, + 0x50084,0x6,0x594f,0x98a,0x20b,0x4007c,0x1a,0x5951,0x594f,0x50050,0x32,0x5952, + 0x594d,0x5951,0x4007c,0x2d,0x595d,0x5952,0x50080,0x2d,0x59d2,0x595d,0x542,0x50080, + 0x2d,0x59d4,0x595d,0x545,0x50080,0x2d,0x59d6,0x595d,0x548,0x4003d,0x1e4,0x5a39, + 0x219,0x50062,0x9f,0x5a3b,0x5a39,0x5952,0x50051,0x13,0x5a06,0x5a3b,0x0,0x50051, + 0x13,0x5a07,0x5a3b,0x1,0x70050,0x9f,0x5a08,0x5a06,0x5a07,0x1d8,0x1d8,0x4007c, + 0x32,0x59f0,0x59d2,0x4003d,0x1e4,0x5a79,0x219,0x50062,0x9f,0x5a7b,0x5a79,0x59f0, + 0x50051,0x13,0x5a46,0x5a7b,0x0,0x50051,0x13,0x5a47,0x5a7b,0x1,0x70050,0x9f, + 0x5a48,0x5a46,0x5a47,0x1d8,0x1d8,0x4007c,0x32,0x59f4,0x59d4,0x4003d,0x1e4,0x5ab9, + 0x219,0x50062,0x9f,0x5abb,0x5ab9,0x59f4,0x50051,0x13,0x5a86,0x5abb,0x0,0x50051, + 0x13,0x5a87,0x5abb,0x1,0x70050,0x9f,0x5a88,0x5a86,0x5a87,0x1d8,0x1d8,0x4007c, + 0x32,0x59f8,0x59d6,0x4003d,0x1e4,0x5af9,0x219,0x50062,0x9f,0x5afb,0x5af9,0x59f8, + 0x50051,0x13,0x5ac6,0x5afb,0x0,0x50051,0x13,0x5ac7,0x5afb,0x1,0x70050,0x9f, + 0x5ac8,0x5ac6,0x5ac7,0x1d8,0x1d8,0x50081,0x9f,0x5b04,0x5a08,0x5a48,0x50081,0x9f, + 0x5b06,0x5b04,0x5a88,0x50081,0x9f,0x5b08,0x5b06,0x5ac8,0x5008e,0x9f,0x5b09,0x5b08, + 0x4af,0x50080,0x6,0x5966,0x594b,0x16b,0x4007c,0x1a,0x5967,0x5966,0x50050,0x32, + 0x596c,0x5967,0x5951,0x4007c,0x2d,0x5977,0x596c,0x50080,0x2d,0x5b5e,0x5977,0x542, + 0x50080,0x2d,0x5b60,0x5977,0x545,0x50080,0x2d,0x5b62,0x5977,0x548,0x4003d,0x1e4, + 0x5bc5,0x219,0x50062,0x9f,0x5bc7,0x5bc5,0x596c,0x50051,0x13,0x5b92,0x5bc7,0x0, + 0x50051,0x13,0x5b93,0x5bc7,0x1,0x70050,0x9f,0x5b94,0x5b92,0x5b93,0x1d8,0x1d8, + 0x4007c,0x32,0x5b7c,0x5b5e,0x4003d,0x1e4,0x5c05,0x219,0x50062,0x9f,0x5c07,0x5c05, + 0x5b7c,0x50051,0x13,0x5bd2,0x5c07,0x0,0x50051,0x13,0x5bd3,0x5c07,0x1,0x70050, + 0x9f,0x5bd4,0x5bd2,0x5bd3,0x1d8,0x1d8,0x4007c,0x32,0x5b80,0x5b60,0x4003d,0x1e4, + 0x5c45,0x219,0x50062,0x9f,0x5c47,0x5c45,0x5b80,0x50051,0x13,0x5c12,0x5c47,0x0, + 0x50051,0x13,0x5c13,0x5c47,0x1,0x70050,0x9f,0x5c14,0x5c12,0x5c13,0x1d8,0x1d8, + 0x4007c,0x32,0x5b84,0x5b62,0x4003d,0x1e4,0x5c85,0x219,0x50062,0x9f,0x5c87,0x5c85, + 0x5b84,0x50051,0x13,0x5c52,0x5c87,0x0,0x50051,0x13,0x5c53,0x5c87,0x1,0x70050, + 0x9f,0x5c54,0x5c52,0x5c53,0x1d8,0x1d8,0x50081,0x9f,0x5c90,0x5b94,0x5bd4,0x50081, + 0x9f,0x5c92,0x5c90,0x5c14,0x50081,0x9f,0x5c94,0x5c92,0x5c54,0x5008e,0x9f,0x5c95, + 0x5c94,0x4af,0x50080,0x6,0x5984,0x594f,0x16b,0x4007c,0x1a,0x5985,0x5984,0x50050, + 0x32,0x5986,0x594d,0x5985,0x4007c,0x2d,0x5991,0x5986,0x50080,0x2d,0x5cea,0x5991, + 0x542,0x50080,0x2d,0x5cec,0x5991,0x545,0x50080,0x2d,0x5cee,0x5991,0x548,0x4003d, + 0x1e4,0x5d51,0x219,0x50062,0x9f,0x5d53,0x5d51,0x5986,0x50051,0x13,0x5d1e,0x5d53, + 0x0,0x50051,0x13,0x5d1f,0x5d53,0x1,0x70050,0x9f,0x5d20,0x5d1e,0x5d1f,0x1d8, + 0x1d8,0x4007c,0x32,0x5d08,0x5cea,0x4003d,0x1e4,0x5d91,0x219,0x50062,0x9f,0x5d93, + 0x5d91,0x5d08,0x50051,0x13,0x5d5e,0x5d93,0x0,0x50051,0x13,0x5d5f,0x5d93,0x1, + 0x70050,0x9f,0x5d60,0x5d5e,0x5d5f,0x1d8,0x1d8,0x4007c,0x32,0x5d0c,0x5cec,0x4003d, + 0x1e4,0x5dd1,0x219,0x50062,0x9f,0x5dd3,0x5dd1,0x5d0c,0x50051,0x13,0x5d9e,0x5dd3, + 0x0,0x50051,0x13,0x5d9f,0x5dd3,0x1,0x70050,0x9f,0x5da0,0x5d9e,0x5d9f,0x1d8, + 0x1d8,0x4007c,0x32,0x5d10,0x5cee,0x4003d,0x1e4,0x5e11,0x219,0x50062,0x9f,0x5e13, + 0x5e11,0x5d10,0x50051,0x13,0x5dde,0x5e13,0x0,0x50051,0x13,0x5ddf,0x5e13,0x1, + 0x70050,0x9f,0x5de0,0x5dde,0x5ddf,0x1d8,0x1d8,0x50081,0x9f,0x5e1c,0x5d20,0x5d60, + 0x50081,0x9f,0x5e1e,0x5e1c,0x5da0,0x50081,0x9f,0x5e20,0x5e1e,0x5de0,0x5008e,0x9f, + 0x5e21,0x5e20,0x4af,0x50050,0x32,0x59a0,0x5967,0x5985,0x4007c,0x2d,0x59ab,0x59a0, + 0x50080,0x2d,0x5e76,0x59ab,0x542,0x50080,0x2d,0x5e78,0x59ab,0x545,0x50080,0x2d, + 0x5e7a,0x59ab,0x548,0x4003d,0x1e4,0x5edd,0x219,0x50062,0x9f,0x5edf,0x5edd,0x59a0, + 0x50051,0x13,0x5eaa,0x5edf,0x0,0x50051,0x13,0x5eab,0x5edf,0x1,0x70050,0x9f, + 0x5eac,0x5eaa,0x5eab,0x1d8,0x1d8,0x4007c,0x32,0x5e94,0x5e76,0x4003d,0x1e4,0x5f1d, + 0x219,0x50062,0x9f,0x5f1f,0x5f1d,0x5e94,0x50051,0x13,0x5eea,0x5f1f,0x0,0x50051, + 0x13,0x5eeb,0x5f1f,0x1,0x70050,0x9f,0x5eec,0x5eea,0x5eeb,0x1d8,0x1d8,0x4007c, + 0x32,0x5e98,0x5e78,0x4003d,0x1e4,0x5f5d,0x219,0x50062,0x9f,0x5f5f,0x5f5d,0x5e98, + 0x50051,0x13,0x5f2a,0x5f5f,0x0,0x50051,0x13,0x5f2b,0x5f5f,0x1,0x70050,0x9f, + 0x5f2c,0x5f2a,0x5f2b,0x1d8,0x1d8,0x4007c,0x32,0x5e9c,0x5e7a,0x4003d,0x1e4,0x5f9d, + 0x219,0x50062,0x9f,0x5f9f,0x5f9d,0x5e9c,0x50051,0x13,0x5f6a,0x5f9f,0x0,0x50051, + 0x13,0x5f6b,0x5f9f,0x1,0x70050,0x9f,0x5f6c,0x5f6a,0x5f6b,0x1d8,0x1d8,0x50081, + 0x9f,0x5fa8,0x5eac,0x5eec,0x50081,0x9f,0x5faa,0x5fa8,0x5f2c,0x50081,0x9f,0x5fac, + 0x5faa,0x5f6c,0x5008e,0x9f,0x5fad,0x5fac,0x4af,0x500b2,0x6e,0x59b3,0x941,0x81c, + 0x300f7,0x59b5,0x0,0x400fa,0x59b3,0x59b4,0x59b5,0x200f8,0x59b4,0x200f9,0x59c7,0x200f8, + 0x59b5,0x50081,0x9f,0x5ffc,0x5b09,0x5c95,0x50081,0x9f,0x5ffe,0x5ffc,0x5e21,0x50081, + 0x9f,0x6000,0x5ffe,0x5fad,0x5008e,0x9f,0x6001,0x6000,0x4af,0x50051,0x13,0x6050, + 0x6001,0x0,0x60041,0x4c6,0x6051,0x4c3,0x984,0x98a,0x3003e,0x6051,0x6050,0x50051, + 0x13,0x6055,0x6001,0x1,0x60041,0x4c6,0x6056,0x4c9,0x984,0x98a,0x3003e,0x6056, + 0x6055,0x50051,0x13,0x605a,0x6001,0x2,0x60041,0x4c6,0x605b,0x4ce,0x984,0x98a, + 0x3003e,0x605b,0x605a,0x50051,0x13,0x605f,0x6001,0x3,0x60041,0x4c6,0x6060,0x4d3, + 0x984,0x98a,0x3003e,0x6060,0x605f,0x200f9,0x59c7,0x200f8,0x59c7,0x300f7,0x60b2,0x0, + 0x300fb,0x1bf,0x6079,0x200f8,0x6079,0x500b2,0x6e,0x607c,0x941,0x678,0x300f7,0x607e, + 0x0,0x400fa,0x607c,0x607d,0x607e,0x200f8,0x607d,0x200f9,0x60b2,0x200f8,0x607e,0x300e1, + 0x16b,0x4ef,0x400e0,0x16b,0x16b,0x4f0,0x60041,0x4c6,0x60e6,0x4c3,0x984,0x98a, + 0x4003d,0x13,0x60e7,0x60e6,0x60041,0x4c6,0x60ea,0x4c9,0x984,0x98a,0x4003d,0x13, + 0x60eb,0x60ea,0x60041,0x4c6,0x60ee,0x4ce,0x984,0x98a,0x4003d,0x13,0x60ef,0x60ee, + 0x60041,0x4c6,0x60f2,0x4d3,0x984,0x98a,0x4003d,0x13,0x60f3,0x60f2,0x70050,0x9f, + 0x60f4,0x60e7,0x60eb,0x60ef,0x60f3,0x6016e,0x9f,0x6101,0x16c,0x60f4,0x1bf,0x6016e, + 0x9f,0x6103,0x16c,0x60f4,0x172,0x6016e,0x9f,0x6105,0x16c,0x60f4,0x16b,0x50081, + 0x9f,0x610f,0x60f4,0x6101,0x50081,0x9f,0x6111,0x610f,0x6103,0x50081,0x9f,0x6113, + 0x6111,0x6105,0x5008e,0x9f,0x6114,0x6113,0x4af,0x50089,0x6,0x60c6,0x90b,0x20b, + 0x500aa,0x6e,0x60c7,0x60c6,0x1bf,0x300f7,0x60e1,0x0,0x400fa,0x60c7,0x60c8,0x60e1, + 0x200f8,0x60c8,0x50086,0x6,0x60db,0x98a,0x16b,0x50089,0x6,0x60dc,0x60db,0x16b, + 0x50080,0x6,0x60dd,0x984,0x60dc,0x50051,0x13,0x6163,0x6114,0x0,0x60041,0x4c6, + 0x6164,0x4c3,0x60dd,0x98a,0x3003e,0x6164,0x6163,0x50051,0x13,0x6168,0x6114,0x1, + 0x60041,0x4c6,0x6169,0x4c9,0x60dd,0x98a,0x3003e,0x6169,0x6168,0x50051,0x13,0x616d, + 0x6114,0x2,0x60041,0x4c6,0x616e,0x4ce,0x60dd,0x98a,0x3003e,0x616e,0x616d,0x50051, + 0x13,0x6172,0x6114,0x3,0x60041,0x4c6,0x6173,0x4d3,0x60dd,0x98a,0x3003e,0x6173, + 0x6172,0x200f9,0x60e1,0x200f8,0x60e1,0x500b2,0x6e,0x608a,0x941,0x9502,0x300f7,0x608c, + 0x0,0x400fa,0x608a,0x608b,0x608c,0x200f8,0x608b,0x200f9,0x60b2,0x200f8,0x608c,0x300e1, + 0x16b,0x4ef,0x400e0,0x16b,0x16b,0x4f0,0x500b0,0x6e,0x6182,0x90b,0x591,0x300f7, + 0x61ac,0x0,0x400fa,0x6182,0x6183,0x61ac,0x200f8,0x6183,0x50089,0x6,0x6187,0x98a, + 0x16b,0x50080,0x6,0x6188,0xa43,0x6187,0x60041,0x4c6,0x61b1,0x4c3,0x6188,0xa46, + 0x4003d,0x13,0x61b2,0x61b1,0x60041,0x4c6,0x61b5,0x4c9,0x6188,0xa46,0x4003d,0x13, + 0x61b6,0x61b5,0x60041,0x4c6,0x61b9,0x4ce,0x6188,0xa46,0x4003d,0x13,0x61ba,0x61b9, + 0x60041,0x4c6,0x61bd,0x4d3,0x6188,0xa46,0x4003d,0x13,0x61be,0x61bd,0x70050,0x9f, + 0x61bf,0x61b2,0x61b6,0x61ba,0x61be,0x6016e,0x9f,0x61cc,0x16c,0x61bf,0x1bf,0x6016e, + 0x9f,0x61ce,0x16c,0x61bf,0x172,0x6016e,0x9f,0x61d0,0x16c,0x61bf,0x16b,0x50081, + 0x9f,0x61da,0x61bf,0x61cc,0x50081,0x9f,0x61dc,0x61da,0x61ce,0x50081,0x9f,0x61de, + 0x61dc,0x61d0,0x5008e,0x9f,0x61df,0x61de,0x4af,0x300f7,0x61ab,0x0,0x400fa,0x60c7, + 0x6191,0x61ab,0x200f8,0x6191,0x50086,0x6,0x61a5,0x98a,0x16b,0x50080,0x6,0x61a6, + 0xa43,0x61a5,0x50051,0x13,0x622e,0x61df,0x0,0x60041,0x4c6,0x622f,0x4c3,0x61a6, + 0xa46,0x3003e,0x622f,0x622e,0x50051,0x13,0x6233,0x61df,0x1,0x60041,0x4c6,0x6234, + 0x4c9,0x61a6,0xa46,0x3003e,0x6234,0x6233,0x50051,0x13,0x6238,0x61df,0x2,0x60041, + 0x4c6,0x6239,0x4ce,0x61a6,0xa46,0x3003e,0x6239,0x6238,0x50051,0x13,0x623d,0x61df, + 0x3,0x60041,0x4c6,0x623e,0x4d3,0x61a6,0xa46,0x3003e,0x623e,0x623d,0x200f9,0x61ab, + 0x200f8,0x61ab,0x200f9,0x61ac,0x200f8,0x61ac,0x500b2,0x6e,0x6099,0x941,0x9503,0x300f7, + 0x609b,0x0,0x400fa,0x6099,0x609a,0x609b,0x200f8,0x609a,0x200f9,0x60b2,0x200f8,0x609b, + 0x300e1,0x16b,0x4ef,0x400e0,0x16b,0x16b,0x4f0,0x500b0,0x6e,0x624d,0x90b,0x4bf, + 0x300f7,0x6273,0x0,0x400fa,0x624d,0x624e,0x6273,0x200f8,0x624e,0x50080,0x6,0x6252, + 0x594b,0x98a,0x60041,0x4c6,0x6278,0x4c3,0x6252,0x594f,0x4003d,0x13,0x6279,0x6278, + 0x60041,0x4c6,0x627c,0x4c9,0x6252,0x594f,0x4003d,0x13,0x627d,0x627c,0x60041,0x4c6, + 0x6280,0x4ce,0x6252,0x594f,0x4003d,0x13,0x6281,0x6280,0x60041,0x4c6,0x6284,0x4d3, + 0x6252,0x594f,0x4003d,0x13,0x6285,0x6284,0x70050,0x9f,0x6286,0x6279,0x627d,0x6281, + 0x6285,0x6016e,0x9f,0x6293,0x16c,0x6286,0x1bf,0x6016e,0x9f,0x6295,0x16c,0x6286, + 0x172,0x6016e,0x9f,0x6297,0x16c,0x6286,0x16b,0x50081,0x9f,0x62a1,0x6286,0x6293, + 0x50081,0x9f,0x62a3,0x62a1,0x6295,0x50081,0x9f,0x62a5,0x62a3,0x6297,0x5008e,0x9f, + 0x62a6,0x62a5,0x4af,0x300f7,0x6272,0x0,0x400fa,0x60c7,0x625b,0x6272,0x200f8,0x625b, + 0x50086,0x6,0x626d,0x984,0x16b,0x50080,0x6,0x626f,0x626d,0x98a,0x50051,0x13, + 0x62f5,0x62a6,0x0,0x60041,0x4c6,0x62f6,0x4c3,0x626f,0x1bf,0x3003e,0x62f6,0x62f5, + 0x50051,0x13,0x62fa,0x62a6,0x1,0x60041,0x4c6,0x62fb,0x4c9,0x626f,0x1bf,0x3003e, + 0x62fb,0x62fa,0x50051,0x13,0x62ff,0x62a6,0x2,0x60041,0x4c6,0x6300,0x4ce,0x626f, + 0x1bf,0x3003e,0x6300,0x62ff,0x50051,0x13,0x6304,0x62a6,0x3,0x60041,0x4c6,0x6305, + 0x4d3,0x626f,0x1bf,0x3003e,0x6305,0x6304,0x200f9,0x6272,0x200f8,0x6272,0x200f9,0x6273, + 0x200f8,0x6273,0x500b2,0x6e,0x60a8,0x941,0x9504,0x300f7,0x60aa,0x0,0x400fa,0x60a8, + 0x60a9,0x60aa,0x200f8,0x60a9,0x200f9,0x60b2,0x200f8,0x60aa,0x300e1,0x16b,0x4ef,0x400e0, + 0x16b,0x16b,0x4f0,0x500b0,0x6e,0x6311,0x90b,0x20b,0x300f7,0x6322,0x0,0x400fa, + 0x6311,0x6312,0x6322,0x200f8,0x6312,0x60041,0x4c6,0x6327,0x4c3,0x90b,0x1bf,0x4003d, + 0x13,0x6328,0x6327,0x60041,0x4c6,0x632b,0x4c9,0x90b,0x1bf,0x4003d,0x13,0x632c, + 0x632b,0x60041,0x4c6,0x632f,0x4ce,0x90b,0x1bf,0x4003d,0x13,0x6330,0x632f,0x60041, + 0x4c6,0x6333,0x4d3,0x90b,0x1bf,0x4003d,0x13,0x6334,0x6333,0x70050,0x9f,0x6335, + 0x6328,0x632c,0x6330,0x6334,0x6016e,0x9f,0x6342,0x16c,0x6335,0x1bf,0x6016e,0x9f, + 0x6344,0x16c,0x6335,0x172,0x6016e,0x9f,0x6346,0x16c,0x6335,0x16b,0x200f9,0x6322, + 0x200f8,0x6322,0x200f9,0x60b2,0x200f8,0x60b2,0x200f9,0x9b0,0x200f8,0x9b0,0x100fd,0x10038, +}; +static const char *fu0_shading_change_pyramid_pass_0_cb_names[] = {"cbFSR3Upscaler", "cbSPD"}; +static const uint32_t fu0_shading_change_pyramid_pass_0_cb_bind[] = {11, 12}; +static const uint32_t fu0_shading_change_pyramid_pass_0_cb_count[] = {1, 1}; +static const uint32_t fu0_shading_change_pyramid_pass_0_cb_space[] = {0, 0}; +static const char *fu0_shading_change_pyramid_pass_0_srv_tex_names[] = {"r_current_luma", "r_previous_luma", "r_dilated_motion_vectors", "r_input_exposure"}; +static const uint32_t fu0_shading_change_pyramid_pass_0_srv_tex_bind[] = {0, 1, 2, 3}; +static const uint32_t fu0_shading_change_pyramid_pass_0_srv_tex_count[] = {1, 1, 1, 1}; +static const uint32_t fu0_shading_change_pyramid_pass_0_srv_tex_space[] = {0, 0, 0, 0}; +static const char *fu0_shading_change_pyramid_pass_0_uav_tex_names[] = {"rw_spd_global_atomic", "rw_spd_mip0", "rw_spd_mip1", "rw_spd_mip2", "rw_spd_mip3", "rw_spd_mip4", "rw_spd_mip5"}; +static const uint32_t fu0_shading_change_pyramid_pass_0_uav_tex_bind[] = {4, 5, 6, 7, 8, 9, 10}; +static const uint32_t fu0_shading_change_pyramid_pass_0_uav_tex_count[] = {1, 1, 1, 1, 1, 1, 1}; +static const uint32_t fu0_shading_change_pyramid_pass_0_uav_tex_space[] = {0, 0, 0, 0, 0, 0, 0}; + +static const uint32_t fu0_shading_change_pass_0_spv[734] = { + 0x7230203,0x10500,0x8000b,0x239,0x0,0x20011,0x1,0x20011,0x31,0x20011,0x32,0x6000b, + 0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0xa000f,0x5,0x4,0x6e69616d, + 0x0,0x68,0x77,0x81,0x8e,0x128,0x60010,0x4,0x11,0x8,0x8,0x1, + 0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75, + 0x736e6f69,0x0,0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63, + 0x736570,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004, + 0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669,0x40005,0x4,0x6e69616d,0x0,0x70005, + 0x66,0x53466263,0x50553352,0x4c414353,0x745f5245,0x0,0x60006,0x66,0x0,0x6e655269,0x53726564,0x657a69, + 0x50006,0x66,0x1,0x74694a66,0x726574,0x60005,0x68,0x53466263,0x70553352,0x6c616373,0x7265,0x50005, + 0x77,0x70735f72,0x696d5f64,0x7370,0x60005,0x81,0x694c5f73,0x7261656e,0x6d616c43,0x70,0x70005,0x8e, + 0x735f7772,0x69646168,0x635f676e,0x676e6168,0x65,0x80005,0x128,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69, + 0x44,0x30047,0x66,0x2,0x50048,0x66,0x0,0x23,0x0,0x50048,0x66,0x1, + 0x23,0x40,0x40047,0x68,0x21,0x2,0x40047,0x68,0x22,0x0,0x40047,0x77, + 0x21,0x0,0x40047,0x77,0x22,0x0,0x40047,0x81,0x21,0x3e9,0x40047,0x81, + 0x22,0x0,0x40047,0x8e,0x21,0x1,0x40047,0x8e,0x22,0x0,0x40047,0x128, + 0xb,0x1c,0x40047,0x13c,0xb,0x19,0x20013,0x2,0x30021,0x3,0x2,0x30016, + 0x6,0x20,0x40020,0x7,0x7,0x6,0x40017,0xc,0x6,0x2,0x40015,0x1c, + 0x20,0x1,0x40017,0x1d,0x1c,0x2,0x40015,0x24,0x20,0x0,0x20014,0x3d, + 0x4002b,0x24,0x43,0x3,0x4001c,0x44,0x6,0x43,0x4002b,0x6,0x51,0x0, + 0x4002b,0x6,0x52,0x3f800000,0x40017,0x65,0x6,0x4,0x4001e,0x66,0x1d,0xc, + 0x40020,0x67,0x2,0x66,0x4003b,0x67,0x68,0x2,0x4002b,0x1c,0x69,0x0, + 0x40020,0x6a,0x2,0x1d,0x40020,0x70,0x2,0xc,0x90019,0x75,0x6,0x1, + 0x0,0x0,0x0,0x1,0x0,0x40020,0x76,0x0,0x75,0x4003b,0x76,0x77, + 0x0,0x2001a,0x7f,0x40020,0x80,0x0,0x7f,0x4003b,0x80,0x81,0x0,0x3001b, + 0x83,0x75,0x90019,0x8c,0x6,0x1,0x0,0x0,0x0,0x2,0xf,0x40020, + 0x8d,0x0,0x8c,0x4003b,0x8d,0x8e,0x0,0x4002b,0x6,0x95,0x3f000000,0x5002c, + 0xc,0xa0,0x95,0x95,0x40017,0xb4,0x24,0x2,0x40017,0xb8,0x3d,0x2, + 0x4002b,0x1c,0xcf,0x3,0x4002b,0x24,0xdd,0x1,0x4002b,0x1c,0xe4,0x1, + 0x40017,0x126,0x24,0x3,0x40020,0x127,0x1,0x126,0x4003b,0x127,0x128,0x1, + 0x4002b,0x24,0x13b,0x8,0x6002c,0x126,0x13c,0x13b,0x13b,0xdd,0x40020,0x21a, + 0x7,0x44,0x50036,0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003b,0x21a,0x223, + 0x7,0x4003b,0x21a,0x21b,0x7,0x4003d,0x126,0x129,0x128,0x7004f,0xb4,0x12a, + 0x129,0x129,0x0,0x1,0x4007c,0x1d,0x12b,0x12a,0x50041,0x6a,0x183,0x68, + 0x69,0x4003d,0x1d,0x184,0x183,0x4006f,0xc,0x17e,0x184,0x5008e,0xc,0x17f, + 0x17e,0x95,0x4006e,0x1d,0x180,0x17f,0x4007c,0xb4,0x18b,0x180,0x500b0,0xb8, + 0x18c,0x12a,0x18b,0x4009b,0x3d,0x18d,0x18c,0x300f7,0x17a,0x0,0x400fa,0x18d, + 0x14f,0x17a,0x200f8,0x14f,0x4006f,0xc,0x151,0x12b,0x50081,0xc,0x153,0x151, + 0xa0,0x4006f,0xc,0x155,0x180,0x50088,0xc,0x156,0x153,0x155,0x50041,0x70, + 0x19a,0x68,0xdd,0x4003d,0xc,0x19b,0x19a,0x50088,0xc,0x15b,0x19b,0x17e, + 0x50081,0xc,0x15c,0x156,0x15b,0x4003d,0x75,0x1dc,0x77,0x50067,0x1d,0x1df, + 0x1dc,0x69,0x50085,0xc,0x1ec,0x15c,0x155,0x50083,0xc,0x1ef,0x155,0xa0, + 0x7000c,0xc,0x1fc,0x1,0x25,0x1ec,0x1ef,0x7000c,0xc,0x201,0x1,0x28, + 0xa0,0x1fc,0x4006f,0xc,0x1f5,0x1df,0x50088,0xc,0x1f6,0x201,0x1f5,0x200f9, + 0x1ba,0x200f8,0x1ba,0x700f5,0x1c,0x231,0x69,0x14f,0x1cd,0x1be,0x500b1,0x3d, + 0x1bd,0x231,0xcf,0x400f6,0x1ce,0x1be,0x0,0x400fa,0x1bd,0x1be,0x1ce,0x200f8, + 0x1be,0x4007c,0x24,0x1c0,0x231,0x4003d,0x75,0x204,0x77,0x4003d,0x7f,0x205, + 0x81,0x50056,0x83,0x206,0x204,0x205,0x40070,0x6,0x209,0x1c0,0x70058,0x65, + 0x20a,0x206,0x1f6,0x2,0x209,0x50051,0x6,0x1c5,0x20a,0x0,0x50051,0x6, + 0x1c7,0x20a,0x1,0x50085,0x6,0x1c8,0x1c5,0x1c7,0x6000c,0x6,0x1c9,0x1, + 0x4,0x1c8,0x50041,0x7,0x21c,0x21b,0x231,0x3003e,0x21c,0x1c9,0x50080,0x1c, + 0x1cd,0x231,0xe4,0x200f9,0x1ba,0x200f8,0x1ce,0x4003d,0x44,0x21d,0x21b,0x3003e, + 0x223,0x21d,0x200f9,0x161,0x200f8,0x161,0x700f5,0x6,0x233,0x51,0x1ce,0x238, + 0x172,0x700f5,0x1c,0x232,0x69,0x1ce,0x174,0x172,0x500b1,0x3d,0x164,0x232, + 0xcf,0x400f6,0x175,0x172,0x0,0x400fa,0x164,0x165,0x175,0x200f8,0x165,0x50041, + 0x7,0x225,0x223,0x232,0x4003d,0x6,0x168,0x225,0x500ba,0x3d,0x169,0x168, + 0x51,0x300f7,0x171,0x0,0x400fa,0x169,0x16a,0x171,0x200f8,0x16a,0x4003d,0x6, + 0x16e,0x225,0x7000c,0x6,0x210,0x1,0x28,0x233,0x16e,0x200f9,0x171,0x200f8, + 0x171,0x700f5,0x6,0x238,0x233,0x165,0x210,0x16a,0x200f9,0x172,0x200f8,0x172, + 0x50080,0x1c,0x174,0x232,0xe4,0x200f9,0x161,0x200f8,0x175,0x8000c,0x6,0x214, + 0x1,0x2b,0x233,0x51,0x52,0x4003d,0x8c,0x216,0x8e,0x70050,0x65,0x219, + 0x214,0x51,0x51,0x51,0x40063,0x216,0x12b,0x219,0x200f9,0x17a,0x200f8,0x17a, + 0x100fd,0x10038, +}; +static const char *fu0_shading_change_pass_0_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu0_shading_change_pass_0_cb_bind[] = {2}; +static const uint32_t fu0_shading_change_pass_0_cb_count[] = {1}; +static const uint32_t fu0_shading_change_pass_0_cb_space[] = {0}; +static const char *fu0_shading_change_pass_0_srv_tex_names[] = {"r_spd_mips"}; +static const uint32_t fu0_shading_change_pass_0_srv_tex_bind[] = {0}; +static const uint32_t fu0_shading_change_pass_0_srv_tex_count[] = {1}; +static const uint32_t fu0_shading_change_pass_0_srv_tex_space[] = {0}; +static const char *fu0_shading_change_pass_0_uav_tex_names[] = {"rw_shading_change"}; +static const uint32_t fu0_shading_change_pass_0_uav_tex_bind[] = {1}; +static const uint32_t fu0_shading_change_pass_0_uav_tex_count[] = {1}; +static const uint32_t fu0_shading_change_pass_0_uav_tex_space[] = {0}; +static const char *fu0_shading_change_pass_0_sampler_names[] = {"s_LinearClamp"}; +static const uint32_t fu0_shading_change_pass_0_sampler_bind[] = {1001}; +static const uint32_t fu0_shading_change_pass_0_sampler_count[] = {1}; +static const uint32_t fu0_shading_change_pass_0_sampler_space[] = {0}; + +static const uint32_t fu0_prepare_reactivity_pass_0_spv[3241] = { + 0x7230203,0x10500,0x8000b,0xc04,0x0,0x20011,0x1,0x20011,0x31,0x20011,0x32,0x6000b, + 0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0x14000f,0x5,0x4,0x6e69616d, + 0x0,0x10b,0x13f,0x14b,0x153,0x15c,0x167,0x16c,0x179,0x180,0x187,0x190, + 0x197,0x19f,0x1ad,0x513,0x60010,0x4,0x11,0x8,0x8,0x1,0x30003,0x2, + 0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0, + 0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004, + 0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f, + 0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669,0x40005,0x4,0x6e69616d,0x0,0x70005,0x109,0x53466263, + 0x50553352,0x4c414353,0x745f5245,0x0,0x60006,0x109,0x0,0x6e655269,0x53726564,0x657a69,0xa0006,0x109, + 0x1,0x65725069,0x756f6976,0x61724673,0x6552656d,0x7265646e,0x657a6953,0x0,0x70006,0x109,0x2,0x73705569, + 0x656c6163,0x657a6953,0x0,0x70006,0x109,0x3,0x78614d69,0x646e6552,0x69537265,0x657a,0x80006,0x109, + 0x4,0x76654466,0x54656369,0x6569566f,0x70654477,0x6874,0x50006,0x109,0x5,0x74694a66,0x726574,0xa0006, + 0x109,0x6,0x65695666,0x61705377,0x6f546563,0x6574654d,0x61467372,0x726f7463,0x0,0x80006,0x109,0x7, + 0x61655266,0x76697463,0x73656e65,0x61635373,0x656c,0x80006,0x109,0x8,0x61685366,0x676e6964,0x6e616843,0x63536567, + 0x656c61,0xa0006,0x109,0x9,0x63634166,0x6c756d75,0x6f697461,0x6464416e,0x65506465,0x61724672,0x656d,0xb0006, + 0x109,0xa,0x6e694d66,0x6f736944,0x756c6363,0x6e6f6973,0x75636341,0x616c756d,0x6e6f6974,0x0,0x60005,0x10b, + 0x53466263,0x70553352,0x6c616373,0x7265,0x60005,0x13f,0x65725f72,0x69746361,0x6d5f6576,0x6b7361,0xb0005,0x14b, + 0x72745f72,0x70736e61,0x6e657261,0x615f7963,0x635f646e,0x6f706d6f,0x69746973,0x6d5f6e6f,0x6b7361,0x60005,0x153,0x694c5f73, + 0x7261656e,0x6d616c43,0x70,0x60005,0x15c,0x63615f72,0x756d7563,0x6974616c,0x6e6f,0x60005,0x167,0x615f7772, + 0x6d756363,0x74616c75,0x6e6f69,0x70005,0x16c,0x68735f72,0x6e696461,0x68635f67,0x65676e61,0x0,0x60005,0x179, + 0x75635f72,0x6e657272,0x756c5f74,0x616d,0x60005,0x180,0x6e5f7772,0x6c5f7765,0x736b636f,0x0,0xc0005,0x187, + 0x65725f72,0x736e6f63,0x63757274,0x5f646574,0x76657270,0x73756f69,0x61656e5f,0x74736572,0x7065645f,0x6874,0x90005,0x190, + 0x69645f72,0x6574616c,0x6f6d5f64,0x6e6f6974,0x6365765f,0x73726f74,0x0,0x60005,0x197,0x69645f72,0x6574616c,0x65645f64, + 0x687470,0x70005,0x19f,0x6e695f72,0x5f747570,0x6f707865,0x65727573,0x0,0x90005,0x1ad,0x645f7772,0x74616c69, + 0x725f6465,0x74636165,0x5f657669,0x6b73616d,0x73,0x80005,0x513,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69, + 0x44,0x30047,0x109,0x2,0x50048,0x109,0x0,0x23,0x0,0x50048,0x109,0x1, + 0x23,0x8,0x50048,0x109,0x2,0x23,0x10,0x50048,0x109,0x3,0x23,0x20, + 0x50048,0x109,0x4,0x23,0x30,0x50048,0x109,0x5,0x23,0x40,0x50048,0x109, + 0x6,0x23,0x78,0x50048,0x109,0x7,0x23,0x84,0x50048,0x109,0x8,0x23, + 0x88,0x50048,0x109,0x9,0x23,0x8c,0x50048,0x109,0xa,0x23,0x90,0x40047, + 0x10b,0x21,0xc,0x40047,0x10b,0x22,0x0,0x40047,0x13f,0x21,0x3,0x40047, + 0x13f,0x22,0x0,0x40047,0x14b,0x21,0x4,0x40047,0x14b,0x22,0x0,0x40047, + 0x153,0x21,0x3e9,0x40047,0x153,0x22,0x0,0x40047,0x15c,0x21,0x5,0x40047, + 0x15c,0x22,0x0,0x40047,0x167,0x21,0xb,0x40047,0x167,0x22,0x0,0x40047, + 0x16c,0x21,0x6,0x40047,0x16c,0x22,0x0,0x40047,0x179,0x21,0x7,0x40047, + 0x179,0x22,0x0,0x40047,0x180,0x21,0xa,0x40047,0x180,0x22,0x0,0x40047, + 0x187,0x21,0x0,0x40047,0x187,0x22,0x0,0x40047,0x190,0x21,0x1,0x40047, + 0x190,0x22,0x0,0x40047,0x197,0x21,0x2,0x40047,0x197,0x22,0x0,0x40047, + 0x19f,0x21,0x8,0x40047,0x19f,0x22,0x0,0x30047,0x1ad,0x19,0x40047,0x1ad, + 0x21,0x9,0x40047,0x1ad,0x22,0x0,0x40047,0x513,0xb,0x1c,0x40047,0x522, + 0xb,0x19,0x30047,0x9aa,0x18,0x30047,0x9be,0x18,0x30047,0x9bf,0x18,0x20013, + 0x2,0x30021,0x3,0x2,0x30016,0x6,0x20,0x40020,0x7,0x7,0x6,0x40017, + 0x12,0x6,0x2,0x40015,0x22,0x20,0x1,0x40017,0x35,0x22,0x2,0x40017, + 0x42,0x6,0x4,0x40020,0x4d,0x7,0x35,0x20014,0x8b,0x40015,0xab,0x20, + 0x0,0x4002b,0xab,0xac,0x4,0x4001c,0xad,0x35,0xac,0x4001c,0xae,0x6, + 0xac,0x4002b,0x6,0xe2,0x0,0x4002b,0x6,0xe3,0x3f800000,0xd001e,0x109,0x35, + 0x35,0x35,0x35,0x42,0x12,0x6,0x6,0x6,0x6,0x6,0x40020,0x10a, + 0x2,0x109,0x4003b,0x10a,0x10b,0x2,0x4002b,0x22,0x10c,0x0,0x40020,0x10d, + 0x2,0x35,0x4002b,0x22,0x112,0x1,0x4002b,0x22,0x117,0x4,0x4002b,0x22, + 0x11c,0x2,0x40020,0x122,0x2,0x12,0x40020,0x128,0x2,0x42,0x40020,0x12e, + 0x2,0x6,0x90019,0x13d,0x6,0x1,0x0,0x0,0x0,0x1,0x0,0x40020, + 0x13e,0x0,0x13d,0x4003b,0x13e,0x13f,0x0,0x4002b,0xab,0x143,0x0,0x4003b, + 0x13e,0x14b,0x0,0x2001a,0x151,0x40020,0x152,0x0,0x151,0x4003b,0x152,0x153, + 0x0,0x3001b,0x155,0x13d,0x4003b,0x13e,0x15c,0x0,0x90019,0x165,0x6,0x1, + 0x0,0x0,0x0,0x2,0xf,0x40020,0x166,0x0,0x165,0x4003b,0x166,0x167, + 0x0,0x4003b,0x13e,0x16c,0x0,0x4003b,0x13e,0x179,0x0,0x4003b,0x166,0x180, + 0x0,0x90019,0x185,0xab,0x1,0x0,0x0,0x0,0x1,0x0,0x40020,0x186, + 0x0,0x185,0x4003b,0x186,0x187,0x0,0x40017,0x18a,0xab,0x4,0x4003b,0x13e, + 0x190,0x0,0x4003b,0x13e,0x197,0x0,0x4003b,0x13e,0x19f,0x0,0x5002c,0x35, + 0x1a1,0x10c,0x10c,0x90019,0x1ab,0x6,0x1,0x0,0x0,0x0,0x2,0x4, + 0x40020,0x1ac,0x0,0x1ab,0x4003b,0x1ac,0x1ad,0x0,0x4002b,0x6,0x1b1,0x3e800000, + 0x4002b,0x6,0x1b2,0x3f400000,0x4002b,0x6,0x1b4,0x42c80000,0x4002b,0x6,0x1c0,0x3f000000, + 0x4002b,0x6,0x1cc,0x45700000,0x4002b,0x6,0x1cd,0x45070000,0x5002c,0x12,0x1ce,0x1cc, + 0x1cd,0x4002b,0xab,0x1f0,0x1,0x5002c,0x12,0x222,0x1c0,0x1c0,0x40017,0x236, + 0xab,0x2,0x40017,0x23a,0x8b,0x2,0x5002c,0x35,0x278,0x112,0x10c,0x5002c, + 0x35,0x27a,0x10c,0x112,0x5002c,0x35,0x27d,0x112,0x112,0x4002b,0x6,0x2a2, + 0x477fe000,0x30029,0x8b,0x2c0,0x4002b,0x6,0x2e4,0x3a1fe868,0x4002b,0x6,0x2f4,0x800000, + 0x4002b,0x6,0x306,0x3765d90d,0x4002b,0x22,0x36b,0xffffffff,0x4002b,0x6,0x3a1,0x7f7fffff, + 0x4002b,0x22,0x3aa,0x9,0x4002b,0xab,0x3ad,0x9,0x4001c,0x3ae,0x35,0x3ad, + 0x5002c,0x35,0x3af,0x36b,0x36b,0x5002c,0x35,0x3b0,0x10c,0x36b,0x5002c,0x35, + 0x3b1,0x112,0x36b,0x5002c,0x35,0x3b2,0x36b,0x10c,0x5002c,0x35,0x3b3,0x36b, + 0x112,0xc002c,0x3ae,0x3b4,0x1a1,0x3af,0x3b0,0x3b1,0x3b2,0x278,0x3b3,0x27a, + 0x27d,0x40020,0x3ba,0x7,0x3ae,0x4001c,0x3c0,0x6,0x3ad,0x40020,0x3c1,0x7, + 0x3c0,0x40020,0x3dc,0x7,0xab,0x4002b,0x6,0x3f4,0x3f666666,0x3002a,0x8b,0x41c, + 0x4001c,0x42c,0xab,0xac,0x4002b,0xab,0x42d,0x17,0x4002b,0xab,0x42e,0x2d, + 0x4002b,0xab,0x42f,0xd1,0x4002b,0xab,0x430,0x1a1,0x7002c,0x42c,0x431,0x42d, + 0x42e,0x42f,0x430,0x40020,0x433,0x7,0x42c,0x4002b,0x6,0x506,0x3c23d70a,0x40017, + 0x511,0xab,0x3,0x40020,0x512,0x1,0x511,0x4003b,0x512,0x513,0x1,0x4002b, + 0xab,0x521,0x8,0x6002c,0x511,0x522,0x521,0x521,0x1f0,0x40020,0xabb,0x7, + 0xad,0x40020,0xabd,0x7,0xae,0x30001,0x6,0xb6d,0x7002c,0xad,0xbb7,0x1a1, + 0x278,0x27a,0x27d,0x4002b,0x6,0xbb8,0x3dcccccd,0x4002b,0xab,0xbee,0x6,0x4002b, + 0xab,0xbef,0x7,0x4002b,0xab,0xbf0,0x5,0x4002b,0xab,0xbf1,0x3,0x4002b, + 0xab,0xbf2,0xa,0x50036,0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003b,0xabd, + 0xad7,0x7,0x4003b,0xabb,0xad6,0x7,0x5003b,0x3ba,0x9aa,0x7,0x3b4,0x4003b, + 0x3c1,0x9ac,0x7,0x5003b,0x433,0x9be,0x7,0x431,0x5003b,0x433,0x9bf,0x7, + 0x431,0x4003d,0x511,0x514,0x513,0x7004f,0x236,0x515,0x514,0x514,0x0,0x1, + 0x4007c,0x35,0x516,0x515,0x4006f,0x12,0x559,0x516,0x50081,0x12,0x55b,0x559, + 0x222,0x50041,0x10d,0x59c,0x10b,0x10c,0x4003d,0x35,0x59d,0x59c,0x4006f,0x12, + 0x55d,0x59d,0x50088,0x12,0x55e,0x55b,0x55d,0x4003d,0x13d,0x5a0,0x190,0x7005f, + 0x42,0x5a2,0x5a0,0x516,0x2,0x10c,0x7004f,0x12,0x5a3,0x5a2,0x5a2,0x0, + 0x1,0x4003d,0x13d,0x5ab,0x197,0x7005f,0x42,0x5ad,0x5ab,0x516,0x2,0x10c, + 0x50051,0x6,0x5ae,0x5ad,0x0,0x50041,0x128,0x5d6,0x10b,0xac,0x4003d,0x42, + 0x5d7,0x5d6,0x50051,0x6,0x5ce,0x5d7,0x1,0x50051,0x6,0x5d1,0x5d7,0x0, + 0x50083,0x6,0x5d2,0x5ae,0x5d1,0x50088,0x6,0x5d3,0x5ce,0x5d2,0x50041,0x12e, + 0x661,0x10b,0xbee,0x4003d,0x6,0x662,0x661,0x50085,0x6,0x5fe,0x5d3,0x662, + 0x7000c,0x6,0x667,0x1,0x25,0x5fe,0x2a2,0x50085,0x6,0x66f,0x667,0x506, + 0x8000c,0x6,0x675,0x1,0x2b,0x66f,0xe2,0xe3,0x8000c,0x6,0x67b,0x1, + 0x2e,0x1b1,0x1b2,0x675,0x50085,0x12,0x67f,0x5a3,0x1ce,0x6000c,0x6,0x680, + 0x1,0x42,0x67f,0x500ba,0x8b,0x605,0x680,0x67b,0x600a9,0x6,0x606,0x605, + 0xe3,0xe2,0x5008e,0x12,0x608,0x5a3,0x606,0x50081,0x12,0x60b,0x55e,0x608, + 0x50085,0x12,0x68e,0x60b,0x55d,0x50083,0x12,0x68f,0x68e,0x222,0x6000c,0x12, + 0x691,0x1,0x8,0x68f,0x4006e,0x35,0x692,0x691,0x6000c,0x12,0x6ba,0x1, + 0xa,0x68f,0x50051,0x6,0x69b,0x6ba,0x0,0x50083,0x6,0x69c,0xe3,0x69b, + 0x50051,0x6,0x69e,0x6ba,0x1,0x50083,0x6,0x69f,0xe3,0x69e,0x50085,0x6, + 0x6a0,0x69c,0x69f,0x50085,0x6,0x6a7,0x69b,0x69f,0x50085,0x6,0x6ae,0x69c, + 0x69e,0x50085,0x6,0x6b4,0x69b,0x69e,0x70050,0xae,0xb09,0x6a0,0x6a7,0x6ae, + 0x6b4,0x3003e,0xad6,0xbb7,0x3003e,0xad7,0xb09,0x200f9,0x60f,0x200f8,0x60f,0x700f5, + 0x6,0xb0d,0xe2,0x5,0xb8d,0x64d,0x700f5,0x6,0xb0c,0xe2,0x5,0xb8a, + 0x64d,0x700f5,0x8b,0xb0b,0x2c0,0x5,0xb87,0x64d,0x700f5,0x22,0xb0a,0x10c, + 0x5,0x64f,0x64d,0x500b1,0x8b,0x612,0xb0a,0x117,0x500a7,0x8b,0x614,0x612, + 0xb0b,0x400f6,0x650,0x64d,0x0,0x400fa,0x614,0x615,0x650,0x200f8,0x615,0x50041, + 0x4d,0xadc,0xad6,0xb0a,0x4003d,0x35,0x618,0xadc,0x50080,0x35,0x6cc,0x692, + 0x618,0x50051,0x22,0x6ce,0x59d,0x0,0x50082,0x22,0x6cf,0x6ce,0x112,0x50051, + 0x22,0x6d1,0x6cc,0x0,0x7000c,0x22,0x6e2,0x1,0x27,0x6d1,0x6cf,0x7000c, + 0x22,0x6e7,0x1,0x2a,0x10c,0x6e2,0x50051,0x22,0x6d6,0x59d,0x1,0x50082, + 0x22,0x6d7,0x6d6,0x112,0x50051,0x22,0x6d9,0x6cc,0x1,0x7000c,0x22,0x6ec, + 0x1,0x27,0x6d9,0x6d7,0x7000c,0x22,0x6f1,0x1,0x2a,0x10c,0x6ec,0x50050, + 0x35,0xc03,0x6e7,0x6f1,0x4007c,0x236,0x6f9,0xc03,0x4007c,0x236,0x6fb,0x59d, + 0x500b0,0x23a,0x6fc,0x6f9,0x6fb,0x4009b,0x8b,0x6fd,0x6fc,0x300f7,0x64c,0x0, + 0x400fa,0x6fd,0x621,0x64c,0x200f8,0x621,0x50041,0x7,0xadd,0xad7,0xb0a,0x4003d, + 0x6,0x624,0xadd,0x500ba,0x8b,0x626,0x624,0x2e4,0x300f7,0x64b,0x0,0x400fa, + 0x626,0x627,0x64b,0x200f8,0x627,0x4003d,0x185,0x700,0x187,0x7005f,0x18a,0x702, + 0x700,0xc03,0x2002,0x10c,0x50051,0xab,0x703,0x702,0x0,0x4007c,0x6,0x704, + 0x703,0x50083,0x6,0x70e,0x704,0x5d1,0x50088,0x6,0x70f,0x5ce,0x70e,0x50083, + 0x6,0x62d,0x5d3,0x70f,0x500ba,0x8b,0x630,0x62d,0x2f4,0x500a7,0x8b,0x631, + 0xb0b,0x630,0x300f7,0x64a,0x0,0x400fa,0x631,0x633,0x64a,0x200f8,0x633,0x5008e, + 0x12,0x636,0x55d,0x1c0,0x6000c,0x6,0x637,0x1,0x42,0x636,0x7000c,0x6, + 0x71c,0x1,0x28,0x5d3,0x70f,0x50085,0x6,0x63c,0x306,0x637,0x50085,0x6, + 0x63e,0x63c,0x71c,0x50088,0x6,0x641,0x63e,0x62d,0x8000c,0x6,0x720,0x1, + 0x2b,0x641,0xe2,0xe3,0x50085,0x6,0x644,0x720,0x624,0x50081,0x6,0x646, + 0xb0d,0x644,0x50081,0x6,0x649,0xb0c,0x624,0x200f9,0x64a,0x200f8,0x64a,0x700f5, + 0x6,0xb8f,0xb0d,0x627,0x646,0x633,0x700f5,0x6,0xb8c,0xb0c,0x627,0x649, + 0x633,0x200f9,0x64b,0x200f8,0x64b,0x700f5,0x6,0xb8e,0xb0d,0x621,0xb8f,0x64a, + 0x700f5,0x6,0xb8b,0xb0c,0x621,0xb8c,0x64a,0x700f5,0x8b,0xb88,0xb0b,0x621, + 0x631,0x64a,0x200f9,0x64c,0x200f8,0x64c,0x700f5,0x6,0xb8d,0xb0d,0x615,0xb8e, + 0x64b,0x700f5,0x6,0xb8a,0xb0c,0x615,0xb8b,0x64b,0x700f5,0x8b,0xb87,0xb0b, + 0x615,0xb88,0x64b,0x200f9,0x64d,0x200f8,0x64d,0x50080,0x22,0x64f,0xb0a,0x112, + 0x200f9,0x60f,0x200f8,0x650,0x500ba,0x8b,0x653,0xb0c,0xe2,0x500a7,0x8b,0x654, + 0xb0b,0x653,0x300f7,0x65c,0x0,0x400fa,0x654,0x655,0x65b,0x200f8,0x655,0x50088, + 0x6,0x658,0xb0d,0xb0c,0x50083,0x6,0x659,0xe3,0x658,0x8000c,0x6,0x724, + 0x1,0x2b,0x659,0xe2,0xe3,0x200f9,0x65c,0x200f8,0x65b,0x200f9,0x65c,0x200f8, + 0x65c,0x700f5,0x6,0xb0e,0x724,0x655,0xe2,0x65b,0x200f9,0x731,0x200f8,0x731, + 0x700f5,0x6,0xb14,0xe2,0x65c,0xb81,0x749,0x700f5,0x22,0xb13,0x36b,0x65c, + 0x74b,0x749,0x500b3,0x8b,0x734,0xb13,0x112,0x400f6,0x74c,0x749,0x0,0x400fa, + 0x734,0x735,0x74c,0x200f8,0x735,0x200f9,0x736,0x200f8,0x736,0x700f5,0x6,0xb81, + 0xb14,0x735,0x792,0x73a,0x700f5,0x22,0xb7d,0x36b,0x735,0x747,0x73a,0x500b3, + 0x8b,0x739,0xb7d,0x112,0x400f6,0x748,0x73a,0x0,0x400fa,0x739,0x73a,0x748, + 0x200f8,0x73a,0x50050,0x35,0x73d,0xb7d,0xb13,0x50080,0x35,0x75f,0x516,0x73d, + 0x50051,0x22,0x761,0x59d,0x0,0x50082,0x22,0x762,0x761,0x112,0x50051,0x22, + 0x764,0x75f,0x0,0x7000c,0x22,0x775,0x1,0x27,0x764,0x762,0x7000c,0x22, + 0x77a,0x1,0x2a,0x10c,0x775,0x50051,0x22,0x769,0x59d,0x1,0x50082,0x22, + 0x76a,0x769,0x112,0x50051,0x22,0x76c,0x75f,0x1,0x7000c,0x22,0x77f,0x1, + 0x27,0x76c,0x76a,0x7000c,0x22,0x784,0x1,0x2a,0x10c,0x77f,0x50050,0x35, + 0xc02,0x77a,0x784,0x4003d,0x13d,0x787,0x13f,0x7005f,0x42,0x789,0x787,0xc02, + 0x2,0x10c,0x50051,0x6,0x78a,0x789,0x0,0x50041,0x12e,0x78b,0x10b,0xbef, + 0x4003d,0x6,0x78c,0x78b,0x50085,0x6,0x78d,0x78a,0x78c,0x7000c,0x6,0x792, + 0x1,0x28,0xb81,0x78d,0x50080,0x22,0x747,0xb7d,0x112,0x200f9,0x736,0x200f8, + 0x748,0x200f9,0x749,0x200f8,0x749,0x50080,0x22,0x74b,0xb13,0x112,0x200f9,0x731, + 0x200f8,0x74c,0x50041,0x122,0x7ab,0x10b,0xbf0,0x4003d,0x12,0x7ac,0x7ab,0x50088, + 0x12,0x7a0,0x7ac,0x55d,0x50083,0x12,0x7a1,0x55e,0x7a0,0x5008e,0x12,0x7b5, + 0x55d,0x1c0,0x4006e,0x35,0x7b6,0x7b5,0x50041,0x10d,0x7c3,0x10b,0xbf1,0x4003d, + 0x35,0x7c4,0x7c3,0x4006f,0x12,0x7be,0x7c4,0x5008e,0x12,0x7bf,0x7be,0x1c0, + 0x4006e,0x35,0x7c0,0x7bf,0x4006f,0x12,0x7d0,0x7b6,0x50085,0x12,0x7d1,0x7a1, + 0x7d0,0x50083,0x12,0x7d4,0x7d0,0x222,0x7000c,0x12,0x7e1,0x1,0x25,0x7d1, + 0x7d4,0x7000c,0x12,0x7e6,0x1,0x28,0x222,0x7e1,0x4006f,0x12,0x7da,0x7c0, + 0x50088,0x12,0x7db,0x7e6,0x7da,0x4003d,0x13d,0x7e9,0x16c,0x4003d,0x151,0x7ea, + 0x153,0x50056,0x155,0x7eb,0x7e9,0x7ea,0x70058,0x42,0x7ed,0x7eb,0x7db,0x2, + 0xe2,0x50051,0x6,0x7ee,0x7ed,0x0,0x50041,0x12e,0x7ef,0x10b,0x521,0x4003d, + 0x6,0x7f0,0x7ef,0x50085,0x6,0x7f1,0x7ee,0x7f0,0x8000c,0x6,0x7f5,0x1, + 0x2b,0x7f1,0xe2,0xe3,0x7000c,0x6,0x7fa,0x1,0x28,0xb14,0x7f5,0x50081, + 0x12,0x812,0x55e,0x5a3,0x50085,0x12,0x815,0x812,0x55d,0x4006e,0x35,0x816, + 0x815,0x4003d,0x13d,0x83e,0x197,0x7005f,0x42,0x840,0x83e,0x816,0x2,0x10c, + 0x50051,0x6,0x841,0x840,0x0,0x4003d,0x13d,0x844,0x190,0x7005f,0x42,0x846, + 0x844,0x816,0x2,0x10c,0x7004f,0x12,0x847,0x846,0x846,0x0,0x1,0x50085, + 0x12,0x84b,0x847,0x1ce,0x6000c,0x6,0x84c,0x1,0x42,0x84b,0x50083,0x6, + 0x862,0x841,0x5d1,0x50088,0x6,0x863,0x5ce,0x862,0x50085,0x6,0x858,0x863, + 0x662,0x7000c,0x6,0x89c,0x1,0x28,0x858,0x5fe,0x500b7,0x8b,0x890,0x89c, + 0xe2,0x300f7,0x896,0x0,0x400fa,0x890,0x891,0x895,0x200f8,0x891,0x7000c,0x6, + 0x8a1,0x1,0x25,0x858,0x5fe,0x50088,0x6,0x894,0x8a1,0x89c,0x200f9,0x896, + 0x200f8,0x895,0x200f9,0x896,0x200f8,0x896,0x700f5,0x6,0xb1c,0x894,0x891,0xe2, + 0x895,0x50085,0x6,0x82c,0x680,0xbb8,0x8000c,0x6,0x8a5,0x1,0x2b,0x82c, + 0xe2,0xe3,0x50088,0x6,0x830,0x84c,0x680,0x8000c,0x6,0x8a9,0x1,0x2b, + 0x830,0xe2,0xe3,0x50083,0x6,0x832,0xe3,0x8a9,0x50085,0x6,0x834,0x832, + 0xb1c,0x50085,0x6,0x836,0x834,0x8a5,0x4003d,0x13d,0x8bd,0x14b,0x50067,0x35, + 0x8be,0x8bd,0x10c,0x50083,0x12,0x8ce,0x55d,0x222,0x7000c,0x12,0x8db,0x1, + 0x25,0x55b,0x8ce,0x7000c,0x12,0x8e0,0x1,0x28,0x222,0x8db,0x4006f,0x12, + 0x8d4,0x8be,0x50088,0x12,0x8d5,0x8e0,0x8d4,0x4003d,0x13d,0x8e3,0x14b,0x4003d, + 0x151,0x8e4,0x153,0x50056,0x155,0x8e5,0x8e3,0x8e4,0x70058,0x42,0x8e7,0x8e5, + 0x8d5,0x2,0xe2,0x50051,0x6,0x8e8,0x8e7,0x0,0x7000c,0x6,0x8ed,0x1, + 0x28,0x836,0x8e8,0x50051,0x6,0x932,0x812,0x0,0x500be,0x8b,0x933,0x932, + 0xe2,0x300f7,0x938,0x0,0x400fa,0x933,0x934,0x938,0x200f8,0x934,0x500bc,0x8b, + 0x937,0x932,0xe3,0x200f9,0x938,0x200f8,0x938,0x700f5,0x8b,0x939,0x933,0x896, + 0x937,0x934,0x300f7,0x944,0x0,0x400fa,0x939,0x93a,0x944,0x200f8,0x93a,0x50051, + 0x6,0x93c,0x812,0x1,0x500be,0x8b,0x93d,0x93c,0xe2,0x300f7,0x942,0x0, + 0x400fa,0x93d,0x93e,0x942,0x200f8,0x93e,0x500bc,0x8b,0x941,0x93c,0xe3,0x200f9, + 0x942,0x200f8,0x942,0x700f5,0x8b,0x943,0x93d,0x93a,0x941,0x93e,0x200f9,0x944, + 0x200f8,0x944,0x700f5,0x8b,0x945,0x939,0x938,0x943,0x942,0x300f7,0x914,0x0, + 0x400fa,0x945,0x90c,0x914,0x200f8,0x90c,0x50041,0x10d,0x948,0x10b,0x112,0x4003d, + 0x35,0x949,0x948,0x4006f,0x12,0x959,0x949,0x50085,0x12,0x95a,0x812,0x959, + 0x50083,0x12,0x95d,0x959,0x222,0x7000c,0x12,0x96a,0x1,0x25,0x95a,0x95d, + 0x7000c,0x12,0x96f,0x1,0x28,0x222,0x96a,0x50088,0x12,0x964,0x96f,0x7be, + 0x4003d,0x13d,0x972,0x15c,0x4003d,0x151,0x973,0x153,0x50056,0x155,0x974,0x972, + 0x973,0x70058,0x42,0x976,0x974,0x964,0x2,0xe2,0x50051,0x6,0x977,0x976, + 0x0,0x8000c,0x6,0x97b,0x1,0x2b,0x977,0xe2,0xe3,0x200f9,0x914,0x200f8, + 0x914,0x700f5,0x6,0xb29,0xe2,0x944,0x97b,0x90c,0x50041,0x12e,0x97e,0x10b, + 0x3ad,0x4003d,0x6,0x97f,0x97e,0x8000c,0x6,0x985,0x1,0x2e,0xb29,0xe2, + 0x7fa,0x50041,0x12e,0x988,0x10b,0xbf2,0x4003d,0x6,0x989,0x988,0x7000c,0x6, + 0x98e,0x1,0x25,0x989,0x985,0x8000c,0x6,0x994,0x1,0x2e,0x985,0x98e, + 0xb0e,0x50085,0x6,0x921,0x994,0x1b4,0x6000c,0x6,0x922,0x1,0x1,0x921, + 0x500ba,0x8b,0x923,0x922,0xe3,0x600a9,0x6,0x924,0x923,0xe3,0xe2,0x50085, + 0x6,0x926,0x994,0x924,0x50081,0x6,0x929,0x926,0x97f,0x8000c,0x6,0x998, + 0x1,0x2b,0x929,0xe2,0xe3,0x4003d,0x165,0x99a,0x167,0x70050,0x42,0x99d, + 0x998,0xe2,0xe2,0xe2,0x40063,0x99a,0x516,0x99d,0x70050,0x42,0xc00,0x8ed, + 0xb0e,0x7fa,0x926,0x4003d,0x1ab,0x99f,0x1ad,0x40063,0x99f,0x516,0xc00,0x3003e, + 0x9aa,0x3b4,0x3003e,0x9be,0x431,0x3003e,0x9bf,0x431,0x300f7,0xa36,0x0,0x300fb, + 0x143,0x9c2,0x200f8,0x9c2,0x200f9,0x9c3,0x200f8,0x9c3,0x700f5,0x6,0xb5f,0x2f4, + 0x9c2,0xa89,0x9c7,0x700f5,0x6,0xb5a,0x3a1,0x9c2,0xa84,0x9c7,0x700f5,0x22, + 0xb49,0x10c,0x9c2,0x9e0,0x9c7,0x500b1,0x8b,0x9c6,0xb49,0x3aa,0x400f6,0x9e1, + 0x9c7,0x0,0x400fa,0x9c6,0x9c7,0x9e1,0x200f8,0x9c7,0x50041,0x4d,0x9cb,0x9aa, + 0xb49,0x4003d,0x35,0x9cc,0x9cb,0x50080,0x35,0xa49,0x516,0x9cc,0x50051,0x22, + 0xa4b,0x59d,0x0,0x50082,0x22,0xa4c,0xa4b,0x112,0x50051,0x22,0xa4e,0xa49, + 0x0,0x7000c,0x22,0xa5f,0x1,0x27,0xa4e,0xa4c,0x7000c,0x22,0xa64,0x1, + 0x2a,0x10c,0xa5f,0x50051,0x22,0xa53,0x59d,0x1,0x50082,0x22,0xa54,0xa53, + 0x112,0x50051,0x22,0xa56,0xa49,0x1,0x7000c,0x22,0xa69,0x1,0x27,0xa56, + 0xa54,0x7000c,0x22,0xa6e,0x1,0x2a,0x10c,0xa69,0x50050,0x35,0xc01,0xa64, + 0xa6e,0x4003d,0x13d,0xa71,0x179,0x7005f,0x42,0xa73,0xa71,0xc01,0x2,0x10c, + 0x50051,0x6,0xa74,0xa73,0x0,0x4003d,0x13d,0xa78,0x19f,0x7005f,0x42,0xa79, + 0xa78,0x1a1,0x2,0x10c,0x50051,0x6,0xa7a,0xa79,0x0,0x500b4,0x8b,0xa7c, + 0xa7a,0xe2,0x600a9,0x6,0xbb9,0xa7c,0xe3,0xa7a,0x50085,0x6,0x9d2,0xa74, + 0xbb9,0x50041,0x7,0x9d3,0x9ac,0xb49,0x3003e,0x9d3,0x9d2,0x4003d,0x6,0x9d7, + 0x9d3,0x7000c,0x6,0xa84,0x1,0x25,0xb5a,0x9d7,0x4003d,0x6,0x9dc,0x9d3, + 0x7000c,0x6,0xa89,0x1,0x28,0xb5f,0x9dc,0x50080,0x22,0x9e0,0xb49,0x112, + 0x200f9,0x9c3,0x200f8,0x9e1,0x200f9,0x9e2,0x200f8,0x9e2,0x700f5,0x22,0xb75,0x112, + 0x9e1,0xa09,0xa05,0x700f5,0xab,0xb50,0x1f0,0x9e1,0xba3,0xa05,0x700f5,0x6, + 0xb4c,0x3a1,0x9e1,0xba2,0xa05,0x700f5,0x6,0xb4b,0xe2,0x9e1,0xba1,0xa05, + 0x700f5,0x22,0xb4a,0x112,0x9e1,0xa07,0xa05,0x500b1,0x8b,0x9e5,0xb4a,0x3aa, + 0x400f6,0xa0a,0xa05,0x0,0x400fa,0x9e5,0x9e6,0xa0a,0x200f8,0x9e6,0x50041,0x7, + 0x9e8,0x9ac,0xb4a,0x4003d,0x6,0x9e9,0x9e8,0x50041,0x7,0x9ea,0x9ac,0x10c, + 0x4003d,0x6,0x9eb,0x9ea,0x50083,0x6,0x9ec,0x9e9,0x9eb,0x6000c,0x6,0x9ed, + 0x1,0x4,0x9ec,0x50083,0x6,0x9f0,0xb5f,0xb5a,0x50088,0x6,0x9f1,0x9ed, + 0x9f0,0x500b8,0x8b,0x9f3,0x9f1,0x3f4,0x300f7,0xa04,0x0,0x400fa,0x9f3,0x9f4, + 0x9f9,0x200f8,0x9f4,0x500c4,0xab,0x9f6,0x1f0,0xb75,0x500c5,0xab,0x9f8,0xb50, + 0x9f6,0x200f9,0xa04,0x200f8,0x9f9,0x4003d,0x6,0x9fd,0x9e8,0x7000c,0x6,0xa8e, + 0x1,0x25,0xb4c,0x9fd,0x4003d,0x6,0xa02,0x9e8,0x7000c,0x6,0xa93,0x1, + 0x28,0xb4b,0xa02,0x200f9,0xa04,0x200f8,0xa04,0x700f5,0xab,0xba3,0x9f8,0x9f4, + 0xb50,0x9f9,0x700f5,0x6,0xba2,0xb4c,0x9f4,0xa8e,0x9f9,0x700f5,0x6,0xba1, + 0xb4b,0x9f4,0xa93,0x9f9,0x200f9,0xa05,0x200f8,0xa05,0x50080,0x22,0xa07,0xb4a, + 0x112,0x50080,0x22,0xa09,0xb75,0x112,0x200f9,0x9e2,0x200f8,0xa0a,0x50041,0x7, + 0xa0b,0x9ac,0x10c,0x4003d,0x6,0xa0c,0xa0b,0x500ba,0x8b,0xa0e,0xa0c,0xb4b, + 0x400a8,0x8b,0xa0f,0xa0e,0x300f7,0xa15,0x0,0x400fa,0xa0f,0xa10,0xa15,0x200f8, + 0xa10,0x4003d,0x6,0xa12,0xa0b,0x500b8,0x8b,0xa14,0xa12,0xb4c,0x200f9,0xa15, + 0x200f8,0xa15,0x700f5,0x8b,0xa16,0xa0e,0xa0a,0xa14,0xa10,0x400a8,0x8b,0xa18, + 0xa16,0x300f7,0xa1a,0x0,0x400fa,0xa18,0xa19,0xa1a,0x200f8,0xa19,0x200f9,0xa36, + 0x200f8,0xa1a,0x200f9,0xa1b,0x200f8,0xa1b,0x700f5,0x22,0xb4d,0x10c,0xa1a,0xa2e, + 0xa2c,0x4007c,0xab,0xa1e,0xb4d,0x500b0,0x8b,0xa1f,0xa1e,0xac,0x400f6,0xa2f, + 0xa2c,0x0,0x400fa,0xa1f,0xa20,0xa2f,0x200f8,0xa20,0x50041,0x3dc,0xa23,0x9be, + 0xb4d,0x4003d,0xab,0xa24,0xa23,0x500c7,0xab,0xa25,0xb50,0xa24,0x50041,0x3dc, + 0xa27,0x9bf,0xb4d,0x4003d,0xab,0xa28,0xa27,0x500aa,0x8b,0xa29,0xa25,0xa28, + 0x300f7,0xa2b,0x0,0x400fa,0xa29,0xa2a,0xa2b,0x200f8,0xa2a,0x200f9,0xa2f,0x200f8, + 0xa2b,0x200f9,0xa2c,0x200f8,0xa2c,0x50080,0x22,0xa2e,0xb4d,0x112,0x200f9,0xa1b, + 0x200f8,0xa2f,0x700f5,0x6,0xb61,0xb6d,0xa1b,0xe2,0xa2a,0x700f5,0x8b,0xb51, + 0x41c,0xa1b,0x2c0,0xa2a,0x300f7,0xa31,0x0,0x400fa,0xb51,0xa36,0xa31,0x200f8, + 0xa31,0x50088,0x6,0xa34,0xb5a,0xb5f,0x50083,0x6,0xa35,0xe3,0xa34,0x200f9, + 0xa36,0x200f8,0xa36,0x900f5,0x6,0xb60,0xe2,0xa19,0xb61,0xa2f,0xa35,0xa31, + 0x500ba,0x8b,0x593,0xb60,0x506,0x300f7,0x599,0x0,0x400fa,0x593,0x594,0x599, + 0x200f8,0x594,0x50083,0x12,0xa9e,0x55b,0x7ac,0x50088,0x12,0xaa2,0xa9e,0x55d, + 0x50041,0x10d,0xab4,0x10b,0x11c,0x4003d,0x35,0xab5,0xab4,0x4006f,0x12,0xaa4, + 0xab5,0x50085,0x12,0xaa5,0xaa2,0xaa4,0x6000c,0x12,0xaa7,0x1,0x8,0xaa5, + 0x4006e,0x35,0xaa8,0xaa7,0x4003d,0x165,0xab7,0x180,0x70050,0x42,0xaba,0xb60, + 0xe2,0xe2,0xe2,0x40063,0xab7,0xaa8,0xaba,0x200f9,0x599,0x200f8,0x599,0x100fd, + 0x10038, +}; +static const char *fu0_prepare_reactivity_pass_0_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu0_prepare_reactivity_pass_0_cb_bind[] = {12}; +static const uint32_t fu0_prepare_reactivity_pass_0_cb_count[] = {1}; +static const uint32_t fu0_prepare_reactivity_pass_0_cb_space[] = {0}; +static const char *fu0_prepare_reactivity_pass_0_srv_tex_names[] = {"r_reconstructed_previous_nearest_depth", "r_dilated_motion_vectors", "r_dilated_depth", "r_reactive_mask", "r_transparency_and_composition_mask", "r_accumulation", "r_shading_change", "r_current_luma", "r_input_exposure"}; +static const uint32_t fu0_prepare_reactivity_pass_0_srv_tex_bind[] = {0, 1, 2, 3, 4, 5, 6, 7, 8}; +static const uint32_t fu0_prepare_reactivity_pass_0_srv_tex_count[] = {1, 1, 1, 1, 1, 1, 1, 1, 1}; +static const uint32_t fu0_prepare_reactivity_pass_0_srv_tex_space[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; +static const char *fu0_prepare_reactivity_pass_0_uav_tex_names[] = {"rw_dilated_reactive_masks", "rw_new_locks", "rw_accumulation"}; +static const uint32_t fu0_prepare_reactivity_pass_0_uav_tex_bind[] = {9, 10, 11}; +static const uint32_t fu0_prepare_reactivity_pass_0_uav_tex_count[] = {1, 1, 1}; +static const uint32_t fu0_prepare_reactivity_pass_0_uav_tex_space[] = {0, 0, 0}; +static const char *fu0_prepare_reactivity_pass_0_sampler_names[] = {"s_LinearClamp"}; +static const uint32_t fu0_prepare_reactivity_pass_0_sampler_bind[] = {1001}; +static const uint32_t fu0_prepare_reactivity_pass_0_sampler_count[] = {1}; +static const uint32_t fu0_prepare_reactivity_pass_0_sampler_space[] = {0}; + +static const uint32_t fu0_luma_instability_pass_0_spv[1578] = { + 0x7230203,0x10500,0x8000b,0x57d,0x0,0x20011,0x1,0x20011,0x31,0x20011,0x32,0x6000b, + 0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0xf000f,0x5,0x4,0x6e69616d, + 0x0,0x95,0xb9,0xbf,0xc3,0xda,0xe5,0xea,0xf2,0xfe,0x264,0x60010, + 0x4,0x11,0x8,0x8,0x1,0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61, + 0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0,0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72, + 0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79, + 0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669, + 0x40005,0x4,0x6e69616d,0x0,0x70005,0x93,0x53466263,0x50553352,0x4c414353,0x745f5245,0x0,0x60006, + 0x93,0x0,0x6e655269,0x53726564,0x657a69,0xa0006,0x93,0x1,0x65725069,0x756f6976,0x61724673,0x6552656d, + 0x7265646e,0x657a6953,0x0,0x70006,0x93,0x2,0x78614d69,0x646e6552,0x69537265,0x657a,0x50006,0x93, + 0x3,0x74694a66,0x726574,0x90006,0x93,0x4,0x65725066,0x756f6976,0x61724673,0x694a656d,0x72657474,0x0, + 0x80006,0x93,0x5,0x6c654466,0x72506174,0x70784565,0x7275736f,0x65,0x60005,0x95,0x53466263,0x70553352, + 0x6c616373,0x7265,0x60005,0xb9,0x6c5f7772,0x5f616d75,0x74736968,0x79726f,0x60005,0xbf,0x756c5f72,0x685f616d, + 0x6f747369,0x7972,0x60005,0xc3,0x694c5f73,0x7261656e,0x6d616c43,0x70,0x60005,0xda,0x75635f72,0x6e657272, + 0x756c5f74,0x616d,0x70005,0xe5,0x6c5f7772,0x5f616d75,0x74736e69,0x6c696261,0x797469,0x90005,0xea,0x69645f72, + 0x6574616c,0x6f6d5f64,0x6e6f6974,0x6365765f,0x73726f74,0x0,0x70005,0xf2,0x6e695f72,0x5f747570,0x6f707865,0x65727573, + 0x0,0x90005,0xfe,0x69645f72,0x6574616c,0x65725f64,0x69746361,0x6d5f6576,0x736b7361,0x0,0x80005,0x264, + 0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x44,0x30047,0x93,0x2,0x50048,0x93,0x0, + 0x23,0x0,0x50048,0x93,0x1,0x23,0x8,0x50048,0x93,0x2,0x23,0x20, + 0x50048,0x93,0x3,0x23,0x40,0x50048,0x93,0x4,0x23,0x48,0x50048,0x93, + 0x5,0x23,0x74,0x40047,0x95,0x21,0x9,0x40047,0x95,0x22,0x0,0x40047, + 0xb9,0x21,0x7,0x40047,0xb9,0x22,0x0,0x40047,0xbf,0x21,0x4,0x40047, + 0xbf,0x22,0x0,0x40047,0xc3,0x21,0x3e9,0x40047,0xc3,0x22,0x0,0x40047, + 0xda,0x21,0x6,0x40047,0xda,0x22,0x0,0x40047,0xe5,0x21,0x8,0x40047, + 0xe5,0x22,0x0,0x40047,0xea,0x21,0x2,0x40047,0xea,0x22,0x0,0x40047, + 0xf2,0x21,0x0,0x40047,0xf2,0x22,0x0,0x40047,0xfe,0x21,0x1,0x40047, + 0xfe,0x22,0x0,0x40047,0x264,0xb,0x1c,0x40047,0x279,0xb,0x19,0x20013, + 0x2,0x30021,0x3,0x2,0x30016,0x6,0x20,0x40020,0x7,0x7,0x6,0x40017, + 0x11,0x6,0x2,0x40015,0x20,0x20,0x1,0x40017,0x21,0x20,0x2,0x40017, + 0x32,0x6,0x4,0x40020,0x33,0x7,0x32,0x20014,0x62,0x4002b,0x6,0x7a, + 0x0,0x4002b,0x6,0x7b,0x3f800000,0x8001e,0x93,0x21,0x21,0x21,0x11,0x11, + 0x6,0x40020,0x94,0x2,0x93,0x4003b,0x94,0x95,0x2,0x4002b,0x20,0x96, + 0x0,0x40020,0x97,0x2,0x21,0x4002b,0x20,0x9c,0x1,0x40020,0xa7,0x2, + 0x11,0x40020,0xb2,0x2,0x6,0x90019,0xb7,0x6,0x1,0x0,0x0,0x0, + 0x2,0x2,0x40020,0xb8,0x0,0xb7,0x4003b,0xb8,0xb9,0x0,0x90019,0xbd, + 0x6,0x1,0x0,0x0,0x0,0x1,0x0,0x40020,0xbe,0x0,0xbd,0x4003b, + 0xbe,0xbf,0x0,0x2001a,0xc1,0x40020,0xc2,0x0,0xc1,0x4003b,0xc2,0xc3, + 0x0,0x3001b,0xc5,0xbd,0x40015,0xd5,0x20,0x0,0x4002b,0xd5,0xd6,0x0, + 0x4003b,0xbe,0xda,0x0,0x90019,0xe3,0x6,0x1,0x0,0x0,0x0,0x2, + 0x9,0x40020,0xe4,0x0,0xe3,0x4003b,0xe4,0xe5,0x0,0x4003b,0xbe,0xea, + 0x0,0x4003b,0xbe,0xf2,0x0,0x5002c,0x21,0xf4,0x96,0x96,0x4003b,0xbe, + 0xfe,0x0,0x4002b,0x6,0x107,0x45700000,0x4002b,0x6,0x108,0x45070000,0x5002c,0x11, + 0x109,0x107,0x108,0x4002b,0xd5,0x13d,0x1,0x4002b,0x6,0x150,0x3f000000,0x5002c, + 0x11,0x151,0x150,0x150,0x4002b,0x20,0x17d,0x3,0x4002b,0xd5,0x19d,0x2, + 0x4002b,0xd5,0x1a0,0x3,0x7002c,0x32,0x1bc,0x7a,0x7a,0x7a,0x7a,0x4002b, + 0x6,0x204,0x3f666666,0x40017,0x262,0xd5,0x3,0x40020,0x263,0x1,0x262,0x4003b, + 0x263,0x264,0x1,0x40017,0x265,0xd5,0x2,0x4002b,0xd5,0x278,0x8,0x6002c, + 0x262,0x279,0x278,0x278,0x13d,0x4002b,0x6,0x56f,0x3d4ccccd,0x4002b,0xd5,0x57b, + 0x4,0x4002b,0xd5,0x57c,0x5,0x50036,0x2,0x4,0x0,0x3,0x200f8,0x5, + 0x4003b,0x33,0x4f9,0x7,0x4003d,0x262,0x266,0x264,0x7004f,0x265,0x267,0x266, + 0x266,0x0,0x1,0x4007c,0x21,0x268,0x267,0x4003d,0xbd,0x320,0xea,0x7005f, + 0x32,0x322,0x320,0x268,0x2,0x96,0x7004f,0x11,0x323,0x322,0x322,0x0, + 0x1,0x4006f,0x11,0x2b3,0x268,0x50081,0x11,0x2b5,0x2b3,0x151,0x50041,0x97, + 0x326,0x95,0x96,0x4003d,0x21,0x327,0x326,0x4006f,0x11,0x2b7,0x327,0x50088, + 0x11,0x2b8,0x2b5,0x2b7,0x50041,0xa7,0x32a,0x95,0x1a0,0x4003d,0x11,0x32b, + 0x32a,0x50088,0x11,0x2bd,0x32b,0x2b7,0x50081,0x11,0x2be,0x2b8,0x2bd,0x50041, + 0xa7,0x332,0x95,0x57b,0x4003d,0x11,0x333,0x332,0x50041,0x97,0x336,0x95, + 0x9c,0x4003d,0x21,0x337,0x336,0x4006f,0x11,0x2c2,0x337,0x50088,0x11,0x2c3, + 0x333,0x2c2,0x50081,0x11,0x2c4,0x2b8,0x2c3,0x50081,0x11,0x2c7,0x2c4,0x323, + 0x50051,0x6,0x33b,0x2c7,0x0,0x500be,0x62,0x33c,0x33b,0x7a,0x300f7,0x341, + 0x0,0x400fa,0x33c,0x33d,0x341,0x200f8,0x33d,0x500bc,0x62,0x340,0x33b,0x7b, + 0x200f9,0x341,0x200f8,0x341,0x700f5,0x62,0x342,0x33c,0x5,0x340,0x33d,0x300f7, + 0x34d,0x0,0x400fa,0x342,0x343,0x34d,0x200f8,0x343,0x50051,0x6,0x345,0x2c7, + 0x1,0x500be,0x62,0x346,0x345,0x7a,0x300f7,0x34b,0x0,0x400fa,0x346,0x347, + 0x34b,0x200f8,0x347,0x500bc,0x62,0x34a,0x345,0x7b,0x200f9,0x34b,0x200f8,0x34b, + 0x700f5,0x62,0x34c,0x346,0x343,0x34a,0x347,0x200f9,0x34d,0x200f8,0x34d,0x700f5, + 0x62,0x34e,0x342,0x341,0x34c,0x34b,0x300f7,0x315,0x0,0x400fa,0x34e,0x2ca, + 0x315,0x200f8,0x2ca,0x50041,0x97,0x355,0x95,0x19d,0x4003d,0x21,0x356,0x355, + 0x50085,0x11,0x363,0x2be,0x2b7,0x50083,0x11,0x366,0x2b7,0x151,0x7000c,0x11, + 0x373,0x1,0x25,0x363,0x366,0x7000c,0x11,0x378,0x1,0x28,0x151,0x373, + 0x4006f,0x11,0x36c,0x356,0x50088,0x11,0x36d,0x378,0x36c,0x4003d,0xbd,0x37b, + 0xfe,0x4003d,0xc1,0x37c,0xc3,0x50056,0xc5,0x37d,0x37b,0x37c,0x70058,0x32, + 0x37f,0x37d,0x36d,0x2,0x7a,0x50051,0x6,0x2d2,0x37f,0x0,0x8000c,0x6, + 0x383,0x1,0x2b,0x2d2,0x7a,0x7b,0x50051,0x6,0x2d5,0x37f,0x1,0x8000c, + 0x6,0x387,0x1,0x2b,0x2d5,0x7a,0x7b,0x50051,0x6,0x2d8,0x37f,0x2, + 0x8000c,0x6,0x38b,0x1,0x2b,0x2d8,0x7a,0x7b,0x50051,0x6,0x2db,0x37f, + 0x3,0x8000c,0x6,0x38f,0x1,0x2b,0x2db,0x7a,0x7b,0x500ba,0x62,0x2de, + 0x38f,0x204,0x300f7,0x314,0x0,0x400fa,0x2de,0x2e1,0x314,0x200f8,0x2e1,0x4003d, + 0xbd,0x3bc,0xda,0x4003d,0xc1,0x3bd,0xc3,0x50056,0xc5,0x3be,0x3bc,0x3bd, + 0x70058,0x32,0x3c0,0x3be,0x36d,0x2,0x7a,0x50051,0x6,0x3c1,0x3c0,0x0, + 0x4003d,0xbd,0x3c5,0xf2,0x7005f,0x32,0x3c6,0x3c5,0xf4,0x2,0x96,0x50051, + 0x6,0x3c7,0x3c6,0x0,0x500b4,0x62,0x3c9,0x3c7,0x7a,0x600a9,0x6,0x570, + 0x3c9,0x7b,0x3c7,0x50085,0x6,0x2e9,0x3c1,0x570,0x50085,0x11,0x3e1,0x2c7, + 0x2c2,0x50083,0x11,0x3e4,0x2c2,0x151,0x7000c,0x11,0x3f1,0x1,0x25,0x3e1, + 0x3e4,0x7000c,0x11,0x3f6,0x1,0x28,0x151,0x3f1,0x50088,0x11,0x3eb,0x3f6, + 0x36c,0x4003d,0xbd,0x3f9,0xbf,0x4003d,0xc1,0x3fa,0xc3,0x50056,0xc5,0x3fb, + 0x3f9,0x3fa,0x70058,0x32,0x3fd,0x3fb,0x3eb,0x2,0x7a,0x50041,0xb2,0x400, + 0x95,0x57c,0x4003d,0x6,0x401,0x400,0x5008e,0x32,0x2f1,0x3fd,0x401,0x4003d, + 0xbd,0x405,0xf2,0x7005f,0x32,0x406,0x405,0xf4,0x2,0x96,0x50051,0x6, + 0x407,0x406,0x0,0x500b4,0x62,0x409,0x407,0x7a,0x600a9,0x6,0x571,0x409, + 0x7b,0x407,0x5008e,0x32,0x2f3,0x2f1,0x571,0x3003e,0x4f9,0x2f3,0x50041,0x7, + 0x4fd,0x4f9,0xd6,0x4003d,0x6,0x44c,0x4fd,0x50083,0x6,0x44d,0x2e9,0x44c, + 0x4003d,0x6,0x450,0x4fd,0x7000c,0x6,0x4a7,0x1,0x28,0x2e9,0x450,0x500b7, + 0x62,0x49b,0x4a7,0x7a,0x300f7,0x4a1,0x0,0x400fa,0x49b,0x49c,0x4a0,0x200f8, + 0x49c,0x7000c,0x6,0x4ac,0x1,0x25,0x2e9,0x450,0x50088,0x6,0x49f,0x4ac, + 0x4a7,0x200f9,0x4a1,0x200f8,0x4a0,0x200f9,0x4a1,0x200f8,0x4a1,0x700f5,0x6,0x51d, + 0x49f,0x49c,0x7b,0x4a0,0x500b8,0x62,0x454,0x51d,0x7b,0x300f7,0x477,0x0, + 0x400fa,0x454,0x455,0x477,0x200f8,0x455,0x200f9,0x456,0x200f8,0x456,0x700f5,0x6, + 0x51f,0x51d,0x455,0x55d,0x46f,0x700f5,0x20,0x51e,0x9c,0x455,0x471,0x46f, + 0x500b3,0x62,0x459,0x51e,0x17d,0x400f6,0x472,0x46f,0x0,0x400fa,0x459,0x45a, + 0x472,0x200f8,0x45a,0x50041,0x7,0x4ff,0x4f9,0x51e,0x4003d,0x6,0x45e,0x4ff, + 0x50083,0x6,0x45f,0x2e9,0x45e,0x4003d,0x6,0x463,0x4ff,0x7000c,0x6,0x4c3, + 0x1,0x28,0x2e9,0x463,0x500b7,0x62,0x4b7,0x4c3,0x7a,0x300f7,0x4bd,0x0, + 0x400fa,0x4b7,0x4b8,0x4bc,0x200f8,0x4b8,0x7000c,0x6,0x4c8,0x1,0x25,0x2e9, + 0x463,0x50088,0x6,0x4bb,0x4c8,0x4c3,0x200f9,0x4bd,0x200f8,0x4bc,0x200f9,0x4bd, + 0x200f8,0x4bd,0x700f5,0x6,0x555,0x4bb,0x4b8,0x7a,0x4bc,0x6000c,0x6,0x466, + 0x1,0x6,0x44d,0x6000c,0x6,0x468,0x1,0x6,0x45f,0x500b4,0x62,0x469, + 0x466,0x468,0x300f7,0x46e,0x0,0x400fa,0x469,0x46a,0x46e,0x200f8,0x46a,0x7000c, + 0x6,0x4cd,0x1,0x28,0x51f,0x555,0x200f9,0x46e,0x200f8,0x46e,0x700f5,0x6, + 0x55d,0x51f,0x4bd,0x4cd,0x46a,0x200f9,0x46f,0x200f8,0x46f,0x50080,0x20,0x471, + 0x51e,0x9c,0x200f9,0x456,0x200f8,0x472,0x500ba,0x62,0x475,0x51f,0x51d,0x600a9, + 0x6,0x476,0x475,0x7b,0x7a,0x200f9,0x477,0x200f8,0x477,0x700f5,0x6,0x526, + 0x7a,0x4a1,0x476,0x472,0x50041,0x7,0x501,0x4f9,0x19d,0x4003d,0x6,0x479, + 0x501,0x50041,0x7,0x502,0x4f9,0x1a0,0x3003e,0x502,0x479,0x50041,0x7,0x503, + 0x4f9,0x13d,0x4003d,0x6,0x47c,0x503,0x3003e,0x501,0x47c,0x4003d,0x6,0x47f, + 0x4fd,0x3003e,0x503,0x47f,0x3003e,0x4fd,0x2e9,0x4003d,0xbd,0x4d1,0xf2,0x7005f, + 0x32,0x4d2,0x4d1,0xf4,0x2,0x96,0x50051,0x6,0x4d3,0x4d2,0x0,0x500b4, + 0x62,0x4d5,0x4d3,0x7a,0x600a9,0x6,0x572,0x4d5,0x7b,0x4d3,0x4003d,0x32, + 0x485,0x4f9,0x70050,0x32,0x486,0x572,0x572,0x572,0x572,0x50088,0x32,0x487, + 0x485,0x486,0x3003e,0x4f9,0x487,0x4003d,0x6,0x48b,0x502,0x500b7,0x62,0x48c, + 0x48b,0x7a,0x600a9,0x6,0x48d,0x48c,0x7b,0x7a,0x50085,0x6,0x48e,0x526, + 0x48d,0x50085,0x11,0x4dc,0x323,0x109,0x6000c,0x6,0x4dd,0x1,0x42,0x4dc, + 0x50085,0x6,0x303,0x4dd,0x56f,0x8000c,0x6,0x4e1,0x1,0x2b,0x303,0x7a, + 0x7b,0x50083,0x6,0x305,0x7b,0x4e1,0x50083,0x6,0x308,0x7b,0x387,0x50085, + 0x6,0x309,0x305,0x308,0x50083,0x6,0x30b,0x7b,0x383,0x50085,0x6,0x30c, + 0x309,0x30b,0x50083,0x6,0x30e,0x7b,0x38b,0x50085,0x6,0x30f,0x30c,0x30e, + 0x50085,0x6,0x312,0x48e,0x30f,0x200f9,0x314,0x200f8,0x314,0x700f5,0x6,0x554, + 0x7a,0x2ca,0x312,0x477,0x700f5,0x32,0x552,0x1bc,0x2ca,0x487,0x477,0x200f9, + 0x315,0x200f8,0x315,0x700f5,0x6,0x553,0x7a,0x34d,0x554,0x314,0x700f5,0x32, + 0x54e,0x1bc,0x34d,0x552,0x314,0x4003d,0xb7,0x4e3,0xb9,0x40063,0x4e3,0x268, + 0x54e,0x4003d,0xe3,0x4e7,0xe5,0x70050,0x32,0x4ea,0x553,0x7a,0x7a,0x7a, + 0x40063,0x4e7,0x268,0x4ea,0x100fd,0x10038, +}; +static const char *fu0_luma_instability_pass_0_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu0_luma_instability_pass_0_cb_bind[] = {9}; +static const uint32_t fu0_luma_instability_pass_0_cb_count[] = {1}; +static const uint32_t fu0_luma_instability_pass_0_cb_space[] = {0}; +static const char *fu0_luma_instability_pass_0_srv_tex_names[] = {"r_input_exposure", "r_dilated_reactive_masks", "r_dilated_motion_vectors", "r_luma_history", "r_current_luma"}; +static const uint32_t fu0_luma_instability_pass_0_srv_tex_bind[] = {0, 1, 2, 4, 6}; +static const uint32_t fu0_luma_instability_pass_0_srv_tex_count[] = {1, 1, 1, 1, 1}; +static const uint32_t fu0_luma_instability_pass_0_srv_tex_space[] = {0, 0, 0, 0, 0}; +static const char *fu0_luma_instability_pass_0_uav_tex_names[] = {"rw_luma_history", "rw_luma_instability"}; +static const uint32_t fu0_luma_instability_pass_0_uav_tex_bind[] = {7, 8}; +static const uint32_t fu0_luma_instability_pass_0_uav_tex_count[] = {1, 1}; +static const uint32_t fu0_luma_instability_pass_0_uav_tex_space[] = {0, 0}; +static const char *fu0_luma_instability_pass_0_sampler_names[] = {"s_LinearClamp"}; +static const uint32_t fu0_luma_instability_pass_0_sampler_bind[] = {1001}; +static const uint32_t fu0_luma_instability_pass_0_sampler_count[] = {1}; +static const uint32_t fu0_luma_instability_pass_0_sampler_space[] = {0}; + +static const uint32_t fu0_accumulate_pass_0_spv[4762] = { + 0x7230203,0x10500,0x8000b,0x18ab,0x0,0x20011,0x1,0x20011,0x31,0x20011,0x32,0x20011, + 0x38,0x6000b,0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0x12000f,0x5, + 0x4,0x6e69616d,0x0,0x160,0x193,0x19a,0x19e,0x1a8,0x1ae,0x1b6,0x1c5,0x1d0, + 0x1db,0x1e3,0x1ef,0x7bb,0x60010,0x4,0x11,0x8,0x8,0x1,0x30003,0x2, + 0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0, + 0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004, + 0x455f4c47,0x735f5458,0x65646168,0x6d695f72,0x5f656761,0x64616f6c,0x726f665f,0x7474616d,0x6465,0xa0004,0x475f4c47,0x4c474f4f, + 0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63, + 0x69645f65,0x74636572,0x657669,0x40005,0x4,0x6e69616d,0x0,0x70005,0x15e,0x53466263,0x50553352,0x4c414353, + 0x745f5245,0x0,0x60006,0x15e,0x0,0x6e655269,0x53726564,0x657a69,0x70006,0x15e,0x1,0x73705569, + 0x656c6163,0x657a6953,0x0,0x70006,0x15e,0x2,0x78614d69,0x646e6552,0x69537265,0x657a,0x50006,0x15e, + 0x3,0x74694a66,0x726574,0x80006,0x15e,0x4,0x776f4466,0x6163736e,0x6146656c,0x726f7463,0x0,0x90006, + 0x15e,0x5,0x74694a66,0x53726574,0x65757165,0x4c65636e,0x74676e65,0x68,0x80006,0x15e,0x6,0x6c654466, + 0x72506174,0x70784565,0x7275736f,0x65,0x60006,0x15e,0x7,0x61724666,0x6e49656d,0x786564,0x70006,0x15e, + 0x8,0x6c655666,0x7469636f,0x63614679,0x726f74,0x60005,0x160,0x53466263,0x70553352,0x6c616373,0x7265,0x80005, + 0x193,0x6e695f72,0x5f747570,0x6f6c6f63,0x696a5f72,0x72657474,0x6465,0x90005,0x19a,0x6e695f72,0x6e726574,0x755f6c61, + 0x61637370,0x5f64656c,0x6f6c6f63,0x72,0x60005,0x19e,0x694c5f73,0x7261656e,0x6d616c43,0x70,0x90005,0x1a8, + 0x695f7772,0x7265746e,0x5f6c616e,0x63737075,0x64656c61,0x6c6f635f,0x726f,0x70005,0x1ae,0x755f7772,0x61637370,0x5f64656c, + 0x7074756f,0x7475,0x80005,0x1b6,0x61665f72,0x65687472,0x645f7473,0x68747065,0x70696d5f,0x31,0x70005,0x1c5, + 0x756c5f72,0x695f616d,0x6174736e,0x696c6962,0x7974,0x60005,0x1d0,0x6e5f7772,0x6c5f7765,0x736b636f,0x0,0x90005, + 0x1db,0x69645f72,0x6574616c,0x6f6d5f64,0x6e6f6974,0x6365765f,0x73726f74,0x0,0x70005,0x1e3,0x6e695f72,0x5f747570, + 0x6f707865,0x65727573,0x0,0x90005,0x1ef,0x69645f72,0x6574616c,0x65725f64,0x69746361,0x6d5f6576,0x736b7361,0x0, + 0x80005,0x7bb,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x44,0x30047,0x15e,0x2,0x50048, + 0x15e,0x0,0x23,0x0,0x50048,0x15e,0x1,0x23,0x10,0x50048,0x15e,0x2, + 0x23,0x20,0x50048,0x15e,0x3,0x23,0x40,0x50048,0x15e,0x4,0x23,0x58, + 0x50048,0x15e,0x5,0x23,0x6c,0x50048,0x15e,0x6,0x23,0x74,0x50048,0x15e, + 0x7,0x23,0x7c,0x50048,0x15e,0x8,0x23,0x80,0x40047,0x160,0x21,0xc, + 0x40047,0x160,0x22,0x0,0x40047,0x193,0x21,0x8,0x40047,0x193,0x22,0x0, + 0x40047,0x19a,0x21,0x3,0x40047,0x19a,0x22,0x0,0x40047,0x19e,0x21,0x3e9, + 0x40047,0x19e,0x22,0x0,0x30047,0x1a8,0x19,0x40047,0x1a8,0x21,0x9,0x40047, + 0x1a8,0x22,0x0,0x30047,0x1ae,0x19,0x40047,0x1ae,0x21,0xa,0x40047,0x1ae, + 0x22,0x0,0x40047,0x1b6,0x21,0x5,0x40047,0x1b6,0x22,0x0,0x40047,0x1c5, + 0x21,0x7,0x40047,0x1c5,0x22,0x0,0x40047,0x1d0,0x21,0xb,0x40047,0x1d0, + 0x22,0x0,0x40047,0x1db,0x21,0x2,0x40047,0x1db,0x22,0x0,0x40047,0x1e3, + 0x21,0x0,0x40047,0x1e3,0x22,0x0,0x40047,0x1ef,0x21,0x1,0x40047,0x1ef, + 0x22,0x0,0x40047,0x7bb,0xb,0x1c,0x40047,0x7cc,0xb,0x19,0x20013,0x2, + 0x30021,0x3,0x2,0x30016,0x6,0x20,0x40017,0xe,0x6,0x3,0x40020,0xf, + 0x7,0xe,0x40017,0x1f,0x6,0x2,0x40015,0x2b,0x20,0x1,0x40017,0x3e, + 0x6,0x4,0x40017,0x4d,0x2b,0x2,0x20014,0x9c,0x4002b,0x6,0x127,0x0, + 0x4002b,0x6,0x128,0x3f800000,0xb001e,0x15e,0x4d,0x4d,0x4d,0x1f,0x1f,0x6, + 0x6,0x6,0x6,0x40020,0x15f,0x2,0x15e,0x4003b,0x15f,0x160,0x2,0x4002b, + 0x2b,0x161,0x0,0x40020,0x162,0x2,0x4d,0x4002b,0x2b,0x16c,0x2,0x40020, + 0x172,0x2,0x1f,0x40020,0x17d,0x2,0x6,0x90019,0x191,0x6,0x1,0x0, + 0x0,0x0,0x1,0x0,0x40020,0x192,0x0,0x191,0x4003b,0x192,0x193,0x0, + 0x4003b,0x192,0x19a,0x0,0x2001a,0x19c,0x40020,0x19d,0x0,0x19c,0x4003b,0x19d, + 0x19e,0x0,0x3001b,0x1a0,0x191,0x90019,0x1a6,0x6,0x1,0x0,0x0,0x0, + 0x2,0x2,0x40020,0x1a7,0x0,0x1a6,0x4003b,0x1a7,0x1a8,0x0,0x90019,0x1ac, + 0x6,0x1,0x0,0x0,0x0,0x2,0x0,0x40020,0x1ad,0x0,0x1ac,0x4003b, + 0x1ad,0x1ae,0x0,0x4003b,0x192,0x1b6,0x0,0x40015,0x1c0,0x20,0x0,0x4003b, + 0x192,0x1c5,0x0,0x90019,0x1ce,0x6,0x1,0x0,0x0,0x0,0x2,0xf, + 0x40020,0x1cf,0x0,0x1ce,0x4003b,0x1cf,0x1d0,0x0,0x4003b,0x192,0x1db,0x0, + 0x4003b,0x192,0x1e3,0x0,0x5002c,0x4d,0x1e5,0x161,0x161,0x4003b,0x192,0x1ef, + 0x0,0x4002b,0x6,0x1f8,0x45700000,0x4002b,0x6,0x1f9,0x45070000,0x5002c,0x1f,0x1fa, + 0x1f8,0x1f9,0x4002b,0x2b,0x200,0x3,0x4002b,0x2b,0x206,0x1,0x4002b,0x6, + 0x233,0x800000,0x4002b,0x1c0,0x25b,0x1,0x4002b,0x6,0x275,0x3e800000,0x4002b,0x6, + 0x279,0x3f000000,0x4002b,0x6,0x289,0xbe800000,0x4002b,0x6,0x2af,0x387fda40,0x5002c,0x1f, + 0x300,0x279,0x279,0x40017,0x314,0x1c0,0x2,0x40017,0x318,0x9c,0x2,0x4002b, + 0x6,0x31e,0x3ecccccd,0x4002b,0x6,0x326,0x3fc80000,0x4002b,0x6,0x32b,0x3f100000,0x4002b, + 0x6,0x333,0x40800000,0x4002b,0x6,0x359,0x3ffeb852,0x6002c,0xe,0x361,0x127,0x127, + 0x127,0x4002b,0x2b,0x38d,0xfffffffe,0x4002b,0x2b,0x38e,0xffffffff,0x4002b,0x1c0,0x3dc, + 0x9,0x4001c,0x3dd,0xe,0x3dc,0x40020,0x3de,0x7,0x3dd,0x4002b,0x2b,0x3f4, + 0x9,0x4002b,0x6,0x40b,0x3e99999a,0x4002b,0x6,0x418,0x40a00000,0x4002b,0x6,0x483, + 0xc0133333,0x4002b,0x6,0x4bb,0x3d3d70a4,0x4002b,0x6,0x4ff,0xbf000000,0x4002b,0x6,0x50d, + 0xc0200000,0x4002b,0x6,0x50e,0x3fc00000,0x4002b,0x6,0x519,0x40000000,0x7002c,0x3e,0x59b, + 0x127,0x127,0x127,0x127,0x4002b,0x6,0x605,0x3f400000,0x4002b,0x6,0x62a,0x40400000, + 0x4002b,0x6,0x633,0x3fd9999a,0x6002c,0xe,0x634,0x633,0x128,0x128,0x4002b,0x6, + 0x639,0x340018ef,0x6002c,0xe,0x63a,0x639,0x639,0x639,0x4002b,0x6,0x6b4,0x3dcccccd, + 0x4002b,0x6,0x6d4,0x3e19999a,0x4002b,0x6,0x754,0x42c80000,0x40017,0x7b9,0x1c0,0x3, + 0x40020,0x7ba,0x1,0x7b9,0x4003b,0x7ba,0x7bb,0x1,0x4002b,0x1c0,0x7cb,0x8, + 0x6002c,0x7b9,0x7cc,0x7cb,0x7cb,0x25b,0x30001,0x6,0x14aa,0x30001,0xe,0x14ad, + 0x5002c,0x4d,0x17eb,0x16c,0x16c,0x5002c,0x1f,0x17ec,0x128,0x128,0x5002c,0x1f, + 0x17ed,0x4ff,0x4ff,0x5002c,0x1f,0x17ee,0x50d,0x50d,0x5002c,0x1f,0x17ef,0x519, + 0x519,0x4002b,0x6,0x17f0,0x40200000,0x5002c,0x1f,0x17f1,0x17f0,0x17f0,0x4002b,0x6, + 0x17f4,0x3d4ccccd,0x4002b,0x1c0,0x1899,0x3,0x4002b,0x1c0,0x189a,0x2,0x4002b,0x1c0, + 0x189b,0x7,0x4002b,0x1c0,0x189c,0x6,0x4002b,0x1c0,0x189d,0x5,0x4002b,0x1c0, + 0x189e,0x4,0x50036,0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003b,0x3de,0xbad, + 0x7,0x4003d,0x7b9,0x7bc,0x7bb,0x7004f,0x314,0x7bd,0x7bc,0x7bc,0x0,0x1, + 0x4007c,0x4d,0x7be,0x7bd,0x4006f,0x1f,0x840,0x7be,0x50081,0x1f,0x842,0x840, + 0x300,0x50041,0x162,0x8a0,0x160,0x25b,0x4003d,0x4d,0x8a1,0x8a0,0x4006f,0x1f, + 0x844,0x8a1,0x50088,0x1f,0x845,0x842,0x844,0x50041,0x172,0x8a4,0x160,0x1899, + 0x4003d,0x1f,0x8a5,0x8a4,0x50041,0x162,0x8a8,0x160,0x161,0x4003d,0x4d,0x8a9, + 0x8a8,0x4006f,0x1f,0x84b,0x8a9,0x50088,0x1f,0x84c,0x8a5,0x84b,0x50081,0x1f, + 0x84d,0x845,0x84c,0x50041,0x162,0x8b0,0x160,0x189a,0x4003d,0x4d,0x8b1,0x8b0, + 0x50085,0x1f,0x8be,0x84d,0x84b,0x50083,0x1f,0x8c1,0x84b,0x300,0x7000c,0x1f, + 0x8ce,0x1,0x25,0x8be,0x8c1,0x7000c,0x1f,0x8d3,0x1,0x28,0x300,0x8ce, + 0x4006f,0x1f,0x8c7,0x8b1,0x50088,0x1f,0x8c8,0x8d3,0x8c7,0x50085,0x1f,0x8db, + 0x845,0x84b,0x4006e,0x4d,0x8dc,0x8db,0x4003d,0x191,0x8e5,0x1db,0x7005f,0x3e, + 0x8e7,0x8e5,0x8dc,0x2,0x161,0x7004f,0x1f,0x8e8,0x8e7,0x8e7,0x0,0x1, + 0x50085,0x1f,0x8ec,0x8e8,0x1fa,0x6000c,0x6,0x8ed,0x1,0x42,0x8ec,0x50081, + 0x1f,0x8f4,0x845,0x8e8,0x50051,0x6,0x8fd,0x8f4,0x0,0x500be,0x9c,0x8fe, + 0x8fd,0x127,0x300f7,0x903,0x0,0x400fa,0x8fe,0x8ff,0x903,0x200f8,0x8ff,0x500bc, + 0x9c,0x902,0x8fd,0x128,0x200f9,0x903,0x200f8,0x903,0x700f5,0x9c,0x904,0x8fe, + 0x5,0x902,0x8ff,0x300f7,0x90f,0x0,0x400fa,0x904,0x905,0x90f,0x200f8,0x905, + 0x50051,0x6,0x907,0x8f4,0x1,0x500be,0x9c,0x908,0x907,0x127,0x300f7,0x90d, + 0x0,0x400fa,0x908,0x909,0x90d,0x200f8,0x909,0x500bc,0x9c,0x90c,0x907,0x128, + 0x200f9,0x90d,0x200f8,0x90d,0x700f5,0x9c,0x90e,0x908,0x905,0x90c,0x909,0x200f9, + 0x90f,0x200f8,0x90f,0x700f5,0x9c,0x910,0x904,0x903,0x90e,0x90d,0x7000c,0x1f, + 0x935,0x1,0x25,0x8db,0x8c1,0x7000c,0x1f,0x93a,0x1,0x28,0x300,0x935, + 0x50088,0x1f,0x92f,0x93a,0x8c7,0x4003d,0x191,0x93d,0x1c5,0x4003d,0x19c,0x93e, + 0x19e,0x50056,0x1a0,0x93f,0x93d,0x93e,0x70058,0x3e,0x941,0x93f,0x92f,0x2, + 0x127,0x50051,0x6,0x942,0x941,0x0,0x50087,0x4d,0x869,0x8a9,0x17eb,0x4003d, + 0x191,0x949,0x1b6,0x50067,0x4d,0x94a,0x949,0x161,0x4006f,0x1f,0x956,0x869, + 0x50085,0x1f,0x957,0x84d,0x956,0x50083,0x1f,0x95a,0x956,0x300,0x7000c,0x1f, + 0x967,0x1,0x25,0x957,0x95a,0x7000c,0x1f,0x96c,0x1,0x28,0x300,0x967, + 0x4006f,0x1f,0x960,0x94a,0x50088,0x1f,0x961,0x96c,0x960,0x4003d,0x191,0x96f, + 0x1b6,0x4003d,0x19c,0x970,0x19e,0x50056,0x1a0,0x971,0x96f,0x970,0x70058,0x3e, + 0x973,0x971,0x961,0x2,0x127,0x50051,0x6,0x974,0x973,0x0,0x400a8,0x9c, + 0x873,0x910,0x300f7,0x878,0x0,0x400fa,0x910,0x875,0x878,0x200f8,0x875,0x50041, + 0x17d,0x977,0x160,0x189b,0x4003d,0x6,0x978,0x977,0x500b4,0x9c,0x877,0x127, + 0x978,0x200f9,0x878,0x200f8,0x878,0x700f5,0x9c,0x879,0x873,0x90f,0x877,0x875, + 0x4003d,0x191,0x97b,0x1ef,0x4003d,0x19c,0x97c,0x19e,0x50056,0x1a0,0x97d,0x97b, + 0x97c,0x70058,0x3e,0x97f,0x97d,0x8c8,0x2,0x127,0x50051,0x6,0x87f,0x97f, + 0x0,0x8000c,0x6,0x983,0x1,0x2b,0x87f,0x127,0x128,0x50051,0x6,0x883, + 0x97f,0x1,0x8000c,0x6,0x987,0x1,0x2b,0x883,0x127,0x128,0x50051,0x6, + 0x887,0x97f,0x2,0x8000c,0x6,0x98b,0x1,0x2b,0x887,0x127,0x128,0x50051, + 0x6,0x88b,0x97f,0x3,0x8000c,0x6,0x98f,0x1,0x2b,0x88b,0x127,0x128, + 0x50085,0x6,0x890,0x98f,0x754,0x6000c,0x6,0x891,0x1,0x1,0x890,0x500ba, + 0x9c,0x892,0x891,0x128,0x600a9,0x6,0x893,0x892,0x128,0x127,0x50085,0x6, + 0x896,0x98f,0x893,0x300f7,0x7ee,0x0,0x400fa,0x910,0x7ea,0x7ee,0x200f8,0x7ea, + 0x400a8,0x9c,0x7ed,0x879,0x200f9,0x7ee,0x200f8,0x7ee,0x700f5,0x9c,0x7ef,0x910, + 0x878,0x7ed,0x7ea,0x300f7,0x7f5,0x0,0x400fa,0x7ef,0x7f0,0x7f5,0x200f8,0x7f0, + 0x50085,0x1f,0x9cd,0x8f4,0x844,0x50083,0x1f,0x9d0,0x9cd,0x300,0x6000c,0x1f, + 0x9d1,0x1,0x8,0x9d0,0x50081,0x1f,0x9d3,0x9d1,0x300,0x50083,0x1f,0x9d6, + 0x9cd,0x9d3,0x5008e,0x1f,0x9da,0x9d6,0x279,0x50083,0x1f,0x9dc,0x17ec,0x9da, + 0x50085,0x1f,0x9dd,0x9d6,0x9dc,0x50081,0x1f,0x9df,0x17ed,0x9dd,0x50085,0x1f, + 0x9e0,0x9d6,0x9df,0x50085,0x1f,0x9e3,0x9d6,0x9d6,0x5008e,0x1f,0x9e5,0x9d6, + 0x50e,0x50081,0x1f,0x9e7,0x17ee,0x9e5,0x50085,0x1f,0x9e8,0x9e3,0x9e7,0x50081, + 0x1f,0x9ea,0x17ec,0x9e8,0x50083,0x1f,0x9f0,0x17ef,0x9e5,0x50085,0x1f,0x9f1, + 0x9d6,0x9f0,0x50081,0x1f,0x9f3,0x300,0x9f1,0x50085,0x1f,0x9f4,0x9d6,0x9f3, + 0x50081,0x1f,0x9fb,0x17ed,0x9da,0x50085,0x1f,0x9fc,0x9e3,0x9fb,0x50081,0x1f, + 0x9ff,0x9ea,0x9f4,0x50081,0x1f,0xa02,0x9d1,0x17ed,0x50088,0x1f,0xa04,0xa02, + 0x844,0x50081,0x1f,0xa07,0x9d1,0x17f1,0x50088,0x1f,0xa09,0xa07,0x844,0x50088, + 0x1f,0xa0d,0x9f4,0x9ff,0x50081,0x1f,0xa0e,0x9d3,0xa0d,0x50088,0x1f,0xa10, + 0xa0e,0x844,0x50051,0x6,0xa12,0x9ff,0x0,0x50051,0x6,0xa14,0x9e0,0x1, + 0x50085,0x6,0xa15,0xa12,0xa14,0x50051,0x6,0xa17,0x9e0,0x0,0x50051,0x6, + 0xa19,0x9ff,0x1,0x50085,0x6,0xa1a,0xa17,0xa19,0x50085,0x6,0xa1f,0xa12, + 0xa19,0x50051,0x6,0xa21,0x9fc,0x0,0x50085,0x6,0xa24,0xa21,0xa19,0x50051, + 0x6,0xa28,0x9fc,0x1,0x50085,0x6,0xa29,0xa12,0xa28,0x50051,0x6,0xa2b, + 0xa10,0x0,0x50051,0x6,0xa2d,0xa04,0x1,0x50050,0x1f,0xa2e,0xa2b,0xa2d, + 0x4003d,0x191,0xa61,0x19a,0x4003d,0x19c,0xa62,0x19e,0x50056,0x1a0,0xa63,0xa61, + 0xa62,0x70058,0x3e,0xa65,0xa63,0xa2e,0x2,0x127,0x5008e,0x3e,0xa31,0xa65, + 0xa15,0x50051,0x6,0xa33,0xa04,0x0,0x50051,0x6,0xa35,0xa10,0x1,0x50050, + 0x1f,0xa36,0xa33,0xa35,0x4003d,0x191,0xa68,0x19a,0x4003d,0x19c,0xa69,0x19e, + 0x50056,0x1a0,0xa6a,0xa68,0xa69,0x70058,0x3e,0xa6c,0xa6a,0xa36,0x2,0x127, + 0x5008e,0x3e,0xa39,0xa6c,0xa1a,0x50081,0x3e,0xa3a,0xa31,0xa39,0x4003d,0x191, + 0xa6f,0x19a,0x4003d,0x19c,0xa70,0x19e,0x50056,0x1a0,0xa71,0xa6f,0xa70,0x70058, + 0x3e,0xa73,0xa71,0xa10,0x2,0x127,0x5008e,0x3e,0xa3e,0xa73,0xa1f,0x50081, + 0x3e,0xa3f,0xa3a,0xa3e,0x50051,0x6,0xa41,0xa09,0x0,0x50050,0x1f,0xa44, + 0xa41,0xa35,0x4003d,0x191,0xa76,0x19a,0x4003d,0x19c,0xa77,0x19e,0x50056,0x1a0, + 0xa78,0xa76,0xa77,0x70058,0x3e,0xa7a,0xa78,0xa44,0x2,0x127,0x5008e,0x3e, + 0xa47,0xa7a,0xa24,0x50081,0x3e,0xa48,0xa3f,0xa47,0x50051,0x6,0xa4c,0xa09, + 0x1,0x50050,0x1f,0xa4d,0xa2b,0xa4c,0x4003d,0x191,0xa7d,0x19a,0x4003d,0x19c, + 0xa7e,0x19e,0x50056,0x1a0,0xa7f,0xa7d,0xa7e,0x70058,0x3e,0xa81,0xa7f,0xa4d, + 0x2,0x127,0x5008e,0x3e,0xa50,0xa81,0xa29,0x50081,0x3e,0xa51,0xa48,0xa50, + 0x50081,0x6,0xa55,0xa15,0xa1a,0x50081,0x6,0xa57,0xa55,0xa1f,0x50081,0x6, + 0xa59,0xa57,0xa24,0x50081,0x6,0xa5b,0xa59,0xa29,0x70050,0x3e,0xa5c,0xa5b, + 0xa5b,0xa5b,0xa5b,0x50088,0x3e,0xa5d,0xa51,0xa5c,0x7000c,0x3e,0xa86,0x1, + 0x28,0xa5d,0x59b,0x8004f,0xe,0x99a,0xa86,0xa86,0x0,0x1,0x2,0x50041, + 0x17d,0xa89,0x160,0x189c,0x4003d,0x6,0xa8a,0xa89,0x5008e,0xe,0x99f,0x99a, + 0xa8a,0x4003d,0x191,0xa8e,0x1e3,0x7005f,0x3e,0xa8f,0xa8e,0x1e5,0x2,0x161, + 0x50051,0x6,0xa90,0xa8f,0x0,0x500b4,0x9c,0xa92,0xa90,0x127,0x600a9,0x6, + 0x17f9,0xa92,0x128,0xa90,0x5008e,0xe,0x9a4,0x99f,0x17f9,0x50051,0x6,0xa9a, + 0x9a4,0x0,0x50085,0x6,0xa9b,0x275,0xa9a,0x50051,0x6,0xa9d,0x9a4,0x1, + 0x50085,0x6,0xa9e,0x279,0xa9d,0x50081,0x6,0xa9f,0xa9b,0xa9e,0x50051,0x6, + 0xaa1,0x9a4,0x2,0x50085,0x6,0xaa2,0x275,0xaa1,0x50081,0x6,0xaa3,0xa9f, + 0xaa2,0x50083,0x6,0x17f2,0xa9a,0xaa1,0x50085,0x6,0xaaa,0x279,0x17f2,0x50085, + 0x6,0xaad,0x289,0xa9a,0x50081,0x6,0xab1,0xaad,0xa9e,0x50083,0x6,0xab5, + 0xab1,0xaa2,0x60050,0xe,0xab6,0xaa3,0xaaa,0xab5,0x50051,0x6,0x9ab,0xa86, + 0x3,0x200f9,0x7f5,0x200f8,0x7f5,0x700f5,0xe,0x153f,0x361,0x7ee,0xab6,0x7f0, + 0x700f5,0x6,0x153d,0x127,0x7ee,0x9ab,0x7f0,0x400a8,0x9c,0xad2,0x879,0x600a9, + 0x6,0xad3,0xad2,0x128,0x127,0x50085,0x6,0xad6,0x153d,0xad3,0x8000c,0x6, + 0xb1c,0x1,0x2b,0x98b,0x127,0x128,0x7000c,0x6,0xb21,0x1,0x28,0x983, + 0x987,0x7000c,0x6,0xb26,0x1,0x28,0xb1c,0xb21,0x50085,0x6,0xae4,0xb26, + 0x519,0x50083,0x6,0xae5,0xad6,0xae4,0x7000c,0x6,0xb2b,0x1,0x28,0x127, + 0xae5,0x50083,0x6,0xaea,0xb2b,0x128,0x8000c,0x6,0xb2f,0x1,0x2b,0xaea, + 0x127,0x128,0x8000c,0x6,0xb33,0x1,0x2b,0xb2f,0x127,0x128,0x4003d,0x1ce, + 0xb36,0x1d0,0x50062,0x3e,0xb38,0xb36,0x7be,0x50051,0x6,0xb39,0xb38,0x0, + 0x7000c,0x6,0xb3e,0x1,0x28,0x127,0x983,0x50083,0x6,0xaf8,0x128,0xb3e, + 0x50085,0x6,0xaf9,0xb39,0xaf8,0x50081,0x6,0xafd,0xb2b,0xaf9,0x7000c,0x6, + 0xb43,0x1,0x25,0xafd,0x519,0x7000c,0x6,0xb48,0x1,0x28,0x127,0xb43, + 0x50041,0x17d,0xb4b,0x160,0x189d,0x4003d,0x6,0xb4c,0xb4b,0x50088,0x6,0xb02, + 0x6b4,0xb4c,0x50083,0x6,0xb04,0x128,0xb26,0x50085,0x6,0xb05,0xb02,0xb04, + 0x50083,0x6,0xb09,0xb48,0xb05,0x7000c,0x6,0xb51,0x1,0x28,0x127,0xb09, + 0x50083,0x1f,0xb10,0x845,0x8e8,0x50051,0x6,0xb55,0xb10,0x0,0x500be,0x9c, + 0xb56,0xb55,0x127,0x300f7,0xb5b,0x0,0x400fa,0xb56,0xb57,0xb5b,0x200f8,0xb57, + 0x500bc,0x9c,0xb5a,0xb55,0x128,0x200f9,0xb5b,0x200f8,0xb5b,0x700f5,0x9c,0xb5c, + 0xb56,0x7f5,0xb5a,0xb57,0x300f7,0xb67,0x0,0x400fa,0xb5c,0xb5d,0xb67,0x200f8, + 0xb5d,0x50051,0x6,0xb5f,0xb10,0x1,0x500be,0x9c,0xb60,0xb5f,0x127,0x300f7, + 0xb65,0x0,0x400fa,0xb60,0xb61,0xb65,0x200f8,0xb61,0x500bc,0x9c,0xb64,0xb5f, + 0x128,0x200f9,0xb65,0x200f8,0xb65,0x700f5,0x9c,0xb66,0xb60,0xb5d,0xb64,0xb61, + 0x200f9,0xb67,0x200f8,0xb67,0x700f5,0x9c,0xb68,0xb5c,0xb5b,0xb66,0xb65,0x600a9, + 0x6,0xb14,0xb68,0x128,0x127,0x50085,0x6,0xb17,0xb51,0xb14,0x50041,0x17d, + 0xb82,0x160,0x7cb,0x4003d,0x6,0xb83,0xb82,0x50085,0x6,0xb76,0x8ed,0xb83, + 0x50085,0x6,0xb77,0xb76,0x519,0x7000c,0x6,0xb88,0x1,0x28,0x127,0xb77, + 0x8000c,0x6,0xb8c,0x1,0x2b,0xb88,0x127,0x128,0x8000c,0x6,0xb92,0x1, + 0x2e,0x896,0x6d4,0xb8c,0x7000c,0x6,0xb97,0x1,0x25,0x896,0xb92,0x50041, + 0x172,0xcf7,0x160,0x189e,0x4003d,0x1f,0xcf8,0xcf7,0x50085,0x1f,0xbe0,0x842, + 0xcf8,0x6000c,0x1f,0xbe2,0x1,0x8,0xbe0,0x4006e,0x4d,0xbe3,0xbe2,0x4006f, + 0x1f,0xbe5,0xbe3,0x50081,0x1f,0xbe6,0xbe5,0x300,0x50083,0x1f,0xbe8,0xbe6, + 0x8a5,0x50083,0x1f,0xbeb,0xbe8,0xbe0,0x50051,0x6,0xbed,0xbe8,0x0,0x50051, + 0x6,0xbef,0xbe0,0x0,0x500ba,0x9c,0xbf0,0xbed,0xbef,0x600a9,0x2b,0xbf1, + 0xbf0,0x38d,0x38e,0x50051,0x6,0xbf4,0xbe8,0x1,0x50051,0x6,0xbf6,0xbe0, + 0x1,0x500ba,0x9c,0xbf7,0xbf4,0xbf6,0x600a9,0x2b,0xbf8,0xbf7,0x38d,0x38e, + 0x50050,0x4d,0x18a9,0xbf1,0xbf8,0x4006f,0x1f,0xc05,0x18a9,0x500b4,0x9c,0xc07, + 0x896,0x127,0x200f9,0xc08,0x200f8,0xc08,0x700f5,0x2b,0x1595,0x161,0xb67,0xc37, + 0xc35,0x700f5,0x2b,0x16eb,0x161,0xb67,0x16ea,0xc35,0x500b1,0x9c,0xc0b,0x1595, + 0x200,0x400f6,0xc38,0xc35,0x0,0x400fa,0xc0b,0xc0c,0xc38,0x200f8,0xc0c,0x200f9, + 0xc0d,0x200f8,0xc0d,0x700f5,0x2b,0x16ea,0x16eb,0xc0c,0xc30,0xc31,0x700f5,0x2b, + 0x16dd,0x161,0xc0c,0xc33,0xc31,0x500b1,0x9c,0xc10,0x16dd,0x200,0x400f6,0xc34, + 0xc31,0x0,0x400fa,0xc10,0xc11,0xc34,0x200f8,0xc11,0x300f7,0xc18,0x0,0x400fa, + 0xbf0,0xc13,0xc16,0x200f8,0xc13,0x50082,0x2b,0xc15,0x200,0x16dd,0x200f9,0xc18, + 0x200f8,0xc16,0x200f9,0xc18,0x200f8,0xc18,0x700f5,0x2b,0x16e0,0xc15,0xc13,0x16dd, + 0xc16,0x300f7,0xc20,0x0,0x400fa,0xbf7,0xc1b,0xc1e,0x200f8,0xc1b,0x50082,0x2b, + 0xc1d,0x200,0x1595,0x200f9,0xc20,0x200f8,0xc1e,0x200f9,0xc20,0x200f8,0xc20,0x700f5, + 0x2b,0x16e4,0xc1d,0xc1b,0x1595,0xc1e,0x50050,0x4d,0xc22,0x16e0,0x16e4,0x50080, + 0x4d,0xc25,0xbe3,0x18a9,0x50080,0x4d,0xc27,0xc25,0xc22,0x50051,0x2b,0xd10, + 0x8a9,0x0,0x50082,0x2b,0xd11,0xd10,0x206,0x50051,0x2b,0xd13,0xc27,0x0, + 0x7000c,0x2b,0xd24,0x1,0x27,0xd13,0xd11,0x7000c,0x2b,0xd29,0x1,0x2a, + 0x161,0xd24,0x50051,0x2b,0xd18,0x8a9,0x1,0x50082,0x2b,0xd19,0xd18,0x206, + 0x50051,0x2b,0xd1b,0xc27,0x1,0x7000c,0x2b,0xd2e,0x1,0x27,0xd1b,0xd19, + 0x7000c,0x2b,0xd33,0x1,0x2a,0x161,0xd2e,0x50050,0x4d,0x18aa,0xd29,0xd33, + 0x4003d,0x191,0xd46,0x193,0x7005f,0x3e,0xd48,0xd46,0x18aa,0x2,0x161,0x8004f, + 0xe,0xd49,0xd48,0xd48,0x0,0x1,0x2,0x7000c,0xe,0xd4e,0x1,0x28, + 0x361,0xd49,0x4003d,0x191,0xd52,0x1e3,0x7005f,0x3e,0xd53,0xd52,0x1e5,0x2, + 0x161,0x50051,0x6,0xd54,0xd53,0x0,0x500b4,0x9c,0xd56,0xd54,0x127,0x600a9, + 0x6,0x17fa,0xd56,0x128,0xd54,0x5008e,0xe,0xd40,0xd4e,0x17fa,0x50051,0x6, + 0xd5e,0xd40,0x0,0x50085,0x6,0xd5f,0x275,0xd5e,0x50051,0x6,0xd61,0xd40, + 0x1,0x50085,0x6,0xd62,0x279,0xd61,0x50081,0x6,0xd63,0xd5f,0xd62,0x50051, + 0x6,0xd65,0xd40,0x2,0x50085,0x6,0xd66,0x275,0xd65,0x50081,0x6,0xd67, + 0xd63,0xd66,0x50083,0x6,0x17f8,0xd5e,0xd65,0x50085,0x6,0xd6e,0x279,0x17f8, + 0x50085,0x6,0xd71,0x289,0xd5e,0x50081,0x6,0xd75,0xd71,0xd62,0x50083,0x6, + 0xd79,0xd75,0xd66,0x60050,0xe,0xd7a,0xd67,0xd6e,0xd79,0x50041,0xf,0xc2e, + 0xbad,0x16ea,0x3003e,0xc2e,0xd7a,0x50080,0x2b,0xc30,0x16ea,0x206,0x200f9,0xc31, + 0x200f8,0xc31,0x50080,0x2b,0xc33,0x16dd,0x206,0x200f9,0xc0d,0x200f8,0xc34,0x200f9, + 0xc35,0x200f8,0xc35,0x50080,0x2b,0xc37,0x1595,0x206,0x200f9,0xc08,0x200f8,0xc38, + 0x300f7,0xc4c,0x0,0x400fa,0xc07,0xc3a,0xc4c,0x200f8,0xc3a,0x200f9,0xc3b,0x200f8, + 0xc3b,0x700f5,0x2b,0x1597,0x161,0xc3a,0xc4a,0xc3f,0x500b1,0x9c,0xc3e,0x1597, + 0x3f4,0x400f6,0xc4b,0xc3f,0x0,0x400fa,0xc3e,0xc3f,0xc4b,0x200f8,0xc3f,0x50041, + 0xf,0xc42,0xbad,0x1597,0x4003d,0xe,0xc43,0xc42,0x50051,0x6,0xd80,0xc43, + 0x0,0x50051,0x6,0xd82,0xc43,0x1,0x50081,0x6,0xd83,0xd80,0xd82,0x50051, + 0x6,0xd85,0xc43,0x2,0x50083,0x6,0xd86,0xd83,0xd85,0x50081,0x6,0xd8b, + 0xd80,0xd85,0x50083,0x6,0xd90,0xd80,0xd82,0x50083,0x6,0xd93,0xd90,0xd85, + 0x60050,0xe,0xd94,0xd86,0xd8b,0xd93,0x7000c,0x6,0xdaf,0x1,0x28,0x127, + 0xd86,0x7000c,0x6,0xdb4,0x1,0x28,0xd8b,0xd93,0x7000c,0x6,0xdb9,0x1, + 0x28,0xdaf,0xdb4,0x50081,0x6,0xda8,0xdb9,0x128,0x60050,0xe,0xda9,0xda8, + 0xda8,0xda8,0x50088,0xe,0xdaa,0xd94,0xda9,0x50051,0x6,0xdbe,0xdaa,0x0, + 0x50085,0x6,0xdbf,0x275,0xdbe,0x50051,0x6,0xdc1,0xdaa,0x1,0x50085,0x6, + 0xdc2,0x279,0xdc1,0x50081,0x6,0xdc3,0xdbf,0xdc2,0x50051,0x6,0xdc5,0xdaa, + 0x2,0x50085,0x6,0xdc6,0x275,0xdc5,0x50081,0x6,0xdc7,0xdc3,0xdc6,0x50083, + 0x6,0x17f7,0xdbe,0xdc5,0x50085,0x6,0xdce,0x279,0x17f7,0x50085,0x6,0xdd1, + 0x289,0xdbe,0x50081,0x6,0xdd5,0xdd1,0xdc2,0x50083,0x6,0xdd9,0xdd5,0xdc6, + 0x60050,0xe,0xdda,0xdc7,0xdce,0xdd9,0x3003e,0xc42,0xdda,0x50080,0x2b,0xc4a, + 0x1597,0x206,0x200f9,0xc3b,0x200f8,0xc4b,0x200f9,0xc4c,0x200f8,0xc4c,0x50088,0x1f, + 0xde3,0x17ec,0xcf8,0x50083,0x1f,0xde5,0xde3,0x17ec,0x50051,0x6,0xde6,0xde5, + 0x0,0x50081,0x6,0xde7,0x128,0xde6,0x7000c,0x6,0xdf2,0x1,0x25,0x359, + 0xde7,0x50081,0x6,0xc51,0x128,0xdf2,0x50085,0x6,0xc52,0xc51,0x40b,0x7000c, + 0x6,0xdf7,0x1,0x28,0x128,0xc52,0x50085,0x6,0xc55,0x987,0x279,0x50083, + 0x6,0xc56,0x128,0xc55,0x50083,0x6,0xc58,0x128,0x98b,0x50085,0x6,0xc5b, + 0xb97,0x418,0x8000c,0x6,0xdfb,0x1,0x2b,0xc5b,0x127,0x128,0x7000c,0x6, + 0xe00,0x1,0x25,0xc58,0xdfb,0x7000c,0x6,0xe05,0x1,0x25,0xc56,0xe00, + 0x8000c,0x6,0xe0b,0x1,0x2e,0xdf7,0xdf2,0xe05,0x200f9,0xc63,0x200f8,0xc63, + 0x700f5,0xe,0x15c7,0x361,0xc4c,0x16b6,0xcc2,0x700f5,0x6,0x15c5,0x127,0xc4c, + 0x16b9,0xcc2,0x700f5,0xe,0x15be,0x14ad,0xc4c,0x16d5,0xcc2,0x700f5,0xe,0x15bd, + 0x14ad,0xc4c,0x16d1,0xcc2,0x700f5,0xe,0x15bc,0x14ad,0xc4c,0x16cd,0xcc2,0x700f5, + 0xe,0x15bb,0x14ad,0xc4c,0x16c9,0xcc2,0x700f5,0x6,0x15ba,0x14aa,0xc4c,0x16c5, + 0xcc2,0x700f5,0x2b,0x15b9,0x161,0xc4c,0xcc4,0xcc2,0x700f5,0x2b,0x16b3,0x161, + 0xc4c,0x16b2,0xcc2,0x500b1,0x9c,0xc66,0x15b9,0x200,0x400f6,0xcc5,0xcc2,0x0, + 0x400fa,0xc66,0xc67,0xcc5,0x200f8,0xc67,0x200f9,0xc68,0x200f8,0xc68,0x700f5,0xe, + 0x16d5,0x15be,0xc67,0x16da,0xcbe,0x700f5,0xe,0x16d1,0x15bd,0xc67,0x16d9,0xcbe, + 0x700f5,0xe,0x16cd,0x15bc,0xc67,0x16d8,0xcbe,0x700f5,0xe,0x16c9,0x15bb,0xc67, + 0x16d7,0xcbe,0x700f5,0x6,0x16c5,0x15ba,0xc67,0x16d6,0xcbe,0x700f5,0x6,0x16b9, + 0x15c5,0xc67,0x17e2,0xcbe,0x700f5,0xe,0x16b6,0x15c7,0xc67,0x17e0,0xcbe,0x700f5, + 0x2b,0x16b2,0x16b3,0xc67,0xcbd,0xcbe,0x700f5,0x2b,0x1684,0x161,0xc67,0xcc0, + 0xcbe,0x500b1,0x9c,0xc6b,0x1684,0x200,0x400f6,0xcc1,0xcbe,0x0,0x400fa,0xc6b, + 0xc6c,0xcc1,0x200f8,0xc6c,0x300f7,0xc73,0x0,0x400fa,0xbf0,0xc6e,0xc71,0x200f8, + 0xc6e,0x50082,0x2b,0xc70,0x200,0x1684,0x200f9,0xc73,0x200f8,0xc71,0x200f9,0xc73, + 0x200f8,0xc73,0x700f5,0x2b,0x168b,0xc70,0xc6e,0x1684,0xc71,0x300f7,0xc7b,0x0, + 0x400fa,0xbf7,0xc76,0xc79,0x200f8,0xc76,0x50082,0x2b,0xc78,0x200,0x15b9,0x200f9, + 0xc7b,0x200f8,0xc79,0x200f9,0xc7b,0x200f8,0xc7b,0x700f5,0x2b,0x1693,0xc78,0xc76, + 0x15b9,0xc79,0x50050,0x4d,0xc7d,0x168b,0x1693,0x4006f,0x1f,0xc80,0xc7d,0x50081, + 0x1f,0xc81,0xc05,0xc80,0x50081,0x1f,0xc84,0xbeb,0xc81,0x50080,0x4d,0xc87, + 0xbe3,0x18a9,0x50080,0x4d,0xc89,0xc87,0xc7d,0x4007c,0x314,0xe13,0xc89,0x4007c, + 0x314,0xe15,0x8a9,0x500b0,0x318,0xe16,0xe13,0xe15,0x4009b,0x9c,0xe17,0xe16, + 0x600a9,0x6,0xc8d,0xe17,0x128,0x127,0x400a8,0x9c,0xc8f,0xc07,0x300f7,0xca4, + 0x0,0x400fa,0xc8f,0xc90,0xca4,0x200f8,0xc90,0x50050,0x1f,0xe1f,0xe0b,0xe0b, + 0x50085,0x1f,0xe20,0xc84,0xe1f,0x50094,0x6,0xe23,0xe20,0xe20,0x7000c,0x6, + 0xe33,0x1,0x25,0xe23,0x333,0x50085,0x6,0xe39,0x31e,0xe33,0x50083,0x6, + 0xe3a,0xe39,0x128,0x50085,0x6,0xe3c,0x275,0xe33,0x50083,0x6,0xe3d,0xe3c, + 0x128,0x50085,0x6,0xe3f,0x326,0xe3a,0x50085,0x6,0xe41,0xe3f,0xe3a,0x50083, + 0x6,0xe42,0xe41,0x32b,0x50085,0x6,0xe45,0xe3d,0xe3d,0x50085,0x6,0xe46, + 0xe42,0xe45,0x50085,0x6,0xc95,0xc8d,0xe46,0x50041,0xf,0xc97,0xbad,0x16b2, + 0x4003d,0xe,0xc98,0xc97,0x5008e,0xe,0xc9a,0xc98,0xc95,0x50081,0xe,0xc9d, + 0x16b6,0xc9a,0x50081,0x6,0xca2,0x16b9,0xc95,0x200f9,0xca4,0x200f8,0xca4,0x700f5, + 0x6,0x17e2,0x16b9,0xc7b,0xca2,0xc90,0x700f5,0xe,0x17e0,0x16b6,0xc7b,0xc9d, + 0xc90,0x50094,0x6,0xca7,0xc84,0xc84,0x50085,0x6,0xca9,0x483,0xca7,0x6000c, + 0x6,0xcaa,0x1,0x1b,0xca9,0x50085,0x6,0xcac,0xcaa,0xc8d,0x500aa,0x9c, + 0xcae,0x15b9,0x161,0x500aa,0x9c,0xcb0,0x1684,0x161,0x500a7,0x9c,0xcb1,0xcae, + 0xcb0,0x50041,0xf,0xcb3,0xbad,0x16b2,0x4003d,0xe,0xcb4,0xcb3,0x300f7,0xe6c, + 0x0,0x400fa,0xcb1,0xe4f,0xe53,0x200f8,0xe4f,0x5008e,0xe,0xe71,0xcb4,0xcac, + 0x50085,0xe,0xe75,0xcb4,0xe71,0x200f9,0xe6c,0x200f8,0xe53,0x7000c,0xe,0xe7c, + 0x1,0x25,0x16cd,0xcb4,0x7000c,0xe,0xe81,0x1,0x28,0x16c9,0xcb4,0x5008e, + 0xe,0xe5c,0xcb4,0xcac,0x50081,0xe,0xe60,0x16d5,0xe5c,0x50085,0xe,0xe63, + 0xcb4,0xe5c,0x50081,0xe,0xe66,0x16d1,0xe63,0x50081,0x6,0xe6a,0x16c5,0xcac, + 0x200f9,0xe6c,0x200f8,0xe6c,0x700f5,0xe,0x16da,0xe71,0xe4f,0xe60,0xe53,0x700f5, + 0xe,0x16d9,0xe75,0xe4f,0xe66,0xe53,0x700f5,0xe,0x16d8,0xcb4,0xe4f,0xe7c, + 0xe53,0x700f5,0xe,0x16d7,0xcb4,0xe4f,0xe81,0xe53,0x700f5,0x6,0x16d6,0xcac, + 0xe4f,0xe6a,0xe53,0x50080,0x2b,0xcbd,0x16b2,0x206,0x200f9,0xcbe,0x200f8,0xcbe, + 0x50080,0x2b,0xcc0,0x1684,0x206,0x200f9,0xc68,0x200f8,0xcc1,0x200f9,0xcc2,0x200f8, + 0xcc2,0x50080,0x2b,0xcc4,0x15b9,0x206,0x200f9,0xc63,0x200f8,0xcc5,0x6000c,0x6, + 0xe87,0x1,0x4,0x15ba,0x500ba,0x9c,0xe88,0xe87,0x233,0x600a9,0x6,0x17fb, + 0xe88,0x15ba,0x128,0x60050,0xe,0xe94,0x17fb,0x17fb,0x17fb,0x50088,0xe,0xe95, + 0x15be,0xe94,0x50088,0xe,0xe9c,0x15bd,0xe94,0x50085,0xe,0xea4,0xe95,0xe95, + 0x50083,0xe,0xea5,0xe9c,0xea4,0x6000c,0xe,0xea6,0x1,0x4,0xea5,0x6000c, + 0xe,0xea7,0x1,0x1f,0xea6,0x500ba,0x9c,0xccd,0x15c5,0x2af,0x600a9,0x6, + 0xcce,0xccd,0x128,0x127,0x50085,0x6,0xcd1,0x15c5,0xcce,0x500ba,0x9c,0xcd5, + 0xcd1,0x2af,0x300f7,0xce9,0x0,0x400fa,0xcd5,0xcd6,0xce9,0x200f8,0xcd6,0x60050, + 0xe,0xcdb,0xcd1,0xcd1,0xcd1,0x50088,0xe,0xcdc,0x15c7,0xcdb,0x50085,0x6, + 0xce0,0xcd1,0x4bb,0x8000c,0xe,0xeb0,0x1,0x2b,0xcdc,0x15bc,0x15bb,0x200f9, + 0xce9,0x200f8,0xce9,0x700f5,0xe,0x15e1,0x15c7,0xcc5,0xeb0,0xcd6,0x700f5,0x6, + 0x15df,0xcd1,0xcc5,0xce0,0xcd6,0x300f7,0xcf4,0x0,0x400fa,0xc07,0xceb,0xcf4, + 0x200f8,0xceb,0x50051,0x6,0xeb5,0xe95,0x0,0x50051,0x6,0xeb7,0xe95,0x1, + 0x50081,0x6,0xeb8,0xeb5,0xeb7,0x50051,0x6,0xeba,0xe95,0x2,0x50083,0x6, + 0xebb,0xeb8,0xeba,0x50081,0x6,0xec0,0xeb5,0xeba,0x50083,0x6,0xec5,0xeb5, + 0xeb7,0x50083,0x6,0xec8,0xec5,0xeba,0x60050,0xe,0xec9,0xebb,0xec0,0xec8, + 0x7000c,0x6,0xee4,0x1,0x28,0xec0,0xec8,0x7000c,0x6,0xee9,0x1,0x28, + 0xebb,0xee4,0x50083,0x6,0xedc,0x128,0xee9,0x7000c,0x6,0xeee,0x1,0x28, + 0x2af,0xedc,0x60050,0xe,0xede,0xeee,0xeee,0xeee,0x50088,0xe,0xedf,0xec9, + 0xede,0x50051,0x6,0xef3,0xedf,0x0,0x50085,0x6,0xef4,0x275,0xef3,0x50051, + 0x6,0xef6,0xedf,0x1,0x50085,0x6,0xef7,0x279,0xef6,0x50081,0x6,0xef8, + 0xef4,0xef7,0x50051,0x6,0xefa,0xedf,0x2,0x50085,0x6,0xefb,0x275,0xefa, + 0x50081,0x6,0xefc,0xef8,0xefb,0x50083,0x6,0x17f3,0xef3,0xefa,0x50085,0x6, + 0xf03,0x279,0x17f3,0x50085,0x6,0xf06,0x289,0xef3,0x50081,0x6,0xf0a,0xf06, + 0xef7,0x50083,0x6,0xf0e,0xf0a,0xefb,0x60050,0xe,0xf0f,0xefc,0xf03,0xf0e, + 0x200f9,0xcf4,0x200f8,0xcf4,0x700f5,0xe,0x15e0,0x15e1,0xce9,0xf0f,0xceb,0x600a9, + 0x6,0x17fc,0xc07,0x128,0x15df,0x600a9,0x6,0x17fd,0xc07,0x127,0xb97,0x50085, + 0x6,0xf37,0x8ed,0x17f4,0x8000c,0x6,0xf7b,0x1,0x2b,0xf37,0x127,0x128, + 0x50085,0x6,0xf3a,0x974,0x17f4,0x50083,0x6,0xf3b,0x605,0xf3a,0x8000c,0x6, + 0xf7f,0x1,0x2b,0xf3b,0x127,0x128,0x50083,0x6,0xf3e,0x128,0x896,0x7000c, + 0x6,0xf84,0x1,0x1a,0x983,0x279,0x7000c,0x6,0xf89,0x1,0x28,0xf84, + 0x98b,0x7000c,0x6,0xf8e,0x1,0x28,0xf3e,0xf89,0x7000c,0x6,0xf93,0x1, + 0x28,0xf7f,0xf8e,0x7000c,0x6,0xf98,0x1,0x28,0xf7b,0xf93,0x8000c,0x6, + 0xf9e,0x1,0x2e,0x62a,0x128,0xf98,0x50085,0xe,0xf4f,0xea7,0x634,0x5008e, + 0xe,0xf51,0xf4f,0xf9e,0x7000c,0xe,0xfa3,0x1,0x28,0xf51,0x63a,0x50083, + 0xe,0xf58,0x153f,0xe95,0x50088,0xe,0xf5a,0xf58,0xfa3,0x6000c,0x6,0xf5c, + 0x1,0x42,0xf5a,0x500ba,0x9c,0xf5d,0xf5c,0x128,0x300f7,0xf77,0x0,0x400fa, + 0xf5d,0xf5e,0xf77,0x200f8,0xf5e,0x6000c,0xe,0xf60,0x1,0x45,0xf5a,0x50085, + 0xe,0xf63,0xf60,0xf51,0x50081,0xe,0xf66,0xf63,0xe95,0x7000c,0x6,0xfa8, + 0x1,0x28,0x942,0xb33,0x50085,0x6,0xf6c,0xfa8,0x896,0x50083,0x6,0xf6e, + 0x128,0x987,0x50085,0x6,0xf6f,0xf6c,0xf6e,0x8000c,0x6,0xfac,0x1,0x2b, + 0xf6f,0x127,0x128,0x60050,0xe,0xfb2,0xfac,0xfac,0xfac,0x8000c,0xe,0xfb3, + 0x1,0x2e,0xf66,0x153f,0xfb2,0x200f9,0xf77,0x200f8,0xf77,0x700f5,0xe,0x1657, + 0x153f,0xcf4,0xfb3,0xf5e,0x500ba,0x9c,0xfc6,0x17fd,0x2af,0x600a9,0x6,0xfc7, + 0xfc6,0x128,0x127,0x50085,0x6,0xfca,0x17fd,0xfc7,0x50081,0x6,0xfd0,0xfca, + 0x17fc,0x7000c,0x6,0xff8,0x1,0x28,0x2af,0xfd0,0x50051,0x6,0xffd,0x15e0, + 0x0,0x50051,0x6,0xfff,0x15e0,0x1,0x50081,0x6,0x1000,0xffd,0xfff,0x50051, + 0x6,0x1002,0x15e0,0x2,0x50083,0x6,0x1003,0x1000,0x1002,0x50081,0x6,0x1008, + 0xffd,0x1002,0x50083,0x6,0x100d,0xffd,0xfff,0x50083,0x6,0x1010,0x100d,0x1002, + 0x60050,0xe,0x1011,0x1003,0x1008,0x1010,0x7000c,0x6,0x102c,0x1,0x28,0x127, + 0x1003,0x7000c,0x6,0x1031,0x1,0x28,0x1008,0x1010,0x7000c,0x6,0x1036,0x1, + 0x28,0x102c,0x1031,0x50081,0x6,0x1025,0x1036,0x128,0x60050,0xe,0x1026,0x1025, + 0x1025,0x1025,0x50088,0xe,0x1027,0x1011,0x1026,0x50051,0x6,0x103b,0x1027,0x0, + 0x50085,0x6,0x103c,0x275,0x103b,0x50051,0x6,0x103e,0x1027,0x1,0x50085,0x6, + 0x103f,0x279,0x103e,0x50081,0x6,0x1040,0x103c,0x103f,0x50051,0x6,0x1042,0x1027, + 0x2,0x50085,0x6,0x1043,0x275,0x1042,0x50081,0x6,0x1044,0x1040,0x1043,0x50083, + 0x6,0x17f5,0x103b,0x1042,0x50085,0x6,0x104b,0x279,0x17f5,0x50085,0x6,0x104e, + 0x289,0x103b,0x50081,0x6,0x1052,0x104e,0x103f,0x50083,0x6,0x1056,0x1052,0x1043, + 0x60050,0xe,0x1057,0x1044,0x104b,0x1056,0x50051,0x6,0x105d,0x1657,0x0,0x50051, + 0x6,0x105f,0x1657,0x1,0x50081,0x6,0x1060,0x105d,0x105f,0x50051,0x6,0x1062, + 0x1657,0x2,0x50083,0x6,0x1063,0x1060,0x1062,0x50081,0x6,0x1068,0x105d,0x1062, + 0x50083,0x6,0x106d,0x105d,0x105f,0x50083,0x6,0x1070,0x106d,0x1062,0x60050,0xe, + 0x1071,0x1063,0x1068,0x1070,0x7000c,0x6,0x108c,0x1,0x28,0x127,0x1063,0x7000c, + 0x6,0x1091,0x1,0x28,0x1068,0x1070,0x7000c,0x6,0x1096,0x1,0x28,0x108c, + 0x1091,0x50081,0x6,0x1085,0x1096,0x128,0x60050,0xe,0x1086,0x1085,0x1085,0x1085, + 0x50088,0xe,0x1087,0x1071,0x1086,0x50051,0x6,0x109b,0x1087,0x0,0x50085,0x6, + 0x109c,0x275,0x109b,0x50051,0x6,0x109e,0x1087,0x1,0x50085,0x6,0x109f,0x279, + 0x109e,0x50081,0x6,0x10a0,0x109c,0x109f,0x50051,0x6,0x10a2,0x1087,0x2,0x50085, + 0x6,0x10a3,0x275,0x10a2,0x50081,0x6,0x10a4,0x10a0,0x10a3,0x50083,0x6,0x17f6, + 0x109b,0x10a2,0x50085,0x6,0x10ab,0x279,0x17f6,0x50085,0x6,0x10ae,0x289,0x109b, + 0x50081,0x6,0x10b2,0x10ae,0x109f,0x50083,0x6,0x10b6,0x10b2,0x10a3,0x60050,0xe, + 0x10b7,0x10a4,0x10ab,0x10b6,0x50088,0x6,0xfe3,0x17fc,0xff8,0x8000c,0x6,0x10bc, + 0x1,0x2b,0xfe3,0x127,0x128,0x60050,0xe,0x10c2,0x10bc,0x10bc,0x10bc,0x8000c, + 0xe,0x10c3,0x1,0x2e,0x10b7,0x1057,0x10c2,0x50051,0x6,0x10c8,0x10c3,0x0, + 0x50051,0x6,0x10ca,0x10c3,0x1,0x50081,0x6,0x10cb,0x10c8,0x10ca,0x50051,0x6, + 0x10cd,0x10c3,0x2,0x50083,0x6,0x10ce,0x10cb,0x10cd,0x50081,0x6,0x10d3,0x10c8, + 0x10cd,0x50083,0x6,0x10d8,0x10c8,0x10ca,0x50083,0x6,0x10db,0x10d8,0x10cd,0x60050, + 0xe,0x10dc,0x10ce,0x10d3,0x10db,0x7000c,0x6,0x10f7,0x1,0x28,0x10d3,0x10db, + 0x7000c,0x6,0x10fc,0x1,0x28,0x10ce,0x10f7,0x50083,0x6,0x10ef,0x128,0x10fc, + 0x7000c,0x6,0x1101,0x1,0x28,0x2af,0x10ef,0x60050,0xe,0x10f1,0x1101,0x1101, + 0x1101,0x50088,0xe,0x10f2,0x10dc,0x10f1,0x4003d,0x191,0x1105,0x1e3,0x7005f,0x3e, + 0x1106,0x1105,0x1e5,0x2,0x161,0x50051,0x6,0x1107,0x1106,0x0,0x500b4,0x9c, + 0x1109,0x1107,0x127,0x600a9,0x6,0x17fe,0x1109,0x128,0x1107,0x60050,0xe,0x80d, + 0x17fe,0x17fe,0x17fe,0x50088,0xe,0x80e,0x10f2,0x80d,0x7000c,0xe,0x1111,0x1, + 0x28,0x80e,0x361,0x50051,0x6,0x818,0x1111,0x0,0x50051,0x6,0x819,0x1111, + 0x1,0x50051,0x6,0x81a,0x1111,0x2,0x70050,0x3e,0x81b,0x818,0x819,0x81a, + 0xb17,0x4003d,0x1a6,0x1113,0x1a8,0x40063,0x1113,0x7be,0x81b,0x4003d,0x1ac,0x1117, + 0x1ae,0x70050,0x3e,0x111d,0x818,0x819,0x81a,0x128,0x40063,0x1117,0x7be,0x111d, + 0x4003d,0x1ce,0x111f,0x1d0,0x40063,0x111f,0x7be,0x59b,0x100fd,0x10038, +}; +static const char *fu0_accumulate_pass_0_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu0_accumulate_pass_0_cb_bind[] = {12}; +static const uint32_t fu0_accumulate_pass_0_cb_count[] = {1}; +static const uint32_t fu0_accumulate_pass_0_cb_space[] = {0}; +static const char *fu0_accumulate_pass_0_srv_tex_names[] = {"r_input_exposure", "r_dilated_reactive_masks", "r_dilated_motion_vectors", "r_internal_upscaled_color", "r_farthest_depth_mip1", "r_luma_instability", "r_input_color_jittered"}; +static const uint32_t fu0_accumulate_pass_0_srv_tex_bind[] = {0, 1, 2, 3, 5, 7, 8}; +static const uint32_t fu0_accumulate_pass_0_srv_tex_count[] = {1, 1, 1, 1, 1, 1, 1}; +static const uint32_t fu0_accumulate_pass_0_srv_tex_space[] = {0, 0, 0, 0, 0, 0, 0}; +static const char *fu0_accumulate_pass_0_uav_tex_names[] = {"rw_internal_upscaled_color", "rw_upscaled_output", "rw_new_locks"}; +static const uint32_t fu0_accumulate_pass_0_uav_tex_bind[] = {9, 10, 11}; +static const uint32_t fu0_accumulate_pass_0_uav_tex_count[] = {1, 1, 1}; +static const uint32_t fu0_accumulate_pass_0_uav_tex_space[] = {0, 0, 0}; +static const char *fu0_accumulate_pass_0_sampler_names[] = {"s_LinearClamp"}; +static const uint32_t fu0_accumulate_pass_0_sampler_bind[] = {1001}; +static const uint32_t fu0_accumulate_pass_0_sampler_count[] = {1}; +static const uint32_t fu0_accumulate_pass_0_sampler_space[] = {0}; + +static const uint32_t fu0_accumulate_pass_1_spv[4709] = { + 0x7230203,0x10500,0x8000b,0x188b,0x0,0x20011,0x1,0x20011,0x31,0x20011,0x32,0x6000b, + 0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0x11000f,0x5,0x4,0x6e69616d, + 0x0,0x15b,0x18e,0x195,0x199,0x1a3,0x1a7,0x1b6,0x1c1,0x1cc,0x1d4,0x1e0, + 0x7a6,0x60010,0x4,0x11,0x8,0x8,0x1,0x30003,0x2,0x1c2,0xb0004,0x455f4c47, + 0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0,0xb0004,0x455f4c47,0x735f5458, + 0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004,0x455f4c47,0x735f5458,0x65646168, + 0x6d695f72,0x5f656761,0x64616f6c,0x726f665f,0x7474616d,0x6465,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79, + 0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669, + 0x40005,0x4,0x6e69616d,0x0,0x70005,0x159,0x53466263,0x50553352,0x4c414353,0x745f5245,0x0,0x60006, + 0x159,0x0,0x6e655269,0x53726564,0x657a69,0x70006,0x159,0x1,0x73705569,0x656c6163,0x657a6953,0x0, + 0x70006,0x159,0x2,0x78614d69,0x646e6552,0x69537265,0x657a,0x50006,0x159,0x3,0x74694a66,0x726574, + 0x80006,0x159,0x4,0x776f4466,0x6163736e,0x6146656c,0x726f7463,0x0,0x90006,0x159,0x5,0x74694a66, + 0x53726574,0x65757165,0x4c65636e,0x74676e65,0x68,0x80006,0x159,0x6,0x6c654466,0x72506174,0x70784565,0x7275736f, + 0x65,0x60006,0x159,0x7,0x61724666,0x6e49656d,0x786564,0x70006,0x159,0x8,0x6c655666,0x7469636f, + 0x63614679,0x726f74,0x60005,0x15b,0x53466263,0x70553352,0x6c616373,0x7265,0x80005,0x18e,0x6e695f72,0x5f747570, + 0x6f6c6f63,0x696a5f72,0x72657474,0x6465,0x90005,0x195,0x6e695f72,0x6e726574,0x755f6c61,0x61637370,0x5f64656c,0x6f6c6f63, + 0x72,0x60005,0x199,0x694c5f73,0x7261656e,0x6d616c43,0x70,0x90005,0x1a3,0x695f7772,0x7265746e,0x5f6c616e, + 0x63737075,0x64656c61,0x6c6f635f,0x726f,0x80005,0x1a7,0x61665f72,0x65687472,0x645f7473,0x68747065,0x70696d5f,0x31, + 0x70005,0x1b6,0x756c5f72,0x695f616d,0x6174736e,0x696c6962,0x7974,0x60005,0x1c1,0x6e5f7772,0x6c5f7765,0x736b636f, + 0x0,0x90005,0x1cc,0x69645f72,0x6574616c,0x6f6d5f64,0x6e6f6974,0x6365765f,0x73726f74,0x0,0x70005,0x1d4, + 0x6e695f72,0x5f747570,0x6f707865,0x65727573,0x0,0x90005,0x1e0,0x69645f72,0x6574616c,0x65725f64,0x69746361,0x6d5f6576, + 0x736b7361,0x0,0x80005,0x7a6,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x44,0x30047,0x159, + 0x2,0x50048,0x159,0x0,0x23,0x0,0x50048,0x159,0x1,0x23,0x10,0x50048, + 0x159,0x2,0x23,0x20,0x50048,0x159,0x3,0x23,0x40,0x50048,0x159,0x4, + 0x23,0x58,0x50048,0x159,0x5,0x23,0x6c,0x50048,0x159,0x6,0x23,0x74, + 0x50048,0x159,0x7,0x23,0x7c,0x50048,0x159,0x8,0x23,0x80,0x40047,0x15b, + 0x21,0xc,0x40047,0x15b,0x22,0x0,0x40047,0x18e,0x21,0x8,0x40047,0x18e, + 0x22,0x0,0x40047,0x195,0x21,0x3,0x40047,0x195,0x22,0x0,0x40047,0x199, + 0x21,0x3e9,0x40047,0x199,0x22,0x0,0x30047,0x1a3,0x19,0x40047,0x1a3,0x21, + 0x9,0x40047,0x1a3,0x22,0x0,0x40047,0x1a7,0x21,0x5,0x40047,0x1a7,0x22, + 0x0,0x40047,0x1b6,0x21,0x7,0x40047,0x1b6,0x22,0x0,0x40047,0x1c1,0x21, + 0xb,0x40047,0x1c1,0x22,0x0,0x40047,0x1cc,0x21,0x2,0x40047,0x1cc,0x22, + 0x0,0x40047,0x1d4,0x21,0x0,0x40047,0x1d4,0x22,0x0,0x40047,0x1e0,0x21, + 0x1,0x40047,0x1e0,0x22,0x0,0x40047,0x7a6,0xb,0x1c,0x40047,0x7ba,0xb, + 0x19,0x20013,0x2,0x30021,0x3,0x2,0x30016,0x6,0x20,0x40017,0xe,0x6, + 0x3,0x40020,0xf,0x7,0xe,0x40017,0x1f,0x6,0x2,0x40015,0x2b,0x20, + 0x1,0x40017,0x3e,0x6,0x4,0x40017,0x4d,0x2b,0x2,0x20014,0x97,0x4002b, + 0x6,0x122,0x0,0x4002b,0x6,0x123,0x3f800000,0xb001e,0x159,0x4d,0x4d,0x4d, + 0x1f,0x1f,0x6,0x6,0x6,0x6,0x40020,0x15a,0x2,0x159,0x4003b,0x15a, + 0x15b,0x2,0x4002b,0x2b,0x15c,0x0,0x40020,0x15d,0x2,0x4d,0x4002b,0x2b, + 0x167,0x2,0x40020,0x16d,0x2,0x1f,0x40020,0x178,0x2,0x6,0x90019,0x18c, + 0x6,0x1,0x0,0x0,0x0,0x1,0x0,0x40020,0x18d,0x0,0x18c,0x4003b, + 0x18d,0x18e,0x0,0x4003b,0x18d,0x195,0x0,0x2001a,0x197,0x40020,0x198,0x0, + 0x197,0x4003b,0x198,0x199,0x0,0x3001b,0x19b,0x18c,0x90019,0x1a1,0x6,0x1, + 0x0,0x0,0x0,0x2,0x2,0x40020,0x1a2,0x0,0x1a1,0x4003b,0x1a2,0x1a3, + 0x0,0x4003b,0x18d,0x1a7,0x0,0x40015,0x1b1,0x20,0x0,0x4003b,0x18d,0x1b6, + 0x0,0x90019,0x1bf,0x6,0x1,0x0,0x0,0x0,0x2,0xf,0x40020,0x1c0, + 0x0,0x1bf,0x4003b,0x1c0,0x1c1,0x0,0x4003b,0x18d,0x1cc,0x0,0x4003b,0x18d, + 0x1d4,0x0,0x5002c,0x4d,0x1d6,0x15c,0x15c,0x4003b,0x18d,0x1e0,0x0,0x4002b, + 0x6,0x1e9,0x45700000,0x4002b,0x6,0x1ea,0x45070000,0x5002c,0x1f,0x1eb,0x1e9,0x1ea, + 0x4002b,0x2b,0x1f1,0x3,0x4002b,0x2b,0x1f7,0x1,0x4002b,0x6,0x224,0x800000, + 0x4002b,0x1b1,0x24c,0x1,0x4002b,0x6,0x266,0x3e800000,0x4002b,0x6,0x26a,0x3f000000, + 0x4002b,0x6,0x27a,0xbe800000,0x4002b,0x6,0x2a0,0x387fda40,0x5002c,0x1f,0x2f1,0x26a, + 0x26a,0x40017,0x305,0x1b1,0x2,0x40017,0x309,0x97,0x2,0x4002b,0x6,0x30f, + 0x3ecccccd,0x4002b,0x6,0x317,0x3fc80000,0x4002b,0x6,0x31c,0x3f100000,0x4002b,0x6,0x324, + 0x40800000,0x4002b,0x6,0x34a,0x3ffeb852,0x6002c,0xe,0x352,0x122,0x122,0x122,0x4002b, + 0x2b,0x37e,0xfffffffe,0x4002b,0x2b,0x37f,0xffffffff,0x4002b,0x1b1,0x3cd,0x9,0x4001c, + 0x3ce,0xe,0x3cd,0x40020,0x3cf,0x7,0x3ce,0x4002b,0x2b,0x3e5,0x9,0x4002b, + 0x6,0x3fc,0x3e99999a,0x4002b,0x6,0x409,0x40a00000,0x4002b,0x6,0x474,0xc0133333,0x4002b, + 0x6,0x4ac,0x3d3d70a4,0x4002b,0x6,0x4f0,0xbf000000,0x4002b,0x6,0x4fe,0xc0200000,0x4002b, + 0x6,0x4ff,0x3fc00000,0x4002b,0x6,0x50a,0x40000000,0x7002c,0x3e,0x58c,0x122,0x122, + 0x122,0x122,0x4002b,0x6,0x5f6,0x3f400000,0x4002b,0x6,0x61b,0x40400000,0x4002b,0x6, + 0x624,0x3fd9999a,0x6002c,0xe,0x625,0x624,0x123,0x123,0x4002b,0x6,0x62a,0x340018ef, + 0x6002c,0xe,0x62b,0x62a,0x62a,0x62a,0x4002b,0x6,0x6a5,0x3dcccccd,0x4002b,0x6, + 0x6c5,0x3e19999a,0x4002b,0x6,0x745,0x42c80000,0x40017,0x7a4,0x1b1,0x3,0x40020,0x7a5, + 0x1,0x7a4,0x4003b,0x7a5,0x7a6,0x1,0x4002b,0x1b1,0x7b9,0x8,0x6002c,0x7a4, + 0x7ba,0x7b9,0x7b9,0x24c,0x30001,0x6,0x148a,0x30001,0xe,0x148d,0x5002c,0x4d, + 0x17cb,0x167,0x167,0x5002c,0x1f,0x17cc,0x123,0x123,0x5002c,0x1f,0x17cd,0x4f0, + 0x4f0,0x5002c,0x1f,0x17ce,0x4fe,0x4fe,0x5002c,0x1f,0x17cf,0x50a,0x50a,0x4002b, + 0x6,0x17d0,0x40200000,0x5002c,0x1f,0x17d1,0x17d0,0x17d0,0x4002b,0x6,0x17d4,0x3d4ccccd, + 0x4002b,0x1b1,0x1879,0x3,0x4002b,0x1b1,0x187a,0x2,0x4002b,0x1b1,0x187b,0x7, + 0x4002b,0x1b1,0x187c,0x6,0x4002b,0x1b1,0x187d,0x5,0x4002b,0x1b1,0x187e,0x4, + 0x50036,0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003b,0x3cf,0xb95,0x7,0x4003d, + 0x7a4,0x7a7,0x7a6,0x7004f,0x305,0x7a8,0x7a7,0x7a7,0x0,0x1,0x4007c,0x4d, + 0x7a9,0x7a8,0x4006f,0x1f,0x828,0x7a9,0x50081,0x1f,0x82a,0x828,0x2f1,0x50041, + 0x15d,0x888,0x15b,0x24c,0x4003d,0x4d,0x889,0x888,0x4006f,0x1f,0x82c,0x889, + 0x50088,0x1f,0x82d,0x82a,0x82c,0x50041,0x16d,0x88c,0x15b,0x1879,0x4003d,0x1f, + 0x88d,0x88c,0x50041,0x15d,0x890,0x15b,0x15c,0x4003d,0x4d,0x891,0x890,0x4006f, + 0x1f,0x833,0x891,0x50088,0x1f,0x834,0x88d,0x833,0x50081,0x1f,0x835,0x82d, + 0x834,0x50041,0x15d,0x898,0x15b,0x187a,0x4003d,0x4d,0x899,0x898,0x50085,0x1f, + 0x8a6,0x835,0x833,0x50083,0x1f,0x8a9,0x833,0x2f1,0x7000c,0x1f,0x8b6,0x1, + 0x25,0x8a6,0x8a9,0x7000c,0x1f,0x8bb,0x1,0x28,0x2f1,0x8b6,0x4006f,0x1f, + 0x8af,0x899,0x50088,0x1f,0x8b0,0x8bb,0x8af,0x50085,0x1f,0x8c3,0x82d,0x833, + 0x4006e,0x4d,0x8c4,0x8c3,0x4003d,0x18c,0x8cd,0x1cc,0x7005f,0x3e,0x8cf,0x8cd, + 0x8c4,0x2,0x15c,0x7004f,0x1f,0x8d0,0x8cf,0x8cf,0x0,0x1,0x50085,0x1f, + 0x8d4,0x8d0,0x1eb,0x6000c,0x6,0x8d5,0x1,0x42,0x8d4,0x50081,0x1f,0x8dc, + 0x82d,0x8d0,0x50051,0x6,0x8e5,0x8dc,0x0,0x500be,0x97,0x8e6,0x8e5,0x122, + 0x300f7,0x8eb,0x0,0x400fa,0x8e6,0x8e7,0x8eb,0x200f8,0x8e7,0x500bc,0x97,0x8ea, + 0x8e5,0x123,0x200f9,0x8eb,0x200f8,0x8eb,0x700f5,0x97,0x8ec,0x8e6,0x5,0x8ea, + 0x8e7,0x300f7,0x8f7,0x0,0x400fa,0x8ec,0x8ed,0x8f7,0x200f8,0x8ed,0x50051,0x6, + 0x8ef,0x8dc,0x1,0x500be,0x97,0x8f0,0x8ef,0x122,0x300f7,0x8f5,0x0,0x400fa, + 0x8f0,0x8f1,0x8f5,0x200f8,0x8f1,0x500bc,0x97,0x8f4,0x8ef,0x123,0x200f9,0x8f5, + 0x200f8,0x8f5,0x700f5,0x97,0x8f6,0x8f0,0x8ed,0x8f4,0x8f1,0x200f9,0x8f7,0x200f8, + 0x8f7,0x700f5,0x97,0x8f8,0x8ec,0x8eb,0x8f6,0x8f5,0x7000c,0x1f,0x91d,0x1, + 0x25,0x8c3,0x8a9,0x7000c,0x1f,0x922,0x1,0x28,0x2f1,0x91d,0x50088,0x1f, + 0x917,0x922,0x8af,0x4003d,0x18c,0x925,0x1b6,0x4003d,0x197,0x926,0x199,0x50056, + 0x19b,0x927,0x925,0x926,0x70058,0x3e,0x929,0x927,0x917,0x2,0x122,0x50051, + 0x6,0x92a,0x929,0x0,0x50087,0x4d,0x851,0x891,0x17cb,0x4003d,0x18c,0x931, + 0x1a7,0x50067,0x4d,0x932,0x931,0x15c,0x4006f,0x1f,0x93e,0x851,0x50085,0x1f, + 0x93f,0x835,0x93e,0x50083,0x1f,0x942,0x93e,0x2f1,0x7000c,0x1f,0x94f,0x1, + 0x25,0x93f,0x942,0x7000c,0x1f,0x954,0x1,0x28,0x2f1,0x94f,0x4006f,0x1f, + 0x948,0x932,0x50088,0x1f,0x949,0x954,0x948,0x4003d,0x18c,0x957,0x1a7,0x4003d, + 0x197,0x958,0x199,0x50056,0x19b,0x959,0x957,0x958,0x70058,0x3e,0x95b,0x959, + 0x949,0x2,0x122,0x50051,0x6,0x95c,0x95b,0x0,0x400a8,0x97,0x85b,0x8f8, + 0x300f7,0x860,0x0,0x400fa,0x8f8,0x85d,0x860,0x200f8,0x85d,0x50041,0x178,0x95f, + 0x15b,0x187b,0x4003d,0x6,0x960,0x95f,0x500b4,0x97,0x85f,0x122,0x960,0x200f9, + 0x860,0x200f8,0x860,0x700f5,0x97,0x861,0x85b,0x8f7,0x85f,0x85d,0x4003d,0x18c, + 0x963,0x1e0,0x4003d,0x197,0x964,0x199,0x50056,0x19b,0x965,0x963,0x964,0x70058, + 0x3e,0x967,0x965,0x8b0,0x2,0x122,0x50051,0x6,0x867,0x967,0x0,0x8000c, + 0x6,0x96b,0x1,0x2b,0x867,0x122,0x123,0x50051,0x6,0x86b,0x967,0x1, + 0x8000c,0x6,0x96f,0x1,0x2b,0x86b,0x122,0x123,0x50051,0x6,0x86f,0x967, + 0x2,0x8000c,0x6,0x973,0x1,0x2b,0x86f,0x122,0x123,0x50051,0x6,0x873, + 0x967,0x3,0x8000c,0x6,0x977,0x1,0x2b,0x873,0x122,0x123,0x50085,0x6, + 0x878,0x977,0x745,0x6000c,0x6,0x879,0x1,0x1,0x878,0x500ba,0x97,0x87a, + 0x879,0x123,0x600a9,0x6,0x87b,0x87a,0x123,0x122,0x50085,0x6,0x87e,0x977, + 0x87b,0x300f7,0x7da,0x0,0x400fa,0x8f8,0x7d6,0x7da,0x200f8,0x7d6,0x400a8,0x97, + 0x7d9,0x861,0x200f9,0x7da,0x200f8,0x7da,0x700f5,0x97,0x7db,0x8f8,0x860,0x7d9, + 0x7d6,0x300f7,0x7e1,0x0,0x400fa,0x7db,0x7dc,0x7e1,0x200f8,0x7dc,0x50085,0x1f, + 0x9b5,0x8dc,0x82c,0x50083,0x1f,0x9b8,0x9b5,0x2f1,0x6000c,0x1f,0x9b9,0x1, + 0x8,0x9b8,0x50081,0x1f,0x9bb,0x9b9,0x2f1,0x50083,0x1f,0x9be,0x9b5,0x9bb, + 0x5008e,0x1f,0x9c2,0x9be,0x26a,0x50083,0x1f,0x9c4,0x17cc,0x9c2,0x50085,0x1f, + 0x9c5,0x9be,0x9c4,0x50081,0x1f,0x9c7,0x17cd,0x9c5,0x50085,0x1f,0x9c8,0x9be, + 0x9c7,0x50085,0x1f,0x9cb,0x9be,0x9be,0x5008e,0x1f,0x9cd,0x9be,0x4ff,0x50081, + 0x1f,0x9cf,0x17ce,0x9cd,0x50085,0x1f,0x9d0,0x9cb,0x9cf,0x50081,0x1f,0x9d2, + 0x17cc,0x9d0,0x50083,0x1f,0x9d8,0x17cf,0x9cd,0x50085,0x1f,0x9d9,0x9be,0x9d8, + 0x50081,0x1f,0x9db,0x2f1,0x9d9,0x50085,0x1f,0x9dc,0x9be,0x9db,0x50081,0x1f, + 0x9e3,0x17cd,0x9c2,0x50085,0x1f,0x9e4,0x9cb,0x9e3,0x50081,0x1f,0x9e7,0x9d2, + 0x9dc,0x50081,0x1f,0x9ea,0x9b9,0x17cd,0x50088,0x1f,0x9ec,0x9ea,0x82c,0x50081, + 0x1f,0x9ef,0x9b9,0x17d1,0x50088,0x1f,0x9f1,0x9ef,0x82c,0x50088,0x1f,0x9f5, + 0x9dc,0x9e7,0x50081,0x1f,0x9f6,0x9bb,0x9f5,0x50088,0x1f,0x9f8,0x9f6,0x82c, + 0x50051,0x6,0x9fa,0x9e7,0x0,0x50051,0x6,0x9fc,0x9c8,0x1,0x50085,0x6, + 0x9fd,0x9fa,0x9fc,0x50051,0x6,0x9ff,0x9c8,0x0,0x50051,0x6,0xa01,0x9e7, + 0x1,0x50085,0x6,0xa02,0x9ff,0xa01,0x50085,0x6,0xa07,0x9fa,0xa01,0x50051, + 0x6,0xa09,0x9e4,0x0,0x50085,0x6,0xa0c,0xa09,0xa01,0x50051,0x6,0xa10, + 0x9e4,0x1,0x50085,0x6,0xa11,0x9fa,0xa10,0x50051,0x6,0xa13,0x9f8,0x0, + 0x50051,0x6,0xa15,0x9ec,0x1,0x50050,0x1f,0xa16,0xa13,0xa15,0x4003d,0x18c, + 0xa49,0x195,0x4003d,0x197,0xa4a,0x199,0x50056,0x19b,0xa4b,0xa49,0xa4a,0x70058, + 0x3e,0xa4d,0xa4b,0xa16,0x2,0x122,0x5008e,0x3e,0xa19,0xa4d,0x9fd,0x50051, + 0x6,0xa1b,0x9ec,0x0,0x50051,0x6,0xa1d,0x9f8,0x1,0x50050,0x1f,0xa1e, + 0xa1b,0xa1d,0x4003d,0x18c,0xa50,0x195,0x4003d,0x197,0xa51,0x199,0x50056,0x19b, + 0xa52,0xa50,0xa51,0x70058,0x3e,0xa54,0xa52,0xa1e,0x2,0x122,0x5008e,0x3e, + 0xa21,0xa54,0xa02,0x50081,0x3e,0xa22,0xa19,0xa21,0x4003d,0x18c,0xa57,0x195, + 0x4003d,0x197,0xa58,0x199,0x50056,0x19b,0xa59,0xa57,0xa58,0x70058,0x3e,0xa5b, + 0xa59,0x9f8,0x2,0x122,0x5008e,0x3e,0xa26,0xa5b,0xa07,0x50081,0x3e,0xa27, + 0xa22,0xa26,0x50051,0x6,0xa29,0x9f1,0x0,0x50050,0x1f,0xa2c,0xa29,0xa1d, + 0x4003d,0x18c,0xa5e,0x195,0x4003d,0x197,0xa5f,0x199,0x50056,0x19b,0xa60,0xa5e, + 0xa5f,0x70058,0x3e,0xa62,0xa60,0xa2c,0x2,0x122,0x5008e,0x3e,0xa2f,0xa62, + 0xa0c,0x50081,0x3e,0xa30,0xa27,0xa2f,0x50051,0x6,0xa34,0x9f1,0x1,0x50050, + 0x1f,0xa35,0xa13,0xa34,0x4003d,0x18c,0xa65,0x195,0x4003d,0x197,0xa66,0x199, + 0x50056,0x19b,0xa67,0xa65,0xa66,0x70058,0x3e,0xa69,0xa67,0xa35,0x2,0x122, + 0x5008e,0x3e,0xa38,0xa69,0xa11,0x50081,0x3e,0xa39,0xa30,0xa38,0x50081,0x6, + 0xa3d,0x9fd,0xa02,0x50081,0x6,0xa3f,0xa3d,0xa07,0x50081,0x6,0xa41,0xa3f, + 0xa0c,0x50081,0x6,0xa43,0xa41,0xa11,0x70050,0x3e,0xa44,0xa43,0xa43,0xa43, + 0xa43,0x50088,0x3e,0xa45,0xa39,0xa44,0x7000c,0x3e,0xa6e,0x1,0x28,0xa45, + 0x58c,0x8004f,0xe,0x982,0xa6e,0xa6e,0x0,0x1,0x2,0x50041,0x178,0xa71, + 0x15b,0x187c,0x4003d,0x6,0xa72,0xa71,0x5008e,0xe,0x987,0x982,0xa72,0x4003d, + 0x18c,0xa76,0x1d4,0x7005f,0x3e,0xa77,0xa76,0x1d6,0x2,0x15c,0x50051,0x6, + 0xa78,0xa77,0x0,0x500b4,0x97,0xa7a,0xa78,0x122,0x600a9,0x6,0x17d9,0xa7a, + 0x123,0xa78,0x5008e,0xe,0x98c,0x987,0x17d9,0x50051,0x6,0xa82,0x98c,0x0, + 0x50085,0x6,0xa83,0x266,0xa82,0x50051,0x6,0xa85,0x98c,0x1,0x50085,0x6, + 0xa86,0x26a,0xa85,0x50081,0x6,0xa87,0xa83,0xa86,0x50051,0x6,0xa89,0x98c, + 0x2,0x50085,0x6,0xa8a,0x266,0xa89,0x50081,0x6,0xa8b,0xa87,0xa8a,0x50083, + 0x6,0x17d2,0xa82,0xa89,0x50085,0x6,0xa92,0x26a,0x17d2,0x50085,0x6,0xa95, + 0x27a,0xa82,0x50081,0x6,0xa99,0xa95,0xa86,0x50083,0x6,0xa9d,0xa99,0xa8a, + 0x60050,0xe,0xa9e,0xa8b,0xa92,0xa9d,0x50051,0x6,0x993,0xa6e,0x3,0x200f9, + 0x7e1,0x200f8,0x7e1,0x700f5,0xe,0x151f,0x352,0x7da,0xa9e,0x7dc,0x700f5,0x6, + 0x151d,0x122,0x7da,0x993,0x7dc,0x400a8,0x97,0xaba,0x861,0x600a9,0x6,0xabb, + 0xaba,0x123,0x122,0x50085,0x6,0xabe,0x151d,0xabb,0x8000c,0x6,0xb04,0x1, + 0x2b,0x973,0x122,0x123,0x7000c,0x6,0xb09,0x1,0x28,0x96b,0x96f,0x7000c, + 0x6,0xb0e,0x1,0x28,0xb04,0xb09,0x50085,0x6,0xacc,0xb0e,0x50a,0x50083, + 0x6,0xacd,0xabe,0xacc,0x7000c,0x6,0xb13,0x1,0x28,0x122,0xacd,0x50083, + 0x6,0xad2,0xb13,0x123,0x8000c,0x6,0xb17,0x1,0x2b,0xad2,0x122,0x123, + 0x8000c,0x6,0xb1b,0x1,0x2b,0xb17,0x122,0x123,0x4003d,0x1bf,0xb1e,0x1c1, + 0x50062,0x3e,0xb20,0xb1e,0x7a9,0x50051,0x6,0xb21,0xb20,0x0,0x7000c,0x6, + 0xb26,0x1,0x28,0x122,0x96b,0x50083,0x6,0xae0,0x123,0xb26,0x50085,0x6, + 0xae1,0xb21,0xae0,0x50081,0x6,0xae5,0xb13,0xae1,0x7000c,0x6,0xb2b,0x1, + 0x25,0xae5,0x50a,0x7000c,0x6,0xb30,0x1,0x28,0x122,0xb2b,0x50041,0x178, + 0xb33,0x15b,0x187d,0x4003d,0x6,0xb34,0xb33,0x50088,0x6,0xaea,0x6a5,0xb34, + 0x50083,0x6,0xaec,0x123,0xb0e,0x50085,0x6,0xaed,0xaea,0xaec,0x50083,0x6, + 0xaf1,0xb30,0xaed,0x7000c,0x6,0xb39,0x1,0x28,0x122,0xaf1,0x50083,0x1f, + 0xaf8,0x82d,0x8d0,0x50051,0x6,0xb3d,0xaf8,0x0,0x500be,0x97,0xb3e,0xb3d, + 0x122,0x300f7,0xb43,0x0,0x400fa,0xb3e,0xb3f,0xb43,0x200f8,0xb3f,0x500bc,0x97, + 0xb42,0xb3d,0x123,0x200f9,0xb43,0x200f8,0xb43,0x700f5,0x97,0xb44,0xb3e,0x7e1, + 0xb42,0xb3f,0x300f7,0xb4f,0x0,0x400fa,0xb44,0xb45,0xb4f,0x200f8,0xb45,0x50051, + 0x6,0xb47,0xaf8,0x1,0x500be,0x97,0xb48,0xb47,0x122,0x300f7,0xb4d,0x0, + 0x400fa,0xb48,0xb49,0xb4d,0x200f8,0xb49,0x500bc,0x97,0xb4c,0xb47,0x123,0x200f9, + 0xb4d,0x200f8,0xb4d,0x700f5,0x97,0xb4e,0xb48,0xb45,0xb4c,0xb49,0x200f9,0xb4f, + 0x200f8,0xb4f,0x700f5,0x97,0xb50,0xb44,0xb43,0xb4e,0xb4d,0x600a9,0x6,0xafc, + 0xb50,0x123,0x122,0x50085,0x6,0xaff,0xb39,0xafc,0x50041,0x178,0xb6a,0x15b, + 0x7b9,0x4003d,0x6,0xb6b,0xb6a,0x50085,0x6,0xb5e,0x8d5,0xb6b,0x50085,0x6, + 0xb5f,0xb5e,0x50a,0x7000c,0x6,0xb70,0x1,0x28,0x122,0xb5f,0x8000c,0x6, + 0xb74,0x1,0x2b,0xb70,0x122,0x123,0x8000c,0x6,0xb7a,0x1,0x2e,0x87e, + 0x6c5,0xb74,0x7000c,0x6,0xb7f,0x1,0x25,0x87e,0xb7a,0x50041,0x16d,0xcdf, + 0x15b,0x187e,0x4003d,0x1f,0xce0,0xcdf,0x50085,0x1f,0xbc8,0x82a,0xce0,0x6000c, + 0x1f,0xbca,0x1,0x8,0xbc8,0x4006e,0x4d,0xbcb,0xbca,0x4006f,0x1f,0xbcd, + 0xbcb,0x50081,0x1f,0xbce,0xbcd,0x2f1,0x50083,0x1f,0xbd0,0xbce,0x88d,0x50083, + 0x1f,0xbd3,0xbd0,0xbc8,0x50051,0x6,0xbd5,0xbd0,0x0,0x50051,0x6,0xbd7, + 0xbc8,0x0,0x500ba,0x97,0xbd8,0xbd5,0xbd7,0x600a9,0x2b,0xbd9,0xbd8,0x37e, + 0x37f,0x50051,0x6,0xbdc,0xbd0,0x1,0x50051,0x6,0xbde,0xbc8,0x1,0x500ba, + 0x97,0xbdf,0xbdc,0xbde,0x600a9,0x2b,0xbe0,0xbdf,0x37e,0x37f,0x50050,0x4d, + 0x1889,0xbd9,0xbe0,0x4006f,0x1f,0xbed,0x1889,0x500b4,0x97,0xbef,0x87e,0x122, + 0x200f9,0xbf0,0x200f8,0xbf0,0x700f5,0x2b,0x1575,0x15c,0xb4f,0xc1f,0xc1d,0x700f5, + 0x2b,0x16cb,0x15c,0xb4f,0x16ca,0xc1d,0x500b1,0x97,0xbf3,0x1575,0x1f1,0x400f6, + 0xc20,0xc1d,0x0,0x400fa,0xbf3,0xbf4,0xc20,0x200f8,0xbf4,0x200f9,0xbf5,0x200f8, + 0xbf5,0x700f5,0x2b,0x16ca,0x16cb,0xbf4,0xc18,0xc19,0x700f5,0x2b,0x16bd,0x15c, + 0xbf4,0xc1b,0xc19,0x500b1,0x97,0xbf8,0x16bd,0x1f1,0x400f6,0xc1c,0xc19,0x0, + 0x400fa,0xbf8,0xbf9,0xc1c,0x200f8,0xbf9,0x300f7,0xc00,0x0,0x400fa,0xbd8,0xbfb, + 0xbfe,0x200f8,0xbfb,0x50082,0x2b,0xbfd,0x1f1,0x16bd,0x200f9,0xc00,0x200f8,0xbfe, + 0x200f9,0xc00,0x200f8,0xc00,0x700f5,0x2b,0x16c0,0xbfd,0xbfb,0x16bd,0xbfe,0x300f7, + 0xc08,0x0,0x400fa,0xbdf,0xc03,0xc06,0x200f8,0xc03,0x50082,0x2b,0xc05,0x1f1, + 0x1575,0x200f9,0xc08,0x200f8,0xc06,0x200f9,0xc08,0x200f8,0xc08,0x700f5,0x2b,0x16c4, + 0xc05,0xc03,0x1575,0xc06,0x50050,0x4d,0xc0a,0x16c0,0x16c4,0x50080,0x4d,0xc0d, + 0xbcb,0x1889,0x50080,0x4d,0xc0f,0xc0d,0xc0a,0x50051,0x2b,0xcf8,0x891,0x0, + 0x50082,0x2b,0xcf9,0xcf8,0x1f7,0x50051,0x2b,0xcfb,0xc0f,0x0,0x7000c,0x2b, + 0xd0c,0x1,0x27,0xcfb,0xcf9,0x7000c,0x2b,0xd11,0x1,0x2a,0x15c,0xd0c, + 0x50051,0x2b,0xd00,0x891,0x1,0x50082,0x2b,0xd01,0xd00,0x1f7,0x50051,0x2b, + 0xd03,0xc0f,0x1,0x7000c,0x2b,0xd16,0x1,0x27,0xd03,0xd01,0x7000c,0x2b, + 0xd1b,0x1,0x2a,0x15c,0xd16,0x50050,0x4d,0x188a,0xd11,0xd1b,0x4003d,0x18c, + 0xd2e,0x18e,0x7005f,0x3e,0xd30,0xd2e,0x188a,0x2,0x15c,0x8004f,0xe,0xd31, + 0xd30,0xd30,0x0,0x1,0x2,0x7000c,0xe,0xd36,0x1,0x28,0x352,0xd31, + 0x4003d,0x18c,0xd3a,0x1d4,0x7005f,0x3e,0xd3b,0xd3a,0x1d6,0x2,0x15c,0x50051, + 0x6,0xd3c,0xd3b,0x0,0x500b4,0x97,0xd3e,0xd3c,0x122,0x600a9,0x6,0x17da, + 0xd3e,0x123,0xd3c,0x5008e,0xe,0xd28,0xd36,0x17da,0x50051,0x6,0xd46,0xd28, + 0x0,0x50085,0x6,0xd47,0x266,0xd46,0x50051,0x6,0xd49,0xd28,0x1,0x50085, + 0x6,0xd4a,0x26a,0xd49,0x50081,0x6,0xd4b,0xd47,0xd4a,0x50051,0x6,0xd4d, + 0xd28,0x2,0x50085,0x6,0xd4e,0x266,0xd4d,0x50081,0x6,0xd4f,0xd4b,0xd4e, + 0x50083,0x6,0x17d8,0xd46,0xd4d,0x50085,0x6,0xd56,0x26a,0x17d8,0x50085,0x6, + 0xd59,0x27a,0xd46,0x50081,0x6,0xd5d,0xd59,0xd4a,0x50083,0x6,0xd61,0xd5d, + 0xd4e,0x60050,0xe,0xd62,0xd4f,0xd56,0xd61,0x50041,0xf,0xc16,0xb95,0x16ca, + 0x3003e,0xc16,0xd62,0x50080,0x2b,0xc18,0x16ca,0x1f7,0x200f9,0xc19,0x200f8,0xc19, + 0x50080,0x2b,0xc1b,0x16bd,0x1f7,0x200f9,0xbf5,0x200f8,0xc1c,0x200f9,0xc1d,0x200f8, + 0xc1d,0x50080,0x2b,0xc1f,0x1575,0x1f7,0x200f9,0xbf0,0x200f8,0xc20,0x300f7,0xc34, + 0x0,0x400fa,0xbef,0xc22,0xc34,0x200f8,0xc22,0x200f9,0xc23,0x200f8,0xc23,0x700f5, + 0x2b,0x1577,0x15c,0xc22,0xc32,0xc27,0x500b1,0x97,0xc26,0x1577,0x3e5,0x400f6, + 0xc33,0xc27,0x0,0x400fa,0xc26,0xc27,0xc33,0x200f8,0xc27,0x50041,0xf,0xc2a, + 0xb95,0x1577,0x4003d,0xe,0xc2b,0xc2a,0x50051,0x6,0xd68,0xc2b,0x0,0x50051, + 0x6,0xd6a,0xc2b,0x1,0x50081,0x6,0xd6b,0xd68,0xd6a,0x50051,0x6,0xd6d, + 0xc2b,0x2,0x50083,0x6,0xd6e,0xd6b,0xd6d,0x50081,0x6,0xd73,0xd68,0xd6d, + 0x50083,0x6,0xd78,0xd68,0xd6a,0x50083,0x6,0xd7b,0xd78,0xd6d,0x60050,0xe, + 0xd7c,0xd6e,0xd73,0xd7b,0x7000c,0x6,0xd97,0x1,0x28,0x122,0xd6e,0x7000c, + 0x6,0xd9c,0x1,0x28,0xd73,0xd7b,0x7000c,0x6,0xda1,0x1,0x28,0xd97, + 0xd9c,0x50081,0x6,0xd90,0xda1,0x123,0x60050,0xe,0xd91,0xd90,0xd90,0xd90, + 0x50088,0xe,0xd92,0xd7c,0xd91,0x50051,0x6,0xda6,0xd92,0x0,0x50085,0x6, + 0xda7,0x266,0xda6,0x50051,0x6,0xda9,0xd92,0x1,0x50085,0x6,0xdaa,0x26a, + 0xda9,0x50081,0x6,0xdab,0xda7,0xdaa,0x50051,0x6,0xdad,0xd92,0x2,0x50085, + 0x6,0xdae,0x266,0xdad,0x50081,0x6,0xdaf,0xdab,0xdae,0x50083,0x6,0x17d7, + 0xda6,0xdad,0x50085,0x6,0xdb6,0x26a,0x17d7,0x50085,0x6,0xdb9,0x27a,0xda6, + 0x50081,0x6,0xdbd,0xdb9,0xdaa,0x50083,0x6,0xdc1,0xdbd,0xdae,0x60050,0xe, + 0xdc2,0xdaf,0xdb6,0xdc1,0x3003e,0xc2a,0xdc2,0x50080,0x2b,0xc32,0x1577,0x1f7, + 0x200f9,0xc23,0x200f8,0xc33,0x200f9,0xc34,0x200f8,0xc34,0x50088,0x1f,0xdcb,0x17cc, + 0xce0,0x50083,0x1f,0xdcd,0xdcb,0x17cc,0x50051,0x6,0xdce,0xdcd,0x0,0x50081, + 0x6,0xdcf,0x123,0xdce,0x7000c,0x6,0xdda,0x1,0x25,0x34a,0xdcf,0x50081, + 0x6,0xc39,0x123,0xdda,0x50085,0x6,0xc3a,0xc39,0x3fc,0x7000c,0x6,0xddf, + 0x1,0x28,0x123,0xc3a,0x50085,0x6,0xc3d,0x96f,0x26a,0x50083,0x6,0xc3e, + 0x123,0xc3d,0x50083,0x6,0xc40,0x123,0x973,0x50085,0x6,0xc43,0xb7f,0x409, + 0x8000c,0x6,0xde3,0x1,0x2b,0xc43,0x122,0x123,0x7000c,0x6,0xde8,0x1, + 0x25,0xc40,0xde3,0x7000c,0x6,0xded,0x1,0x25,0xc3e,0xde8,0x8000c,0x6, + 0xdf3,0x1,0x2e,0xddf,0xdda,0xded,0x200f9,0xc4b,0x200f8,0xc4b,0x700f5,0xe, + 0x15a7,0x352,0xc34,0x1696,0xcaa,0x700f5,0x6,0x15a5,0x122,0xc34,0x1699,0xcaa, + 0x700f5,0xe,0x159e,0x148d,0xc34,0x16b5,0xcaa,0x700f5,0xe,0x159d,0x148d,0xc34, + 0x16b1,0xcaa,0x700f5,0xe,0x159c,0x148d,0xc34,0x16ad,0xcaa,0x700f5,0xe,0x159b, + 0x148d,0xc34,0x16a9,0xcaa,0x700f5,0x6,0x159a,0x148a,0xc34,0x16a5,0xcaa,0x700f5, + 0x2b,0x1599,0x15c,0xc34,0xcac,0xcaa,0x700f5,0x2b,0x1693,0x15c,0xc34,0x1692, + 0xcaa,0x500b1,0x97,0xc4e,0x1599,0x1f1,0x400f6,0xcad,0xcaa,0x0,0x400fa,0xc4e, + 0xc4f,0xcad,0x200f8,0xc4f,0x200f9,0xc50,0x200f8,0xc50,0x700f5,0xe,0x16b5,0x159e, + 0xc4f,0x16ba,0xca6,0x700f5,0xe,0x16b1,0x159d,0xc4f,0x16b9,0xca6,0x700f5,0xe, + 0x16ad,0x159c,0xc4f,0x16b8,0xca6,0x700f5,0xe,0x16a9,0x159b,0xc4f,0x16b7,0xca6, + 0x700f5,0x6,0x16a5,0x159a,0xc4f,0x16b6,0xca6,0x700f5,0x6,0x1699,0x15a5,0xc4f, + 0x17c2,0xca6,0x700f5,0xe,0x1696,0x15a7,0xc4f,0x17c0,0xca6,0x700f5,0x2b,0x1692, + 0x1693,0xc4f,0xca5,0xca6,0x700f5,0x2b,0x1664,0x15c,0xc4f,0xca8,0xca6,0x500b1, + 0x97,0xc53,0x1664,0x1f1,0x400f6,0xca9,0xca6,0x0,0x400fa,0xc53,0xc54,0xca9, + 0x200f8,0xc54,0x300f7,0xc5b,0x0,0x400fa,0xbd8,0xc56,0xc59,0x200f8,0xc56,0x50082, + 0x2b,0xc58,0x1f1,0x1664,0x200f9,0xc5b,0x200f8,0xc59,0x200f9,0xc5b,0x200f8,0xc5b, + 0x700f5,0x2b,0x166b,0xc58,0xc56,0x1664,0xc59,0x300f7,0xc63,0x0,0x400fa,0xbdf, + 0xc5e,0xc61,0x200f8,0xc5e,0x50082,0x2b,0xc60,0x1f1,0x1599,0x200f9,0xc63,0x200f8, + 0xc61,0x200f9,0xc63,0x200f8,0xc63,0x700f5,0x2b,0x1673,0xc60,0xc5e,0x1599,0xc61, + 0x50050,0x4d,0xc65,0x166b,0x1673,0x4006f,0x1f,0xc68,0xc65,0x50081,0x1f,0xc69, + 0xbed,0xc68,0x50081,0x1f,0xc6c,0xbd3,0xc69,0x50080,0x4d,0xc6f,0xbcb,0x1889, + 0x50080,0x4d,0xc71,0xc6f,0xc65,0x4007c,0x305,0xdfb,0xc71,0x4007c,0x305,0xdfd, + 0x891,0x500b0,0x309,0xdfe,0xdfb,0xdfd,0x4009b,0x97,0xdff,0xdfe,0x600a9,0x6, + 0xc75,0xdff,0x123,0x122,0x400a8,0x97,0xc77,0xbef,0x300f7,0xc8c,0x0,0x400fa, + 0xc77,0xc78,0xc8c,0x200f8,0xc78,0x50050,0x1f,0xe07,0xdf3,0xdf3,0x50085,0x1f, + 0xe08,0xc6c,0xe07,0x50094,0x6,0xe0b,0xe08,0xe08,0x7000c,0x6,0xe1b,0x1, + 0x25,0xe0b,0x324,0x50085,0x6,0xe21,0x30f,0xe1b,0x50083,0x6,0xe22,0xe21, + 0x123,0x50085,0x6,0xe24,0x266,0xe1b,0x50083,0x6,0xe25,0xe24,0x123,0x50085, + 0x6,0xe27,0x317,0xe22,0x50085,0x6,0xe29,0xe27,0xe22,0x50083,0x6,0xe2a, + 0xe29,0x31c,0x50085,0x6,0xe2d,0xe25,0xe25,0x50085,0x6,0xe2e,0xe2a,0xe2d, + 0x50085,0x6,0xc7d,0xc75,0xe2e,0x50041,0xf,0xc7f,0xb95,0x1692,0x4003d,0xe, + 0xc80,0xc7f,0x5008e,0xe,0xc82,0xc80,0xc7d,0x50081,0xe,0xc85,0x1696,0xc82, + 0x50081,0x6,0xc8a,0x1699,0xc7d,0x200f9,0xc8c,0x200f8,0xc8c,0x700f5,0x6,0x17c2, + 0x1699,0xc63,0xc8a,0xc78,0x700f5,0xe,0x17c0,0x1696,0xc63,0xc85,0xc78,0x50094, + 0x6,0xc8f,0xc6c,0xc6c,0x50085,0x6,0xc91,0x474,0xc8f,0x6000c,0x6,0xc92, + 0x1,0x1b,0xc91,0x50085,0x6,0xc94,0xc92,0xc75,0x500aa,0x97,0xc96,0x1599, + 0x15c,0x500aa,0x97,0xc98,0x1664,0x15c,0x500a7,0x97,0xc99,0xc96,0xc98,0x50041, + 0xf,0xc9b,0xb95,0x1692,0x4003d,0xe,0xc9c,0xc9b,0x300f7,0xe54,0x0,0x400fa, + 0xc99,0xe37,0xe3b,0x200f8,0xe37,0x5008e,0xe,0xe59,0xc9c,0xc94,0x50085,0xe, + 0xe5d,0xc9c,0xe59,0x200f9,0xe54,0x200f8,0xe3b,0x7000c,0xe,0xe64,0x1,0x25, + 0x16ad,0xc9c,0x7000c,0xe,0xe69,0x1,0x28,0x16a9,0xc9c,0x5008e,0xe,0xe44, + 0xc9c,0xc94,0x50081,0xe,0xe48,0x16b5,0xe44,0x50085,0xe,0xe4b,0xc9c,0xe44, + 0x50081,0xe,0xe4e,0x16b1,0xe4b,0x50081,0x6,0xe52,0x16a5,0xc94,0x200f9,0xe54, + 0x200f8,0xe54,0x700f5,0xe,0x16ba,0xe59,0xe37,0xe48,0xe3b,0x700f5,0xe,0x16b9, + 0xe5d,0xe37,0xe4e,0xe3b,0x700f5,0xe,0x16b8,0xc9c,0xe37,0xe64,0xe3b,0x700f5, + 0xe,0x16b7,0xc9c,0xe37,0xe69,0xe3b,0x700f5,0x6,0x16b6,0xc94,0xe37,0xe52, + 0xe3b,0x50080,0x2b,0xca5,0x1692,0x1f7,0x200f9,0xca6,0x200f8,0xca6,0x50080,0x2b, + 0xca8,0x1664,0x1f7,0x200f9,0xc50,0x200f8,0xca9,0x200f9,0xcaa,0x200f8,0xcaa,0x50080, + 0x2b,0xcac,0x1599,0x1f7,0x200f9,0xc4b,0x200f8,0xcad,0x6000c,0x6,0xe6f,0x1, + 0x4,0x159a,0x500ba,0x97,0xe70,0xe6f,0x224,0x600a9,0x6,0x17db,0xe70,0x159a, + 0x123,0x60050,0xe,0xe7c,0x17db,0x17db,0x17db,0x50088,0xe,0xe7d,0x159e,0xe7c, + 0x50088,0xe,0xe84,0x159d,0xe7c,0x50085,0xe,0xe8c,0xe7d,0xe7d,0x50083,0xe, + 0xe8d,0xe84,0xe8c,0x6000c,0xe,0xe8e,0x1,0x4,0xe8d,0x6000c,0xe,0xe8f, + 0x1,0x1f,0xe8e,0x500ba,0x97,0xcb5,0x15a5,0x2a0,0x600a9,0x6,0xcb6,0xcb5, + 0x123,0x122,0x50085,0x6,0xcb9,0x15a5,0xcb6,0x500ba,0x97,0xcbd,0xcb9,0x2a0, + 0x300f7,0xcd1,0x0,0x400fa,0xcbd,0xcbe,0xcd1,0x200f8,0xcbe,0x60050,0xe,0xcc3, + 0xcb9,0xcb9,0xcb9,0x50088,0xe,0xcc4,0x15a7,0xcc3,0x50085,0x6,0xcc8,0xcb9, + 0x4ac,0x8000c,0xe,0xe98,0x1,0x2b,0xcc4,0x159c,0x159b,0x200f9,0xcd1,0x200f8, + 0xcd1,0x700f5,0xe,0x15c1,0x15a7,0xcad,0xe98,0xcbe,0x700f5,0x6,0x15bf,0xcb9, + 0xcad,0xcc8,0xcbe,0x300f7,0xcdc,0x0,0x400fa,0xbef,0xcd3,0xcdc,0x200f8,0xcd3, + 0x50051,0x6,0xe9d,0xe7d,0x0,0x50051,0x6,0xe9f,0xe7d,0x1,0x50081,0x6, + 0xea0,0xe9d,0xe9f,0x50051,0x6,0xea2,0xe7d,0x2,0x50083,0x6,0xea3,0xea0, + 0xea2,0x50081,0x6,0xea8,0xe9d,0xea2,0x50083,0x6,0xead,0xe9d,0xe9f,0x50083, + 0x6,0xeb0,0xead,0xea2,0x60050,0xe,0xeb1,0xea3,0xea8,0xeb0,0x7000c,0x6, + 0xecc,0x1,0x28,0xea8,0xeb0,0x7000c,0x6,0xed1,0x1,0x28,0xea3,0xecc, + 0x50083,0x6,0xec4,0x123,0xed1,0x7000c,0x6,0xed6,0x1,0x28,0x2a0,0xec4, + 0x60050,0xe,0xec6,0xed6,0xed6,0xed6,0x50088,0xe,0xec7,0xeb1,0xec6,0x50051, + 0x6,0xedb,0xec7,0x0,0x50085,0x6,0xedc,0x266,0xedb,0x50051,0x6,0xede, + 0xec7,0x1,0x50085,0x6,0xedf,0x26a,0xede,0x50081,0x6,0xee0,0xedc,0xedf, + 0x50051,0x6,0xee2,0xec7,0x2,0x50085,0x6,0xee3,0x266,0xee2,0x50081,0x6, + 0xee4,0xee0,0xee3,0x50083,0x6,0x17d3,0xedb,0xee2,0x50085,0x6,0xeeb,0x26a, + 0x17d3,0x50085,0x6,0xeee,0x27a,0xedb,0x50081,0x6,0xef2,0xeee,0xedf,0x50083, + 0x6,0xef6,0xef2,0xee3,0x60050,0xe,0xef7,0xee4,0xeeb,0xef6,0x200f9,0xcdc, + 0x200f8,0xcdc,0x700f5,0xe,0x15c0,0x15c1,0xcd1,0xef7,0xcd3,0x600a9,0x6,0x17dc, + 0xbef,0x123,0x15bf,0x600a9,0x6,0x17dd,0xbef,0x122,0xb7f,0x50085,0x6,0xf1f, + 0x8d5,0x17d4,0x8000c,0x6,0xf63,0x1,0x2b,0xf1f,0x122,0x123,0x50085,0x6, + 0xf22,0x95c,0x17d4,0x50083,0x6,0xf23,0x5f6,0xf22,0x8000c,0x6,0xf67,0x1, + 0x2b,0xf23,0x122,0x123,0x50083,0x6,0xf26,0x123,0x87e,0x7000c,0x6,0xf6c, + 0x1,0x1a,0x96b,0x26a,0x7000c,0x6,0xf71,0x1,0x28,0xf6c,0x973,0x7000c, + 0x6,0xf76,0x1,0x28,0xf26,0xf71,0x7000c,0x6,0xf7b,0x1,0x28,0xf67, + 0xf76,0x7000c,0x6,0xf80,0x1,0x28,0xf63,0xf7b,0x8000c,0x6,0xf86,0x1, + 0x2e,0x61b,0x123,0xf80,0x50085,0xe,0xf37,0xe8f,0x625,0x5008e,0xe,0xf39, + 0xf37,0xf86,0x7000c,0xe,0xf8b,0x1,0x28,0xf39,0x62b,0x50083,0xe,0xf40, + 0x151f,0xe7d,0x50088,0xe,0xf42,0xf40,0xf8b,0x6000c,0x6,0xf44,0x1,0x42, + 0xf42,0x500ba,0x97,0xf45,0xf44,0x123,0x300f7,0xf5f,0x0,0x400fa,0xf45,0xf46, + 0xf5f,0x200f8,0xf46,0x6000c,0xe,0xf48,0x1,0x45,0xf42,0x50085,0xe,0xf4b, + 0xf48,0xf39,0x50081,0xe,0xf4e,0xf4b,0xe7d,0x7000c,0x6,0xf90,0x1,0x28, + 0x92a,0xb1b,0x50085,0x6,0xf54,0xf90,0x87e,0x50083,0x6,0xf56,0x123,0x96f, + 0x50085,0x6,0xf57,0xf54,0xf56,0x8000c,0x6,0xf94,0x1,0x2b,0xf57,0x122, + 0x123,0x60050,0xe,0xf9a,0xf94,0xf94,0xf94,0x8000c,0xe,0xf9b,0x1,0x2e, + 0xf4e,0x151f,0xf9a,0x200f9,0xf5f,0x200f8,0xf5f,0x700f5,0xe,0x1637,0x151f,0xcdc, + 0xf9b,0xf46,0x500ba,0x97,0xfae,0x17dd,0x2a0,0x600a9,0x6,0xfaf,0xfae,0x123, + 0x122,0x50085,0x6,0xfb2,0x17dd,0xfaf,0x50081,0x6,0xfb8,0xfb2,0x17dc,0x7000c, + 0x6,0xfe0,0x1,0x28,0x2a0,0xfb8,0x50051,0x6,0xfe5,0x15c0,0x0,0x50051, + 0x6,0xfe7,0x15c0,0x1,0x50081,0x6,0xfe8,0xfe5,0xfe7,0x50051,0x6,0xfea, + 0x15c0,0x2,0x50083,0x6,0xfeb,0xfe8,0xfea,0x50081,0x6,0xff0,0xfe5,0xfea, + 0x50083,0x6,0xff5,0xfe5,0xfe7,0x50083,0x6,0xff8,0xff5,0xfea,0x60050,0xe, + 0xff9,0xfeb,0xff0,0xff8,0x7000c,0x6,0x1014,0x1,0x28,0x122,0xfeb,0x7000c, + 0x6,0x1019,0x1,0x28,0xff0,0xff8,0x7000c,0x6,0x101e,0x1,0x28,0x1014, + 0x1019,0x50081,0x6,0x100d,0x101e,0x123,0x60050,0xe,0x100e,0x100d,0x100d,0x100d, + 0x50088,0xe,0x100f,0xff9,0x100e,0x50051,0x6,0x1023,0x100f,0x0,0x50085,0x6, + 0x1024,0x266,0x1023,0x50051,0x6,0x1026,0x100f,0x1,0x50085,0x6,0x1027,0x26a, + 0x1026,0x50081,0x6,0x1028,0x1024,0x1027,0x50051,0x6,0x102a,0x100f,0x2,0x50085, + 0x6,0x102b,0x266,0x102a,0x50081,0x6,0x102c,0x1028,0x102b,0x50083,0x6,0x17d5, + 0x1023,0x102a,0x50085,0x6,0x1033,0x26a,0x17d5,0x50085,0x6,0x1036,0x27a,0x1023, + 0x50081,0x6,0x103a,0x1036,0x1027,0x50083,0x6,0x103e,0x103a,0x102b,0x60050,0xe, + 0x103f,0x102c,0x1033,0x103e,0x50051,0x6,0x1045,0x1637,0x0,0x50051,0x6,0x1047, + 0x1637,0x1,0x50081,0x6,0x1048,0x1045,0x1047,0x50051,0x6,0x104a,0x1637,0x2, + 0x50083,0x6,0x104b,0x1048,0x104a,0x50081,0x6,0x1050,0x1045,0x104a,0x50083,0x6, + 0x1055,0x1045,0x1047,0x50083,0x6,0x1058,0x1055,0x104a,0x60050,0xe,0x1059,0x104b, + 0x1050,0x1058,0x7000c,0x6,0x1074,0x1,0x28,0x122,0x104b,0x7000c,0x6,0x1079, + 0x1,0x28,0x1050,0x1058,0x7000c,0x6,0x107e,0x1,0x28,0x1074,0x1079,0x50081, + 0x6,0x106d,0x107e,0x123,0x60050,0xe,0x106e,0x106d,0x106d,0x106d,0x50088,0xe, + 0x106f,0x1059,0x106e,0x50051,0x6,0x1083,0x106f,0x0,0x50085,0x6,0x1084,0x266, + 0x1083,0x50051,0x6,0x1086,0x106f,0x1,0x50085,0x6,0x1087,0x26a,0x1086,0x50081, + 0x6,0x1088,0x1084,0x1087,0x50051,0x6,0x108a,0x106f,0x2,0x50085,0x6,0x108b, + 0x266,0x108a,0x50081,0x6,0x108c,0x1088,0x108b,0x50083,0x6,0x17d6,0x1083,0x108a, + 0x50085,0x6,0x1093,0x26a,0x17d6,0x50085,0x6,0x1096,0x27a,0x1083,0x50081,0x6, + 0x109a,0x1096,0x1087,0x50083,0x6,0x109e,0x109a,0x108b,0x60050,0xe,0x109f,0x108c, + 0x1093,0x109e,0x50088,0x6,0xfcb,0x17dc,0xfe0,0x8000c,0x6,0x10a4,0x1,0x2b, + 0xfcb,0x122,0x123,0x60050,0xe,0x10aa,0x10a4,0x10a4,0x10a4,0x8000c,0xe,0x10ab, + 0x1,0x2e,0x109f,0x103f,0x10aa,0x50051,0x6,0x10b0,0x10ab,0x0,0x50051,0x6, + 0x10b2,0x10ab,0x1,0x50081,0x6,0x10b3,0x10b0,0x10b2,0x50051,0x6,0x10b5,0x10ab, + 0x2,0x50083,0x6,0x10b6,0x10b3,0x10b5,0x50081,0x6,0x10bb,0x10b0,0x10b5,0x50083, + 0x6,0x10c0,0x10b0,0x10b2,0x50083,0x6,0x10c3,0x10c0,0x10b5,0x60050,0xe,0x10c4, + 0x10b6,0x10bb,0x10c3,0x7000c,0x6,0x10df,0x1,0x28,0x10bb,0x10c3,0x7000c,0x6, + 0x10e4,0x1,0x28,0x10b6,0x10df,0x50083,0x6,0x10d7,0x123,0x10e4,0x7000c,0x6, + 0x10e9,0x1,0x28,0x2a0,0x10d7,0x60050,0xe,0x10d9,0x10e9,0x10e9,0x10e9,0x50088, + 0xe,0x10da,0x10c4,0x10d9,0x4003d,0x18c,0x10ed,0x1d4,0x7005f,0x3e,0x10ee,0x10ed, + 0x1d6,0x2,0x15c,0x50051,0x6,0x10ef,0x10ee,0x0,0x500b4,0x97,0x10f1,0x10ef, + 0x122,0x600a9,0x6,0x17de,0x10f1,0x123,0x10ef,0x60050,0xe,0x7f9,0x17de,0x17de, + 0x17de,0x50088,0xe,0x7fa,0x10da,0x7f9,0x7000c,0xe,0x10f9,0x1,0x28,0x7fa, + 0x352,0x50051,0x6,0x804,0x10f9,0x0,0x50051,0x6,0x805,0x10f9,0x1,0x50051, + 0x6,0x806,0x10f9,0x2,0x70050,0x3e,0x807,0x804,0x805,0x806,0xaff,0x4003d, + 0x1a1,0x10fb,0x1a3,0x40063,0x10fb,0x7a9,0x807,0x4003d,0x1bf,0x10ff,0x1c1,0x40063, + 0x10ff,0x7a9,0x58c,0x100fd,0x10038, +}; +static const char *fu0_accumulate_pass_1_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu0_accumulate_pass_1_cb_bind[] = {12}; +static const uint32_t fu0_accumulate_pass_1_cb_count[] = {1}; +static const uint32_t fu0_accumulate_pass_1_cb_space[] = {0}; +static const char *fu0_accumulate_pass_1_srv_tex_names[] = {"r_input_exposure", "r_dilated_reactive_masks", "r_dilated_motion_vectors", "r_internal_upscaled_color", "r_farthest_depth_mip1", "r_luma_instability", "r_input_color_jittered"}; +static const uint32_t fu0_accumulate_pass_1_srv_tex_bind[] = {0, 1, 2, 3, 5, 7, 8}; +static const uint32_t fu0_accumulate_pass_1_srv_tex_count[] = {1, 1, 1, 1, 1, 1, 1}; +static const uint32_t fu0_accumulate_pass_1_srv_tex_space[] = {0, 0, 0, 0, 0, 0, 0}; +static const char *fu0_accumulate_pass_1_uav_tex_names[] = {"rw_internal_upscaled_color", "rw_new_locks"}; +static const uint32_t fu0_accumulate_pass_1_uav_tex_bind[] = {9, 11}; +static const uint32_t fu0_accumulate_pass_1_uav_tex_count[] = {1, 1}; +static const uint32_t fu0_accumulate_pass_1_uav_tex_space[] = {0, 0}; +static const char *fu0_accumulate_pass_1_sampler_names[] = {"s_LinearClamp"}; +static const uint32_t fu0_accumulate_pass_1_sampler_bind[] = {1001}; +static const uint32_t fu0_accumulate_pass_1_sampler_count[] = {1}; +static const uint32_t fu0_accumulate_pass_1_sampler_space[] = {0}; + +static const uint32_t fu0_rcas_pass_0_spv[4973] = { + 0x7230203,0x10500,0x8000b,0x1248,0x0,0x20011,0x1,0x20011,0x38,0x6000b,0x1,0x4c534c47, + 0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0xb000f,0x5,0x4,0x6e69616d,0x0,0xd3, + 0xdb,0xe3,0xec,0x31e,0x31f,0x60010,0x4,0x11,0x40,0x1,0x1,0x30003, + 0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69, + 0x0,0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570, + 0xa0004,0x455f4c47,0x735f5458,0x65646168,0x6d695f72,0x5f656761,0x64616f6c,0x726f665f,0x7474616d,0x6465,0xa0004,0x475f4c47, + 0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45, + 0x64756c63,0x69645f65,0x74636572,0x657669,0x40005,0x4,0x6e69616d,0x0,0x50005,0xd1,0x43526263,0x745f5341, + 0x0,0x60006,0xd1,0x0,0x73616372,0x666e6f43,0x6769,0x40005,0xd3,0x43526263,0x5341,0x60005, + 0xdb,0x63725f72,0x695f7361,0x7475706e,0x0,0x70005,0xe3,0x755f7772,0x61637370,0x5f64656c,0x7074756f,0x7475, + 0x70005,0xec,0x6e695f72,0x5f747570,0x6f707865,0x65727573,0x0,0x80005,0x31e,0x4c5f6c67,0x6c61636f,0x6f766e49, + 0x69746163,0x44496e6f,0x0,0x60005,0x31f,0x575f6c67,0x476b726f,0x70756f72,0x4449,0x30047,0xd1,0x2, + 0x50048,0xd1,0x0,0x23,0x0,0x40047,0xd3,0x21,0x4,0x40047,0xd3,0x22, + 0x0,0x40047,0xdb,0x21,0x1,0x40047,0xdb,0x22,0x0,0x30047,0xe3,0x19, + 0x40047,0xe3,0x21,0x2,0x40047,0xe3,0x22,0x0,0x40047,0xec,0x21,0x0, + 0x40047,0xec,0x22,0x0,0x40047,0x31e,0xb,0x1b,0x40047,0x31f,0xb,0x1a, + 0x40047,0x33c,0xb,0x19,0x20013,0x2,0x30021,0x3,0x2,0x40015,0x6,0x20, + 0x0,0x30016,0x8,0x20,0x40017,0x37,0x6,0x2,0x40017,0x3c,0x6,0x4, + 0x40015,0x40,0x20,0x1,0x40017,0x41,0x40,0x2,0x40017,0x43,0x8,0x4, + 0x40017,0x48,0x8,0x3,0x40017,0x6e,0x6,0x3,0x4002b,0x40,0x88,0x0, + 0x4002b,0x8,0x9c,0x3f800000,0x4002b,0x8,0xa2,0x0,0x4002b,0x6,0xac,0x7ef19fff, + 0x4002b,0x8,0xb8,0x40000000,0x4002b,0x6,0xbd,0x1,0x3001e,0xd1,0x3c,0x40020, + 0xd2,0x2,0xd1,0x4003b,0xd2,0xd3,0x2,0x40020,0xd4,0x2,0x3c,0x90019, + 0xd9,0x8,0x1,0x0,0x0,0x0,0x1,0x0,0x40020,0xda,0x0,0xd9, + 0x4003b,0xda,0xdb,0x0,0x90019,0xe1,0x8,0x1,0x0,0x0,0x0,0x2, + 0x0,0x40020,0xe2,0x0,0xe1,0x4003b,0xe2,0xe3,0x0,0x4003b,0xda,0xec, + 0x0,0x5002c,0x41,0xee,0x88,0x88,0x20014,0xf3,0x4002b,0x40,0x118,0xffffffff, + 0x5002c,0x41,0x119,0x88,0x118,0x5002c,0x41,0x120,0x118,0x88,0x4002b,0x40, + 0x12c,0x1,0x5002c,0x41,0x12d,0x12c,0x88,0x5002c,0x41,0x134,0x88,0x12c, + 0x4002b,0x8,0x19a,0x3f000000,0x4002b,0x8,0x1c2,0x3e800000,0x4002b,0x8,0x1f2,0xbf000000, + 0x4002b,0x8,0x23b,0xc0800000,0x4002b,0x8,0x23f,0x40800000,0x4002b,0x8,0x28a,0xbe400000, + 0x4002b,0x6,0x2fd,0x4,0x4002b,0x6,0x307,0x8,0x40020,0x31d,0x1,0x6e, + 0x4003b,0x31d,0x31e,0x1,0x4003b,0x31d,0x31f,0x1,0x4002b,0x40,0x339,0x3, + 0x4002b,0x6,0x33b,0x40,0x6002c,0x6e,0x33c,0x33b,0xbd,0xbd,0x50036,0x2, + 0x4,0x0,0x3,0x200f8,0x5,0x4003d,0x6e,0x322,0x31e,0x4003d,0x6e,0x324, + 0x31f,0x50051,0x6,0x345,0x322,0x0,0x600cb,0x6,0x37c,0x345,0x12c,0x339, + 0x600cb,0x6,0x384,0x345,0x339,0x339,0x700c9,0x6,0x38b,0x384,0x345,0x88, + 0x12c,0x50050,0x37,0x374,0x37c,0x38b,0x50051,0x6,0x348,0x324,0x0,0x500c4, + 0x6,0x349,0x348,0x2fd,0x50051,0x6,0x34b,0x324,0x1,0x500c4,0x6,0x34c, + 0x34b,0x2fd,0x50050,0x37,0x34d,0x349,0x34c,0x50080,0x37,0x34e,0x374,0x34d, + 0x50041,0xd4,0x3a7,0xd3,0x88,0x4003d,0x3c,0x3a8,0x3a7,0x4007c,0x41,0x41f, + 0x34e,0x50080,0x41,0x421,0x41f,0x119,0x4003d,0xd9,0x578,0xdb,0x7005f,0x43, + 0x57a,0x578,0x421,0x2,0x88,0x4003d,0xd9,0x57e,0xec,0x7005f,0x43,0x57f, + 0x57e,0xee,0x2,0x88,0x50051,0x8,0x580,0x57f,0x0,0x500b4,0xf3,0x582, + 0x580,0xa2,0x600a9,0x8,0x1134,0x582,0x9c,0x580,0x8004f,0x48,0x56d,0x57a, + 0x57a,0x0,0x1,0x2,0x5008e,0x48,0x56e,0x56d,0x1134,0x50051,0x8,0x570, + 0x56e,0x0,0x50051,0x8,0x572,0x56e,0x1,0x50051,0x8,0x574,0x56e,0x2, + 0x50080,0x41,0x425,0x41f,0x120,0x4003d,0xd9,0x599,0xdb,0x7005f,0x43,0x59b, + 0x599,0x425,0x2,0x88,0x4003d,0xd9,0x59f,0xec,0x7005f,0x43,0x5a0,0x59f, + 0xee,0x2,0x88,0x50051,0x8,0x5a1,0x5a0,0x0,0x500b4,0xf3,0x5a3,0x5a1, + 0xa2,0x600a9,0x8,0x1135,0x5a3,0x9c,0x5a1,0x8004f,0x48,0x58e,0x59b,0x59b, + 0x0,0x1,0x2,0x5008e,0x48,0x58f,0x58e,0x1135,0x50051,0x8,0x591,0x58f, + 0x0,0x50051,0x8,0x593,0x58f,0x1,0x50051,0x8,0x595,0x58f,0x2,0x4003d, + 0xd9,0x5ba,0xdb,0x7005f,0x43,0x5bc,0x5ba,0x41f,0x2,0x88,0x4003d,0xd9, + 0x5c0,0xec,0x7005f,0x43,0x5c1,0x5c0,0xee,0x2,0x88,0x50051,0x8,0x5c2, + 0x5c1,0x0,0x500b4,0xf3,0x5c4,0x5c2,0xa2,0x600a9,0x8,0x1136,0x5c4,0x9c, + 0x5c2,0x8004f,0x48,0x5af,0x5bc,0x5bc,0x0,0x1,0x2,0x5008e,0x48,0x5b0, + 0x5af,0x1136,0x50051,0x8,0x5b2,0x5b0,0x0,0x50051,0x8,0x5b4,0x5b0,0x1, + 0x50051,0x8,0x5b6,0x5b0,0x2,0x50080,0x41,0x42c,0x41f,0x12d,0x4003d,0xd9, + 0x5db,0xdb,0x7005f,0x43,0x5dd,0x5db,0x42c,0x2,0x88,0x4003d,0xd9,0x5e1, + 0xec,0x7005f,0x43,0x5e2,0x5e1,0xee,0x2,0x88,0x50051,0x8,0x5e3,0x5e2, + 0x0,0x500b4,0xf3,0x5e5,0x5e3,0xa2,0x600a9,0x8,0x1137,0x5e5,0x9c,0x5e3, + 0x8004f,0x48,0x5d0,0x5dd,0x5dd,0x0,0x1,0x2,0x5008e,0x48,0x5d1,0x5d0, + 0x1137,0x50051,0x8,0x5d3,0x5d1,0x0,0x50051,0x8,0x5d5,0x5d1,0x1,0x50051, + 0x8,0x5d7,0x5d1,0x2,0x50080,0x41,0x430,0x41f,0x134,0x4003d,0xd9,0x5fc, + 0xdb,0x7005f,0x43,0x5fe,0x5fc,0x430,0x2,0x88,0x4003d,0xd9,0x602,0xec, + 0x7005f,0x43,0x603,0x602,0xee,0x2,0x88,0x50051,0x8,0x604,0x603,0x0, + 0x500b4,0xf3,0x606,0x604,0xa2,0x600a9,0x8,0x1138,0x606,0x9c,0x604,0x8004f, + 0x48,0x5f1,0x5fe,0x5fe,0x0,0x1,0x2,0x5008e,0x48,0x5f2,0x5f1,0x1138, + 0x50051,0x8,0x5f4,0x5f2,0x0,0x50051,0x8,0x5f6,0x5f2,0x1,0x50051,0x8, + 0x5f8,0x5f2,0x2,0x50085,0x8,0x475,0x574,0x19a,0x50085,0x8,0x477,0x570, + 0x19a,0x50081,0x8,0x479,0x477,0x572,0x50081,0x8,0x47a,0x475,0x479,0x50085, + 0x8,0x47c,0x595,0x19a,0x50085,0x8,0x47e,0x591,0x19a,0x50081,0x8,0x480, + 0x47e,0x593,0x50081,0x8,0x481,0x47c,0x480,0x50085,0x8,0x483,0x5b6,0x19a, + 0x50085,0x8,0x485,0x5b2,0x19a,0x50081,0x8,0x487,0x485,0x5b4,0x50081,0x8, + 0x488,0x483,0x487,0x50085,0x8,0x48a,0x5d7,0x19a,0x50085,0x8,0x48c,0x5d3, + 0x19a,0x50081,0x8,0x48e,0x48c,0x5d5,0x50081,0x8,0x48f,0x48a,0x48e,0x50085, + 0x8,0x491,0x5f8,0x19a,0x50085,0x8,0x493,0x5f4,0x19a,0x50081,0x8,0x495, + 0x493,0x5f6,0x50081,0x8,0x496,0x491,0x495,0x50081,0x8,0x1104,0x47a,0x481, + 0x50081,0x8,0x1105,0x1104,0x48f,0x50081,0x8,0x1106,0x1105,0x496,0x50085,0x8, + 0x4a1,0x1c2,0x1106,0x50083,0x8,0x4a3,0x4a1,0x488,0x6000c,0x8,0x4a5,0x1, + 0x4,0x4a3,0x7000c,0x8,0x614,0x1,0x28,0x481,0x488,0x7000c,0x8,0x615, + 0x1,0x28,0x47a,0x614,0x7000c,0x8,0x61b,0x1,0x28,0x48f,0x496,0x7000c, + 0x8,0x61c,0x1,0x28,0x615,0x61b,0x7000c,0x8,0x622,0x1,0x25,0x481, + 0x488,0x7000c,0x8,0x623,0x1,0x25,0x47a,0x622,0x7000c,0x8,0x629,0x1, + 0x25,0x48f,0x496,0x7000c,0x8,0x62a,0x1,0x25,0x623,0x629,0x50083,0x8, + 0x4b4,0x61c,0x62a,0x4007c,0x6,0x63e,0x4b4,0x50082,0x6,0x632,0xac,0x63e, + 0x4007c,0x8,0x642,0x632,0x4007f,0x8,0x636,0x642,0x50085,0x8,0x638,0x636, + 0x4b4,0x50081,0x8,0x639,0x638,0xb8,0x50085,0x8,0x63a,0x642,0x639,0x50085, + 0x8,0x4b6,0x4a5,0x63a,0x8000c,0x8,0x646,0x1,0x2b,0x4b6,0xa2,0x9c, + 0x50085,0x8,0x4b9,0x1f2,0x646,0x50081,0x8,0x4ba,0x4b9,0x9c,0x7000c,0x8, + 0x64c,0x1,0x25,0x591,0x5d3,0x7000c,0x8,0x64d,0x1,0x25,0x570,0x64c, + 0x7000c,0x8,0x652,0x1,0x25,0x64d,0x5f4,0x7000c,0x8,0x658,0x1,0x25, + 0x593,0x5d5,0x7000c,0x8,0x659,0x1,0x25,0x572,0x658,0x7000c,0x8,0x65e, + 0x1,0x25,0x659,0x5f6,0x7000c,0x8,0x664,0x1,0x25,0x595,0x5d7,0x7000c, + 0x8,0x665,0x1,0x25,0x574,0x664,0x7000c,0x8,0x66a,0x1,0x25,0x665, + 0x5f8,0x7000c,0x8,0x670,0x1,0x28,0x591,0x5d3,0x7000c,0x8,0x671,0x1, + 0x28,0x570,0x670,0x7000c,0x8,0x4d2,0x1,0x28,0x671,0x5f4,0x7000c,0x8, + 0x677,0x1,0x28,0x593,0x5d5,0x7000c,0x8,0x678,0x1,0x28,0x572,0x677, + 0x7000c,0x8,0x4d8,0x1,0x28,0x678,0x5f6,0x7000c,0x8,0x67e,0x1,0x28, + 0x595,0x5d7,0x7000c,0x8,0x67f,0x1,0x28,0x574,0x67e,0x7000c,0x8,0x4de, + 0x1,0x28,0x67f,0x5f8,0x50088,0x8,0x683,0x1c2,0x4d2,0x50085,0x8,0x4e3, + 0x652,0x683,0x50088,0x8,0x687,0x1c2,0x4d8,0x50085,0x8,0x4e8,0x65e,0x687, + 0x50088,0x8,0x68b,0x1c2,0x4de,0x50085,0x8,0x4ed,0x66a,0x68b,0x50083,0x8, + 0x4f1,0x9c,0x4d2,0x50085,0x8,0x4f3,0x23f,0x652,0x50081,0x8,0x4f6,0x4f3, + 0x23b,0x50088,0x8,0x68f,0x9c,0x4f6,0x50085,0x8,0x4f8,0x4f1,0x68f,0x50083, + 0x8,0x4fc,0x9c,0x4d8,0x50085,0x8,0x4fe,0x23f,0x65e,0x50081,0x8,0x501, + 0x4fe,0x23b,0x50088,0x8,0x693,0x9c,0x501,0x50085,0x8,0x503,0x4fc,0x693, + 0x50083,0x8,0x507,0x9c,0x4de,0x50085,0x8,0x509,0x23f,0x66a,0x50081,0x8, + 0x50c,0x509,0x23b,0x50088,0x8,0x697,0x9c,0x50c,0x50085,0x8,0x50e,0x507, + 0x697,0x4007f,0x8,0x510,0x4e3,0x7000c,0x8,0x512,0x1,0x28,0x510,0x4f8, + 0x4007f,0x8,0x514,0x4e8,0x7000c,0x8,0x516,0x1,0x28,0x514,0x503,0x4007f, + 0x8,0x518,0x4ed,0x7000c,0x8,0x51a,0x1,0x28,0x518,0x50e,0x7000c,0x8, + 0x69d,0x1,0x28,0x516,0x51a,0x7000c,0x8,0x69e,0x1,0x28,0x512,0x69d, + 0x7000c,0x8,0x6a3,0x1,0x25,0x69e,0xa2,0x7000c,0x8,0x520,0x1,0x28, + 0x28a,0x6a3,0x50051,0x6,0x522,0x3a8,0x0,0x4007c,0x8,0x6a7,0x522,0x50085, + 0x8,0x524,0x520,0x6a7,0x50085,0x8,0x527,0x524,0x4ba,0x50085,0x8,0x529, + 0x23f,0x527,0x50081,0x8,0x52a,0x529,0x9c,0x4007c,0x6,0x6bb,0x52a,0x50082, + 0x6,0x6af,0xac,0x6bb,0x4007c,0x8,0x6bf,0x6af,0x4007f,0x8,0x6b3,0x6bf, + 0x50085,0x8,0x6b5,0x6b3,0x52a,0x50081,0x8,0x6b6,0x6b5,0xb8,0x50085,0x8, + 0x6b7,0x6bf,0x6b6,0x50081,0x8,0x1107,0x570,0x591,0x50081,0x8,0x1108,0x1107, + 0x5f4,0x50081,0x8,0x1109,0x1108,0x5d3,0x50085,0x8,0x53a,0x527,0x1109,0x50081, + 0x8,0x53c,0x53a,0x5b2,0x50085,0x8,0x53e,0x53c,0x6b7,0x50081,0x8,0x110a, + 0x572,0x593,0x50081,0x8,0x110b,0x110a,0x5f6,0x50081,0x8,0x110c,0x110b,0x5d5, + 0x50085,0x8,0x54d,0x527,0x110c,0x50081,0x8,0x54f,0x54d,0x5b4,0x50085,0x8, + 0x551,0x54f,0x6b7,0x50081,0x8,0x110d,0x574,0x595,0x50081,0x8,0x110e,0x110d, + 0x5f8,0x50081,0x8,0x110f,0x110e,0x5d7,0x50085,0x8,0x560,0x527,0x110f,0x50081, + 0x8,0x562,0x560,0x5b6,0x50085,0x8,0x564,0x562,0x6b7,0x60050,0x48,0x1242, + 0x53e,0x551,0x564,0x4003d,0xd9,0x6c3,0xec,0x7005f,0x43,0x6c4,0x6c3,0xee, + 0x2,0x88,0x50051,0x8,0x6c5,0x6c4,0x0,0x500b4,0xf3,0x6c7,0x6c5,0xa2, + 0x600a9,0x8,0x1139,0x6c7,0x9c,0x6c5,0x60050,0x48,0x3a0,0x1139,0x1139,0x1139, + 0x50088,0x48,0x3a1,0x1242,0x3a0,0x4003d,0xe1,0x6d3,0xe3,0x50051,0x8,0x6d6, + 0x3a1,0x0,0x50051,0x8,0x6d7,0x3a1,0x1,0x50051,0x8,0x6d8,0x3a1,0x2, + 0x70050,0x43,0x6d9,0x6d6,0x6d7,0x6d8,0x9c,0x40063,0x6d3,0x41f,0x6d9,0x50051, + 0x6,0x352,0x34e,0x0,0x50080,0x6,0x353,0x352,0x307,0x60052,0x37,0x118b, + 0x353,0x34e,0x0,0x4007c,0x41,0x76d,0x118b,0x50080,0x41,0x76f,0x76d,0x119, + 0x4003d,0xd9,0x8c6,0xdb,0x7005f,0x43,0x8c8,0x8c6,0x76f,0x2,0x88,0x4003d, + 0xd9,0x8cc,0xec,0x7005f,0x43,0x8cd,0x8cc,0xee,0x2,0x88,0x50051,0x8, + 0x8ce,0x8cd,0x0,0x500b4,0xf3,0x8d0,0x8ce,0xa2,0x600a9,0x8,0x113a,0x8d0, + 0x9c,0x8ce,0x8004f,0x48,0x8bb,0x8c8,0x8c8,0x0,0x1,0x2,0x5008e,0x48, + 0x8bc,0x8bb,0x113a,0x50051,0x8,0x8be,0x8bc,0x0,0x50051,0x8,0x8c0,0x8bc, + 0x1,0x50051,0x8,0x8c2,0x8bc,0x2,0x50080,0x41,0x773,0x76d,0x120,0x4003d, + 0xd9,0x8e7,0xdb,0x7005f,0x43,0x8e9,0x8e7,0x773,0x2,0x88,0x4003d,0xd9, + 0x8ed,0xec,0x7005f,0x43,0x8ee,0x8ed,0xee,0x2,0x88,0x50051,0x8,0x8ef, + 0x8ee,0x0,0x500b4,0xf3,0x8f1,0x8ef,0xa2,0x600a9,0x8,0x113b,0x8f1,0x9c, + 0x8ef,0x8004f,0x48,0x8dc,0x8e9,0x8e9,0x0,0x1,0x2,0x5008e,0x48,0x8dd, + 0x8dc,0x113b,0x50051,0x8,0x8df,0x8dd,0x0,0x50051,0x8,0x8e1,0x8dd,0x1, + 0x50051,0x8,0x8e3,0x8dd,0x2,0x4003d,0xd9,0x908,0xdb,0x7005f,0x43,0x90a, + 0x908,0x76d,0x2,0x88,0x4003d,0xd9,0x90e,0xec,0x7005f,0x43,0x90f,0x90e, + 0xee,0x2,0x88,0x50051,0x8,0x910,0x90f,0x0,0x500b4,0xf3,0x912,0x910, + 0xa2,0x600a9,0x8,0x113c,0x912,0x9c,0x910,0x8004f,0x48,0x8fd,0x90a,0x90a, + 0x0,0x1,0x2,0x5008e,0x48,0x8fe,0x8fd,0x113c,0x50051,0x8,0x900,0x8fe, + 0x0,0x50051,0x8,0x902,0x8fe,0x1,0x50051,0x8,0x904,0x8fe,0x2,0x50080, + 0x41,0x77a,0x76d,0x12d,0x4003d,0xd9,0x929,0xdb,0x7005f,0x43,0x92b,0x929, + 0x77a,0x2,0x88,0x4003d,0xd9,0x92f,0xec,0x7005f,0x43,0x930,0x92f,0xee, + 0x2,0x88,0x50051,0x8,0x931,0x930,0x0,0x500b4,0xf3,0x933,0x931,0xa2, + 0x600a9,0x8,0x113d,0x933,0x9c,0x931,0x8004f,0x48,0x91e,0x92b,0x92b,0x0, + 0x1,0x2,0x5008e,0x48,0x91f,0x91e,0x113d,0x50051,0x8,0x921,0x91f,0x0, + 0x50051,0x8,0x923,0x91f,0x1,0x50051,0x8,0x925,0x91f,0x2,0x50080,0x41, + 0x77e,0x76d,0x134,0x4003d,0xd9,0x94a,0xdb,0x7005f,0x43,0x94c,0x94a,0x77e, + 0x2,0x88,0x4003d,0xd9,0x950,0xec,0x7005f,0x43,0x951,0x950,0xee,0x2, + 0x88,0x50051,0x8,0x952,0x951,0x0,0x500b4,0xf3,0x954,0x952,0xa2,0x600a9, + 0x8,0x113e,0x954,0x9c,0x952,0x8004f,0x48,0x93f,0x94c,0x94c,0x0,0x1, + 0x2,0x5008e,0x48,0x940,0x93f,0x113e,0x50051,0x8,0x942,0x940,0x0,0x50051, + 0x8,0x944,0x940,0x1,0x50051,0x8,0x946,0x940,0x2,0x50085,0x8,0x7c3, + 0x8c2,0x19a,0x50085,0x8,0x7c5,0x8be,0x19a,0x50081,0x8,0x7c7,0x7c5,0x8c0, + 0x50081,0x8,0x7c8,0x7c3,0x7c7,0x50085,0x8,0x7ca,0x8e3,0x19a,0x50085,0x8, + 0x7cc,0x8df,0x19a,0x50081,0x8,0x7ce,0x7cc,0x8e1,0x50081,0x8,0x7cf,0x7ca, + 0x7ce,0x50085,0x8,0x7d1,0x904,0x19a,0x50085,0x8,0x7d3,0x900,0x19a,0x50081, + 0x8,0x7d5,0x7d3,0x902,0x50081,0x8,0x7d6,0x7d1,0x7d5,0x50085,0x8,0x7d8, + 0x925,0x19a,0x50085,0x8,0x7da,0x921,0x19a,0x50081,0x8,0x7dc,0x7da,0x923, + 0x50081,0x8,0x7dd,0x7d8,0x7dc,0x50085,0x8,0x7df,0x946,0x19a,0x50085,0x8, + 0x7e1,0x942,0x19a,0x50081,0x8,0x7e3,0x7e1,0x944,0x50081,0x8,0x7e4,0x7df, + 0x7e3,0x50081,0x8,0x1110,0x7c8,0x7cf,0x50081,0x8,0x1111,0x1110,0x7dd,0x50081, + 0x8,0x1112,0x1111,0x7e4,0x50085,0x8,0x7ef,0x1c2,0x1112,0x50083,0x8,0x7f1, + 0x7ef,0x7d6,0x6000c,0x8,0x7f3,0x1,0x4,0x7f1,0x7000c,0x8,0x962,0x1, + 0x28,0x7cf,0x7d6,0x7000c,0x8,0x963,0x1,0x28,0x7c8,0x962,0x7000c,0x8, + 0x969,0x1,0x28,0x7dd,0x7e4,0x7000c,0x8,0x96a,0x1,0x28,0x963,0x969, + 0x7000c,0x8,0x970,0x1,0x25,0x7cf,0x7d6,0x7000c,0x8,0x971,0x1,0x25, + 0x7c8,0x970,0x7000c,0x8,0x977,0x1,0x25,0x7dd,0x7e4,0x7000c,0x8,0x978, + 0x1,0x25,0x971,0x977,0x50083,0x8,0x802,0x96a,0x978,0x4007c,0x6,0x98c, + 0x802,0x50082,0x6,0x980,0xac,0x98c,0x4007c,0x8,0x990,0x980,0x4007f,0x8, + 0x984,0x990,0x50085,0x8,0x986,0x984,0x802,0x50081,0x8,0x987,0x986,0xb8, + 0x50085,0x8,0x988,0x990,0x987,0x50085,0x8,0x804,0x7f3,0x988,0x8000c,0x8, + 0x994,0x1,0x2b,0x804,0xa2,0x9c,0x50085,0x8,0x807,0x1f2,0x994,0x50081, + 0x8,0x808,0x807,0x9c,0x7000c,0x8,0x99a,0x1,0x25,0x8df,0x921,0x7000c, + 0x8,0x99b,0x1,0x25,0x8be,0x99a,0x7000c,0x8,0x9a0,0x1,0x25,0x99b, + 0x942,0x7000c,0x8,0x9a6,0x1,0x25,0x8e1,0x923,0x7000c,0x8,0x9a7,0x1, + 0x25,0x8c0,0x9a6,0x7000c,0x8,0x9ac,0x1,0x25,0x9a7,0x944,0x7000c,0x8, + 0x9b2,0x1,0x25,0x8e3,0x925,0x7000c,0x8,0x9b3,0x1,0x25,0x8c2,0x9b2, + 0x7000c,0x8,0x9b8,0x1,0x25,0x9b3,0x946,0x7000c,0x8,0x9be,0x1,0x28, + 0x8df,0x921,0x7000c,0x8,0x9bf,0x1,0x28,0x8be,0x9be,0x7000c,0x8,0x820, + 0x1,0x28,0x9bf,0x942,0x7000c,0x8,0x9c5,0x1,0x28,0x8e1,0x923,0x7000c, + 0x8,0x9c6,0x1,0x28,0x8c0,0x9c5,0x7000c,0x8,0x826,0x1,0x28,0x9c6, + 0x944,0x7000c,0x8,0x9cc,0x1,0x28,0x8e3,0x925,0x7000c,0x8,0x9cd,0x1, + 0x28,0x8c2,0x9cc,0x7000c,0x8,0x82c,0x1,0x28,0x9cd,0x946,0x50088,0x8, + 0x9d1,0x1c2,0x820,0x50085,0x8,0x831,0x9a0,0x9d1,0x50088,0x8,0x9d5,0x1c2, + 0x826,0x50085,0x8,0x836,0x9ac,0x9d5,0x50088,0x8,0x9d9,0x1c2,0x82c,0x50085, + 0x8,0x83b,0x9b8,0x9d9,0x50083,0x8,0x83f,0x9c,0x820,0x50085,0x8,0x841, + 0x23f,0x9a0,0x50081,0x8,0x844,0x841,0x23b,0x50088,0x8,0x9dd,0x9c,0x844, + 0x50085,0x8,0x846,0x83f,0x9dd,0x50083,0x8,0x84a,0x9c,0x826,0x50085,0x8, + 0x84c,0x23f,0x9ac,0x50081,0x8,0x84f,0x84c,0x23b,0x50088,0x8,0x9e1,0x9c, + 0x84f,0x50085,0x8,0x851,0x84a,0x9e1,0x50083,0x8,0x855,0x9c,0x82c,0x50085, + 0x8,0x857,0x23f,0x9b8,0x50081,0x8,0x85a,0x857,0x23b,0x50088,0x8,0x9e5, + 0x9c,0x85a,0x50085,0x8,0x85c,0x855,0x9e5,0x4007f,0x8,0x85e,0x831,0x7000c, + 0x8,0x860,0x1,0x28,0x85e,0x846,0x4007f,0x8,0x862,0x836,0x7000c,0x8, + 0x864,0x1,0x28,0x862,0x851,0x4007f,0x8,0x866,0x83b,0x7000c,0x8,0x868, + 0x1,0x28,0x866,0x85c,0x7000c,0x8,0x9eb,0x1,0x28,0x864,0x868,0x7000c, + 0x8,0x9ec,0x1,0x28,0x860,0x9eb,0x7000c,0x8,0x9f1,0x1,0x25,0x9ec, + 0xa2,0x7000c,0x8,0x86e,0x1,0x28,0x28a,0x9f1,0x50085,0x8,0x872,0x86e, + 0x6a7,0x50085,0x8,0x875,0x872,0x808,0x50085,0x8,0x877,0x23f,0x875,0x50081, + 0x8,0x878,0x877,0x9c,0x4007c,0x6,0xa09,0x878,0x50082,0x6,0x9fd,0xac, + 0xa09,0x4007c,0x8,0xa0d,0x9fd,0x4007f,0x8,0xa01,0xa0d,0x50085,0x8,0xa03, + 0xa01,0x878,0x50081,0x8,0xa04,0xa03,0xb8,0x50085,0x8,0xa05,0xa0d,0xa04, + 0x50081,0x8,0x1113,0x8be,0x8df,0x50081,0x8,0x1114,0x1113,0x942,0x50081,0x8, + 0x1115,0x1114,0x921,0x50085,0x8,0x888,0x875,0x1115,0x50081,0x8,0x88a,0x888, + 0x900,0x50085,0x8,0x88c,0x88a,0xa05,0x50081,0x8,0x1116,0x8c0,0x8e1,0x50081, + 0x8,0x1117,0x1116,0x944,0x50081,0x8,0x1118,0x1117,0x923,0x50085,0x8,0x89b, + 0x875,0x1118,0x50081,0x8,0x89d,0x89b,0x902,0x50085,0x8,0x89f,0x89d,0xa05, + 0x50081,0x8,0x1119,0x8c2,0x8e3,0x50081,0x8,0x111a,0x1119,0x946,0x50081,0x8, + 0x111b,0x111a,0x925,0x50085,0x8,0x8ae,0x875,0x111b,0x50081,0x8,0x8b0,0x8ae, + 0x904,0x50085,0x8,0x8b2,0x8b0,0xa05,0x60050,0x48,0x1243,0x88c,0x89f,0x8b2, + 0x4003d,0xd9,0xa11,0xec,0x7005f,0x43,0xa12,0xa11,0xee,0x2,0x88,0x50051, + 0x8,0xa13,0xa12,0x0,0x500b4,0xf3,0xa15,0xa13,0xa2,0x600a9,0x8,0x113f, + 0xa15,0x9c,0xa13,0x60050,0x48,0x6ee,0x113f,0x113f,0x113f,0x50088,0x48,0x6ef, + 0x1243,0x6ee,0x4003d,0xe1,0xa21,0xe3,0x50051,0x8,0xa24,0x6ef,0x0,0x50051, + 0x8,0xa25,0x6ef,0x1,0x50051,0x8,0xa26,0x6ef,0x2,0x70050,0x43,0xa27, + 0xa24,0xa25,0xa26,0x9c,0x40063,0xa21,0x76d,0xa27,0x50051,0x6,0x358,0x34e, + 0x1,0x50080,0x6,0x359,0x358,0x307,0x50050,0x37,0x1244,0x353,0x359,0x4007c, + 0x41,0xabb,0x1244,0x50080,0x41,0xabd,0xabb,0x119,0x4003d,0xd9,0xc14,0xdb, + 0x7005f,0x43,0xc16,0xc14,0xabd,0x2,0x88,0x4003d,0xd9,0xc1a,0xec,0x7005f, + 0x43,0xc1b,0xc1a,0xee,0x2,0x88,0x50051,0x8,0xc1c,0xc1b,0x0,0x500b4, + 0xf3,0xc1e,0xc1c,0xa2,0x600a9,0x8,0x1140,0xc1e,0x9c,0xc1c,0x8004f,0x48, + 0xc09,0xc16,0xc16,0x0,0x1,0x2,0x5008e,0x48,0xc0a,0xc09,0x1140,0x50051, + 0x8,0xc0c,0xc0a,0x0,0x50051,0x8,0xc0e,0xc0a,0x1,0x50051,0x8,0xc10, + 0xc0a,0x2,0x50080,0x41,0xac1,0xabb,0x120,0x4003d,0xd9,0xc35,0xdb,0x7005f, + 0x43,0xc37,0xc35,0xac1,0x2,0x88,0x4003d,0xd9,0xc3b,0xec,0x7005f,0x43, + 0xc3c,0xc3b,0xee,0x2,0x88,0x50051,0x8,0xc3d,0xc3c,0x0,0x500b4,0xf3, + 0xc3f,0xc3d,0xa2,0x600a9,0x8,0x1141,0xc3f,0x9c,0xc3d,0x8004f,0x48,0xc2a, + 0xc37,0xc37,0x0,0x1,0x2,0x5008e,0x48,0xc2b,0xc2a,0x1141,0x50051,0x8, + 0xc2d,0xc2b,0x0,0x50051,0x8,0xc2f,0xc2b,0x1,0x50051,0x8,0xc31,0xc2b, + 0x2,0x4003d,0xd9,0xc56,0xdb,0x7005f,0x43,0xc58,0xc56,0xabb,0x2,0x88, + 0x4003d,0xd9,0xc5c,0xec,0x7005f,0x43,0xc5d,0xc5c,0xee,0x2,0x88,0x50051, + 0x8,0xc5e,0xc5d,0x0,0x500b4,0xf3,0xc60,0xc5e,0xa2,0x600a9,0x8,0x1142, + 0xc60,0x9c,0xc5e,0x8004f,0x48,0xc4b,0xc58,0xc58,0x0,0x1,0x2,0x5008e, + 0x48,0xc4c,0xc4b,0x1142,0x50051,0x8,0xc4e,0xc4c,0x0,0x50051,0x8,0xc50, + 0xc4c,0x1,0x50051,0x8,0xc52,0xc4c,0x2,0x50080,0x41,0xac8,0xabb,0x12d, + 0x4003d,0xd9,0xc77,0xdb,0x7005f,0x43,0xc79,0xc77,0xac8,0x2,0x88,0x4003d, + 0xd9,0xc7d,0xec,0x7005f,0x43,0xc7e,0xc7d,0xee,0x2,0x88,0x50051,0x8, + 0xc7f,0xc7e,0x0,0x500b4,0xf3,0xc81,0xc7f,0xa2,0x600a9,0x8,0x1143,0xc81, + 0x9c,0xc7f,0x8004f,0x48,0xc6c,0xc79,0xc79,0x0,0x1,0x2,0x5008e,0x48, + 0xc6d,0xc6c,0x1143,0x50051,0x8,0xc6f,0xc6d,0x0,0x50051,0x8,0xc71,0xc6d, + 0x1,0x50051,0x8,0xc73,0xc6d,0x2,0x50080,0x41,0xacc,0xabb,0x134,0x4003d, + 0xd9,0xc98,0xdb,0x7005f,0x43,0xc9a,0xc98,0xacc,0x2,0x88,0x4003d,0xd9, + 0xc9e,0xec,0x7005f,0x43,0xc9f,0xc9e,0xee,0x2,0x88,0x50051,0x8,0xca0, + 0xc9f,0x0,0x500b4,0xf3,0xca2,0xca0,0xa2,0x600a9,0x8,0x1144,0xca2,0x9c, + 0xca0,0x8004f,0x48,0xc8d,0xc9a,0xc9a,0x0,0x1,0x2,0x5008e,0x48,0xc8e, + 0xc8d,0x1144,0x50051,0x8,0xc90,0xc8e,0x0,0x50051,0x8,0xc92,0xc8e,0x1, + 0x50051,0x8,0xc94,0xc8e,0x2,0x50085,0x8,0xb11,0xc10,0x19a,0x50085,0x8, + 0xb13,0xc0c,0x19a,0x50081,0x8,0xb15,0xb13,0xc0e,0x50081,0x8,0xb16,0xb11, + 0xb15,0x50085,0x8,0xb18,0xc31,0x19a,0x50085,0x8,0xb1a,0xc2d,0x19a,0x50081, + 0x8,0xb1c,0xb1a,0xc2f,0x50081,0x8,0xb1d,0xb18,0xb1c,0x50085,0x8,0xb1f, + 0xc52,0x19a,0x50085,0x8,0xb21,0xc4e,0x19a,0x50081,0x8,0xb23,0xb21,0xc50, + 0x50081,0x8,0xb24,0xb1f,0xb23,0x50085,0x8,0xb26,0xc73,0x19a,0x50085,0x8, + 0xb28,0xc6f,0x19a,0x50081,0x8,0xb2a,0xb28,0xc71,0x50081,0x8,0xb2b,0xb26, + 0xb2a,0x50085,0x8,0xb2d,0xc94,0x19a,0x50085,0x8,0xb2f,0xc90,0x19a,0x50081, + 0x8,0xb31,0xb2f,0xc92,0x50081,0x8,0xb32,0xb2d,0xb31,0x50081,0x8,0x111c, + 0xb16,0xb1d,0x50081,0x8,0x111d,0x111c,0xb2b,0x50081,0x8,0x111e,0x111d,0xb32, + 0x50085,0x8,0xb3d,0x1c2,0x111e,0x50083,0x8,0xb3f,0xb3d,0xb24,0x6000c,0x8, + 0xb41,0x1,0x4,0xb3f,0x7000c,0x8,0xcb0,0x1,0x28,0xb1d,0xb24,0x7000c, + 0x8,0xcb1,0x1,0x28,0xb16,0xcb0,0x7000c,0x8,0xcb7,0x1,0x28,0xb2b, + 0xb32,0x7000c,0x8,0xcb8,0x1,0x28,0xcb1,0xcb7,0x7000c,0x8,0xcbe,0x1, + 0x25,0xb1d,0xb24,0x7000c,0x8,0xcbf,0x1,0x25,0xb16,0xcbe,0x7000c,0x8, + 0xcc5,0x1,0x25,0xb2b,0xb32,0x7000c,0x8,0xcc6,0x1,0x25,0xcbf,0xcc5, + 0x50083,0x8,0xb50,0xcb8,0xcc6,0x4007c,0x6,0xcda,0xb50,0x50082,0x6,0xcce, + 0xac,0xcda,0x4007c,0x8,0xcde,0xcce,0x4007f,0x8,0xcd2,0xcde,0x50085,0x8, + 0xcd4,0xcd2,0xb50,0x50081,0x8,0xcd5,0xcd4,0xb8,0x50085,0x8,0xcd6,0xcde, + 0xcd5,0x50085,0x8,0xb52,0xb41,0xcd6,0x8000c,0x8,0xce2,0x1,0x2b,0xb52, + 0xa2,0x9c,0x50085,0x8,0xb55,0x1f2,0xce2,0x50081,0x8,0xb56,0xb55,0x9c, + 0x7000c,0x8,0xce8,0x1,0x25,0xc2d,0xc6f,0x7000c,0x8,0xce9,0x1,0x25, + 0xc0c,0xce8,0x7000c,0x8,0xcee,0x1,0x25,0xce9,0xc90,0x7000c,0x8,0xcf4, + 0x1,0x25,0xc2f,0xc71,0x7000c,0x8,0xcf5,0x1,0x25,0xc0e,0xcf4,0x7000c, + 0x8,0xcfa,0x1,0x25,0xcf5,0xc92,0x7000c,0x8,0xd00,0x1,0x25,0xc31, + 0xc73,0x7000c,0x8,0xd01,0x1,0x25,0xc10,0xd00,0x7000c,0x8,0xd06,0x1, + 0x25,0xd01,0xc94,0x7000c,0x8,0xd0c,0x1,0x28,0xc2d,0xc6f,0x7000c,0x8, + 0xd0d,0x1,0x28,0xc0c,0xd0c,0x7000c,0x8,0xb6e,0x1,0x28,0xd0d,0xc90, + 0x7000c,0x8,0xd13,0x1,0x28,0xc2f,0xc71,0x7000c,0x8,0xd14,0x1,0x28, + 0xc0e,0xd13,0x7000c,0x8,0xb74,0x1,0x28,0xd14,0xc92,0x7000c,0x8,0xd1a, + 0x1,0x28,0xc31,0xc73,0x7000c,0x8,0xd1b,0x1,0x28,0xc10,0xd1a,0x7000c, + 0x8,0xb7a,0x1,0x28,0xd1b,0xc94,0x50088,0x8,0xd1f,0x1c2,0xb6e,0x50085, + 0x8,0xb7f,0xcee,0xd1f,0x50088,0x8,0xd23,0x1c2,0xb74,0x50085,0x8,0xb84, + 0xcfa,0xd23,0x50088,0x8,0xd27,0x1c2,0xb7a,0x50085,0x8,0xb89,0xd06,0xd27, + 0x50083,0x8,0xb8d,0x9c,0xb6e,0x50085,0x8,0xb8f,0x23f,0xcee,0x50081,0x8, + 0xb92,0xb8f,0x23b,0x50088,0x8,0xd2b,0x9c,0xb92,0x50085,0x8,0xb94,0xb8d, + 0xd2b,0x50083,0x8,0xb98,0x9c,0xb74,0x50085,0x8,0xb9a,0x23f,0xcfa,0x50081, + 0x8,0xb9d,0xb9a,0x23b,0x50088,0x8,0xd2f,0x9c,0xb9d,0x50085,0x8,0xb9f, + 0xb98,0xd2f,0x50083,0x8,0xba3,0x9c,0xb7a,0x50085,0x8,0xba5,0x23f,0xd06, + 0x50081,0x8,0xba8,0xba5,0x23b,0x50088,0x8,0xd33,0x9c,0xba8,0x50085,0x8, + 0xbaa,0xba3,0xd33,0x4007f,0x8,0xbac,0xb7f,0x7000c,0x8,0xbae,0x1,0x28, + 0xbac,0xb94,0x4007f,0x8,0xbb0,0xb84,0x7000c,0x8,0xbb2,0x1,0x28,0xbb0, + 0xb9f,0x4007f,0x8,0xbb4,0xb89,0x7000c,0x8,0xbb6,0x1,0x28,0xbb4,0xbaa, + 0x7000c,0x8,0xd39,0x1,0x28,0xbb2,0xbb6,0x7000c,0x8,0xd3a,0x1,0x28, + 0xbae,0xd39,0x7000c,0x8,0xd3f,0x1,0x25,0xd3a,0xa2,0x7000c,0x8,0xbbc, + 0x1,0x28,0x28a,0xd3f,0x50085,0x8,0xbc0,0xbbc,0x6a7,0x50085,0x8,0xbc3, + 0xbc0,0xb56,0x50085,0x8,0xbc5,0x23f,0xbc3,0x50081,0x8,0xbc6,0xbc5,0x9c, + 0x4007c,0x6,0xd57,0xbc6,0x50082,0x6,0xd4b,0xac,0xd57,0x4007c,0x8,0xd5b, + 0xd4b,0x4007f,0x8,0xd4f,0xd5b,0x50085,0x8,0xd51,0xd4f,0xbc6,0x50081,0x8, + 0xd52,0xd51,0xb8,0x50085,0x8,0xd53,0xd5b,0xd52,0x50081,0x8,0x111f,0xc0c, + 0xc2d,0x50081,0x8,0x1120,0x111f,0xc90,0x50081,0x8,0x1121,0x1120,0xc6f,0x50085, + 0x8,0xbd6,0xbc3,0x1121,0x50081,0x8,0xbd8,0xbd6,0xc4e,0x50085,0x8,0xbda, + 0xbd8,0xd53,0x50081,0x8,0x1122,0xc0e,0xc2f,0x50081,0x8,0x1123,0x1122,0xc92, + 0x50081,0x8,0x1124,0x1123,0xc71,0x50085,0x8,0xbe9,0xbc3,0x1124,0x50081,0x8, + 0xbeb,0xbe9,0xc50,0x50085,0x8,0xbed,0xbeb,0xd53,0x50081,0x8,0x1125,0xc10, + 0xc31,0x50081,0x8,0x1126,0x1125,0xc94,0x50081,0x8,0x1127,0x1126,0xc73,0x50085, + 0x8,0xbfc,0xbc3,0x1127,0x50081,0x8,0xbfe,0xbfc,0xc52,0x50085,0x8,0xc00, + 0xbfe,0xd53,0x60050,0x48,0x1245,0xbda,0xbed,0xc00,0x4003d,0xd9,0xd5f,0xec, + 0x7005f,0x43,0xd60,0xd5f,0xee,0x2,0x88,0x50051,0x8,0xd61,0xd60,0x0, + 0x500b4,0xf3,0xd63,0xd61,0xa2,0x600a9,0x8,0x1145,0xd63,0x9c,0xd61,0x60050, + 0x48,0xa3c,0x1145,0x1145,0x1145,0x50088,0x48,0xa3d,0x1245,0xa3c,0x4003d,0xe1, + 0xd6f,0xe3,0x50051,0x8,0xd72,0xa3d,0x0,0x50051,0x8,0xd73,0xa3d,0x1, + 0x50051,0x8,0xd74,0xa3d,0x2,0x70050,0x43,0xd75,0xd72,0xd73,0xd74,0x9c, + 0x40063,0xd6f,0xabb,0xd75,0x60052,0x37,0x1205,0x352,0x1244,0x0,0x4007c,0x41, + 0xe09,0x1205,0x50080,0x41,0xe0b,0xe09,0x119,0x4003d,0xd9,0xf62,0xdb,0x7005f, + 0x43,0xf64,0xf62,0xe0b,0x2,0x88,0x4003d,0xd9,0xf68,0xec,0x7005f,0x43, + 0xf69,0xf68,0xee,0x2,0x88,0x50051,0x8,0xf6a,0xf69,0x0,0x500b4,0xf3, + 0xf6c,0xf6a,0xa2,0x600a9,0x8,0x1146,0xf6c,0x9c,0xf6a,0x8004f,0x48,0xf57, + 0xf64,0xf64,0x0,0x1,0x2,0x5008e,0x48,0xf58,0xf57,0x1146,0x50051,0x8, + 0xf5a,0xf58,0x0,0x50051,0x8,0xf5c,0xf58,0x1,0x50051,0x8,0xf5e,0xf58, + 0x2,0x50080,0x41,0xe0f,0xe09,0x120,0x4003d,0xd9,0xf83,0xdb,0x7005f,0x43, + 0xf85,0xf83,0xe0f,0x2,0x88,0x4003d,0xd9,0xf89,0xec,0x7005f,0x43,0xf8a, + 0xf89,0xee,0x2,0x88,0x50051,0x8,0xf8b,0xf8a,0x0,0x500b4,0xf3,0xf8d, + 0xf8b,0xa2,0x600a9,0x8,0x1147,0xf8d,0x9c,0xf8b,0x8004f,0x48,0xf78,0xf85, + 0xf85,0x0,0x1,0x2,0x5008e,0x48,0xf79,0xf78,0x1147,0x50051,0x8,0xf7b, + 0xf79,0x0,0x50051,0x8,0xf7d,0xf79,0x1,0x50051,0x8,0xf7f,0xf79,0x2, + 0x4003d,0xd9,0xfa4,0xdb,0x7005f,0x43,0xfa6,0xfa4,0xe09,0x2,0x88,0x4003d, + 0xd9,0xfaa,0xec,0x7005f,0x43,0xfab,0xfaa,0xee,0x2,0x88,0x50051,0x8, + 0xfac,0xfab,0x0,0x500b4,0xf3,0xfae,0xfac,0xa2,0x600a9,0x8,0x1148,0xfae, + 0x9c,0xfac,0x8004f,0x48,0xf99,0xfa6,0xfa6,0x0,0x1,0x2,0x5008e,0x48, + 0xf9a,0xf99,0x1148,0x50051,0x8,0xf9c,0xf9a,0x0,0x50051,0x8,0xf9e,0xf9a, + 0x1,0x50051,0x8,0xfa0,0xf9a,0x2,0x50080,0x41,0xe16,0xe09,0x12d,0x4003d, + 0xd9,0xfc5,0xdb,0x7005f,0x43,0xfc7,0xfc5,0xe16,0x2,0x88,0x4003d,0xd9, + 0xfcb,0xec,0x7005f,0x43,0xfcc,0xfcb,0xee,0x2,0x88,0x50051,0x8,0xfcd, + 0xfcc,0x0,0x500b4,0xf3,0xfcf,0xfcd,0xa2,0x600a9,0x8,0x1149,0xfcf,0x9c, + 0xfcd,0x8004f,0x48,0xfba,0xfc7,0xfc7,0x0,0x1,0x2,0x5008e,0x48,0xfbb, + 0xfba,0x1149,0x50051,0x8,0xfbd,0xfbb,0x0,0x50051,0x8,0xfbf,0xfbb,0x1, + 0x50051,0x8,0xfc1,0xfbb,0x2,0x50080,0x41,0xe1a,0xe09,0x134,0x4003d,0xd9, + 0xfe6,0xdb,0x7005f,0x43,0xfe8,0xfe6,0xe1a,0x2,0x88,0x4003d,0xd9,0xfec, + 0xec,0x7005f,0x43,0xfed,0xfec,0xee,0x2,0x88,0x50051,0x8,0xfee,0xfed, + 0x0,0x500b4,0xf3,0xff0,0xfee,0xa2,0x600a9,0x8,0x114a,0xff0,0x9c,0xfee, + 0x8004f,0x48,0xfdb,0xfe8,0xfe8,0x0,0x1,0x2,0x5008e,0x48,0xfdc,0xfdb, + 0x114a,0x50051,0x8,0xfde,0xfdc,0x0,0x50051,0x8,0xfe0,0xfdc,0x1,0x50051, + 0x8,0xfe2,0xfdc,0x2,0x50085,0x8,0xe5f,0xf5e,0x19a,0x50085,0x8,0xe61, + 0xf5a,0x19a,0x50081,0x8,0xe63,0xe61,0xf5c,0x50081,0x8,0xe64,0xe5f,0xe63, + 0x50085,0x8,0xe66,0xf7f,0x19a,0x50085,0x8,0xe68,0xf7b,0x19a,0x50081,0x8, + 0xe6a,0xe68,0xf7d,0x50081,0x8,0xe6b,0xe66,0xe6a,0x50085,0x8,0xe6d,0xfa0, + 0x19a,0x50085,0x8,0xe6f,0xf9c,0x19a,0x50081,0x8,0xe71,0xe6f,0xf9e,0x50081, + 0x8,0xe72,0xe6d,0xe71,0x50085,0x8,0xe74,0xfc1,0x19a,0x50085,0x8,0xe76, + 0xfbd,0x19a,0x50081,0x8,0xe78,0xe76,0xfbf,0x50081,0x8,0xe79,0xe74,0xe78, + 0x50085,0x8,0xe7b,0xfe2,0x19a,0x50085,0x8,0xe7d,0xfde,0x19a,0x50081,0x8, + 0xe7f,0xe7d,0xfe0,0x50081,0x8,0xe80,0xe7b,0xe7f,0x50081,0x8,0x1128,0xe64, + 0xe6b,0x50081,0x8,0x1129,0x1128,0xe79,0x50081,0x8,0x112a,0x1129,0xe80,0x50085, + 0x8,0xe8b,0x1c2,0x112a,0x50083,0x8,0xe8d,0xe8b,0xe72,0x6000c,0x8,0xe8f, + 0x1,0x4,0xe8d,0x7000c,0x8,0xffe,0x1,0x28,0xe6b,0xe72,0x7000c,0x8, + 0xfff,0x1,0x28,0xe64,0xffe,0x7000c,0x8,0x1005,0x1,0x28,0xe79,0xe80, + 0x7000c,0x8,0x1006,0x1,0x28,0xfff,0x1005,0x7000c,0x8,0x100c,0x1,0x25, + 0xe6b,0xe72,0x7000c,0x8,0x100d,0x1,0x25,0xe64,0x100c,0x7000c,0x8,0x1013, + 0x1,0x25,0xe79,0xe80,0x7000c,0x8,0x1014,0x1,0x25,0x100d,0x1013,0x50083, + 0x8,0xe9e,0x1006,0x1014,0x4007c,0x6,0x1028,0xe9e,0x50082,0x6,0x101c,0xac, + 0x1028,0x4007c,0x8,0x102c,0x101c,0x4007f,0x8,0x1020,0x102c,0x50085,0x8,0x1022, + 0x1020,0xe9e,0x50081,0x8,0x1023,0x1022,0xb8,0x50085,0x8,0x1024,0x102c,0x1023, + 0x50085,0x8,0xea0,0xe8f,0x1024,0x8000c,0x8,0x1030,0x1,0x2b,0xea0,0xa2, + 0x9c,0x50085,0x8,0xea3,0x1f2,0x1030,0x50081,0x8,0xea4,0xea3,0x9c,0x7000c, + 0x8,0x1036,0x1,0x25,0xf7b,0xfbd,0x7000c,0x8,0x1037,0x1,0x25,0xf5a, + 0x1036,0x7000c,0x8,0x103c,0x1,0x25,0x1037,0xfde,0x7000c,0x8,0x1042,0x1, + 0x25,0xf7d,0xfbf,0x7000c,0x8,0x1043,0x1,0x25,0xf5c,0x1042,0x7000c,0x8, + 0x1048,0x1,0x25,0x1043,0xfe0,0x7000c,0x8,0x104e,0x1,0x25,0xf7f,0xfc1, + 0x7000c,0x8,0x104f,0x1,0x25,0xf5e,0x104e,0x7000c,0x8,0x1054,0x1,0x25, + 0x104f,0xfe2,0x7000c,0x8,0x105a,0x1,0x28,0xf7b,0xfbd,0x7000c,0x8,0x105b, + 0x1,0x28,0xf5a,0x105a,0x7000c,0x8,0xebc,0x1,0x28,0x105b,0xfde,0x7000c, + 0x8,0x1061,0x1,0x28,0xf7d,0xfbf,0x7000c,0x8,0x1062,0x1,0x28,0xf5c, + 0x1061,0x7000c,0x8,0xec2,0x1,0x28,0x1062,0xfe0,0x7000c,0x8,0x1068,0x1, + 0x28,0xf7f,0xfc1,0x7000c,0x8,0x1069,0x1,0x28,0xf5e,0x1068,0x7000c,0x8, + 0xec8,0x1,0x28,0x1069,0xfe2,0x50088,0x8,0x106d,0x1c2,0xebc,0x50085,0x8, + 0xecd,0x103c,0x106d,0x50088,0x8,0x1071,0x1c2,0xec2,0x50085,0x8,0xed2,0x1048, + 0x1071,0x50088,0x8,0x1075,0x1c2,0xec8,0x50085,0x8,0xed7,0x1054,0x1075,0x50083, + 0x8,0xedb,0x9c,0xebc,0x50085,0x8,0xedd,0x23f,0x103c,0x50081,0x8,0xee0, + 0xedd,0x23b,0x50088,0x8,0x1079,0x9c,0xee0,0x50085,0x8,0xee2,0xedb,0x1079, + 0x50083,0x8,0xee6,0x9c,0xec2,0x50085,0x8,0xee8,0x23f,0x1048,0x50081,0x8, + 0xeeb,0xee8,0x23b,0x50088,0x8,0x107d,0x9c,0xeeb,0x50085,0x8,0xeed,0xee6, + 0x107d,0x50083,0x8,0xef1,0x9c,0xec8,0x50085,0x8,0xef3,0x23f,0x1054,0x50081, + 0x8,0xef6,0xef3,0x23b,0x50088,0x8,0x1081,0x9c,0xef6,0x50085,0x8,0xef8, + 0xef1,0x1081,0x4007f,0x8,0xefa,0xecd,0x7000c,0x8,0xefc,0x1,0x28,0xefa, + 0xee2,0x4007f,0x8,0xefe,0xed2,0x7000c,0x8,0xf00,0x1,0x28,0xefe,0xeed, + 0x4007f,0x8,0xf02,0xed7,0x7000c,0x8,0xf04,0x1,0x28,0xf02,0xef8,0x7000c, + 0x8,0x1087,0x1,0x28,0xf00,0xf04,0x7000c,0x8,0x1088,0x1,0x28,0xefc, + 0x1087,0x7000c,0x8,0x108d,0x1,0x25,0x1088,0xa2,0x7000c,0x8,0xf0a,0x1, + 0x28,0x28a,0x108d,0x50085,0x8,0xf0e,0xf0a,0x6a7,0x50085,0x8,0xf11,0xf0e, + 0xea4,0x50085,0x8,0xf13,0x23f,0xf11,0x50081,0x8,0xf14,0xf13,0x9c,0x4007c, + 0x6,0x10a5,0xf14,0x50082,0x6,0x1099,0xac,0x10a5,0x4007c,0x8,0x10a9,0x1099, + 0x4007f,0x8,0x109d,0x10a9,0x50085,0x8,0x109f,0x109d,0xf14,0x50081,0x8,0x10a0, + 0x109f,0xb8,0x50085,0x8,0x10a1,0x10a9,0x10a0,0x50081,0x8,0x112b,0xf5a,0xf7b, + 0x50081,0x8,0x112c,0x112b,0xfde,0x50081,0x8,0x112d,0x112c,0xfbd,0x50085,0x8, + 0xf24,0xf11,0x112d,0x50081,0x8,0xf26,0xf24,0xf9c,0x50085,0x8,0xf28,0xf26, + 0x10a1,0x50081,0x8,0x112e,0xf5c,0xf7d,0x50081,0x8,0x112f,0x112e,0xfe0,0x50081, + 0x8,0x1130,0x112f,0xfbf,0x50085,0x8,0xf37,0xf11,0x1130,0x50081,0x8,0xf39, + 0xf37,0xf9e,0x50085,0x8,0xf3b,0xf39,0x10a1,0x50081,0x8,0x1131,0xf5e,0xf7f, + 0x50081,0x8,0x1132,0x1131,0xfe2,0x50081,0x8,0x1133,0x1132,0xfc1,0x50085,0x8, + 0xf4a,0xf11,0x1133,0x50081,0x8,0xf4c,0xf4a,0xfa0,0x50085,0x8,0xf4e,0xf4c, + 0x10a1,0x60050,0x48,0x1247,0xf28,0xf3b,0xf4e,0x4003d,0xd9,0x10ad,0xec,0x7005f, + 0x43,0x10ae,0x10ad,0xee,0x2,0x88,0x50051,0x8,0x10af,0x10ae,0x0,0x500b4, + 0xf3,0x10b1,0x10af,0xa2,0x600a9,0x8,0x114b,0x10b1,0x9c,0x10af,0x60050,0x48, + 0xd8a,0x114b,0x114b,0x114b,0x50088,0x48,0xd8b,0x1247,0xd8a,0x4003d,0xe1,0x10bd, + 0xe3,0x50051,0x8,0x10c0,0xd8b,0x0,0x50051,0x8,0x10c1,0xd8b,0x1,0x50051, + 0x8,0x10c2,0xd8b,0x2,0x70050,0x43,0x10c3,0x10c0,0x10c1,0x10c2,0x9c,0x40063, + 0x10bd,0xe09,0x10c3,0x100fd,0x10038, +}; +static const char *fu0_rcas_pass_0_cb_names[] = {"cbRCAS"}; +static const uint32_t fu0_rcas_pass_0_cb_bind[] = {4}; +static const uint32_t fu0_rcas_pass_0_cb_count[] = {1}; +static const uint32_t fu0_rcas_pass_0_cb_space[] = {0}; +static const char *fu0_rcas_pass_0_srv_tex_names[] = {"r_input_exposure", "r_rcas_input"}; +static const uint32_t fu0_rcas_pass_0_srv_tex_bind[] = {0, 1}; +static const uint32_t fu0_rcas_pass_0_srv_tex_count[] = {1, 1}; +static const uint32_t fu0_rcas_pass_0_srv_tex_space[] = {0, 0}; +static const char *fu0_rcas_pass_0_uav_tex_names[] = {"rw_upscaled_output"}; +static const uint32_t fu0_rcas_pass_0_uav_tex_bind[] = {2}; +static const uint32_t fu0_rcas_pass_0_uav_tex_count[] = {1}; +static const uint32_t fu0_rcas_pass_0_uav_tex_space[] = {0}; + +static const uint32_t fu0_debug_view_pass_0_spv[2403] = { + 0x7230203,0x10500,0x8000b,0x709,0x0,0x20011,0x1,0x20011,0x38,0x6000b,0x1,0x4c534c47, + 0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0xd000f,0x5,0x4,0x6e69616d,0x0,0x8a, + 0xa9,0xad,0xb7,0xbf,0xc8,0xd3,0x26f,0x60010,0x4,0x11,0x8,0x8, + 0x1,0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572, + 0x74636e75,0x736e6f69,0x0,0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d, + 0x79745f63,0x736570,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576, + 0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669,0x40005,0x4,0x6e69616d,0x0, + 0x70005,0x4a,0x44786646,0x67756265,0x77656956,0x74726f70,0x0,0x50006,0x4a,0x0,0x7366666f,0x7465, + 0x50006,0x4a,0x1,0x657a6973,0x0,0x70005,0x88,0x53466263,0x50553352,0x4c414353,0x745f5245,0x0, + 0x60006,0x88,0x0,0x6e655269,0x53726564,0x657a69,0x70006,0x88,0x1,0x73705569,0x656c6163,0x657a6953, + 0x0,0x70006,0x88,0x2,0x78614d69,0x646e6552,0x69537265,0x657a,0x80006,0x88,0x3,0x76654466, + 0x54656369,0x6569566f,0x70654477,0x6874,0xa0006,0x88,0x4,0x65695666,0x61705377,0x6f546563,0x6574654d,0x61467372, + 0x726f7463,0x0,0x60005,0x8a,0x53466263,0x70553352,0x6c616373,0x7265,0x90005,0xa9,0x6e695f72,0x6e726574, + 0x755f6c61,0x61637370,0x5f64656c,0x6f6c6f63,0x72,0x60005,0xad,0x694c5f73,0x7261656e,0x6d616c43,0x70,0x70005, + 0xb7,0x755f7772,0x61637370,0x5f64656c,0x7074756f,0x7475,0x90005,0xbf,0x69645f72,0x6574616c,0x6f6d5f64,0x6e6f6974, + 0x6365765f,0x73726f74,0x0,0x60005,0xc8,0x69645f72,0x6574616c,0x65645f64,0x687470,0x90005,0xd3,0x69645f72, + 0x6574616c,0x65725f64,0x69746361,0x6d5f6576,0x736b7361,0x0,0x80005,0x26f,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f, + 0x496e6f69,0x44,0x30047,0x88,0x2,0x50048,0x88,0x0,0x23,0x0,0x50048,0x88, + 0x1,0x23,0x10,0x50048,0x88,0x2,0x23,0x20,0x50048,0x88,0x3,0x23, + 0x30,0x50048,0x88,0x4,0x23,0x78,0x40047,0x8a,0x21,0x6,0x40047,0x8a, + 0x22,0x0,0x40047,0xa9,0x21,0x3,0x40047,0xa9,0x22,0x0,0x40047,0xad, + 0x21,0x3e9,0x40047,0xad,0x22,0x0,0x30047,0xb7,0x19,0x40047,0xb7,0x21, + 0x5,0x40047,0xb7,0x22,0x0,0x40047,0xbf,0x21,0x1,0x40047,0xbf,0x22, + 0x0,0x40047,0xc8,0x21,0x2,0x40047,0xc8,0x22,0x0,0x40047,0xd3,0x21, + 0x0,0x40047,0xd3,0x22,0x0,0x40047,0x26f,0xb,0x1c,0x40047,0x284,0xb, + 0x19,0x20013,0x2,0x30021,0x3,0x2,0x30016,0x6,0x20,0x40017,0xc,0x6, + 0x2,0x40015,0x17,0x20,0x1,0x40017,0x18,0x17,0x2,0x40017,0x20,0x6, + 0x4,0x40020,0x2b,0x7,0x18,0x4001e,0x4a,0x18,0x18,0x40020,0x4b,0x7, + 0x4a,0x20014,0x6e,0x4002b,0x6,0x79,0x0,0x4002b,0x6,0x7a,0x3f800000,0x7001e, + 0x88,0x18,0x18,0x18,0x20,0x6,0x40020,0x89,0x2,0x88,0x4003b,0x89, + 0x8a,0x2,0x4002b,0x17,0x8b,0x0,0x40020,0x8c,0x2,0x18,0x4002b,0x17, + 0x96,0x2,0x40020,0x9c,0x2,0x20,0x40020,0xa2,0x2,0x6,0x90019,0xa7, + 0x6,0x1,0x0,0x0,0x0,0x1,0x0,0x40020,0xa8,0x0,0xa7,0x4003b, + 0xa8,0xa9,0x0,0x2001a,0xab,0x40020,0xac,0x0,0xab,0x4003b,0xac,0xad, + 0x0,0x3001b,0xaf,0xa7,0x90019,0xb5,0x6,0x1,0x0,0x0,0x0,0x2, + 0x0,0x40020,0xb6,0x0,0xb5,0x4003b,0xb6,0xb7,0x0,0x4003b,0xa8,0xbf, + 0x0,0x4003b,0xa8,0xc8,0x0,0x40015,0xce,0x20,0x0,0x4003b,0xa8,0xd3, + 0x0,0x4002b,0x6,0xe1,0x3f000000,0x5002c,0xc,0xe2,0xe1,0xe1,0x4002b,0xce, + 0xf8,0x1,0x4002b,0x17,0x111,0x1,0x4002b,0xce,0x19a,0x3,0x4002b,0x6, + 0x1ec,0x3eaaaaab,0x5002c,0xc,0x1ed,0x1ec,0x1ec,0x4002b,0x17,0x1fb,0x3,0x4001c, + 0x205,0x4a,0x19a,0x4001c,0x206,0x205,0x19a,0x40020,0x207,0x7,0x206,0x40017, + 0x26d,0xce,0x3,0x40020,0x26e,0x1,0x26d,0x4003b,0x26e,0x26f,0x1,0x40017, + 0x270,0xce,0x2,0x4002b,0xce,0x283,0x8,0x6002c,0x26d,0x284,0x283,0x283, + 0xf8,0x4002b,0x6,0x6d4,0x3d23d70a,0x4002b,0xce,0x707,0x2,0x4002b,0xce,0x708, + 0x4,0x50036,0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003b,0x207,0x289,0x7, + 0x4003d,0x26d,0x271,0x26f,0x7004f,0x270,0x272,0x271,0x271,0x0,0x1,0x4007c, + 0x18,0x273,0x272,0x50041,0x8c,0x304,0x8a,0xf8,0x4003d,0x18,0x305,0x304, + 0x4006f,0xc,0x2a4,0x305,0x50085,0xc,0x2a6,0x2a4,0x1ed,0x4006e,0x18,0x2a7, + 0x2a6,0x200f9,0x2a8,0x200f8,0x2a8,0x700f5,0x17,0x6b4,0x8b,0x5,0x2c4,0x2c2, + 0x500b1,0x6e,0x2ab,0x6b4,0x1fb,0x400f6,0x2c5,0x2c2,0x0,0x400fa,0x2ab,0x2ac, + 0x2c5,0x200f8,0x2ac,0x200f9,0x2ad,0x200f8,0x2ad,0x700f5,0x17,0x6cd,0x8b,0x2ac, + 0x2c0,0x2b1,0x500b1,0x6e,0x2b0,0x6cd,0x1fb,0x400f6,0x2c1,0x2b1,0x0,0x400fa, + 0x2b0,0x2b1,0x2c1,0x200f8,0x2b1,0x50050,0x18,0x2b7,0x6cd,0x6b4,0x50084,0x18, + 0x2b8,0x2a7,0x2b7,0x70041,0x2b,0x2b9,0x289,0x6b4,0x6cd,0x8b,0x3003e,0x2b9, + 0x2b8,0x70041,0x2b,0x2bd,0x289,0x6b4,0x6cd,0x111,0x3003e,0x2bd,0x2a7,0x50080, + 0x17,0x2c0,0x6cd,0x111,0x200f9,0x2ad,0x200f8,0x2c1,0x200f9,0x2c2,0x200f8,0x2c2, + 0x50080,0x17,0x2c4,0x6b4,0x111,0x200f9,0x2a8,0x200f8,0x2c5,0x60041,0x4b,0x2c7, + 0x289,0x8b,0x8b,0x4003d,0x4a,0x2c8,0x2c7,0x50051,0x18,0x668,0x2c8,0x0, + 0x50051,0x18,0x669,0x2c8,0x1,0x50080,0x18,0x30e,0x668,0x669,0x50051,0x17, + 0x310,0x273,0x0,0x50051,0x17,0x312,0x668,0x0,0x500af,0x6e,0x313,0x310, + 0x312,0x300f7,0x31a,0x0,0x400fa,0x313,0x314,0x31a,0x200f8,0x314,0x50051,0x17, + 0x318,0x30e,0x0,0x500b1,0x6e,0x319,0x310,0x318,0x200f9,0x31a,0x200f8,0x31a, + 0x700f5,0x6e,0x31b,0x313,0x2c5,0x319,0x314,0x300f7,0x32a,0x0,0x400fa,0x31b, + 0x31c,0x32a,0x200f8,0x31c,0x50051,0x17,0x31e,0x273,0x1,0x50051,0x17,0x320, + 0x668,0x1,0x500af,0x6e,0x321,0x31e,0x320,0x300f7,0x328,0x0,0x400fa,0x321, + 0x322,0x328,0x200f8,0x322,0x50051,0x17,0x326,0x30e,0x1,0x500b1,0x6e,0x327, + 0x31e,0x326,0x200f9,0x328,0x200f8,0x328,0x700f5,0x6e,0x329,0x321,0x31c,0x327, + 0x322,0x200f9,0x32a,0x200f8,0x32a,0x700f5,0x6e,0x32b,0x31b,0x31a,0x329,0x328, + 0x300f7,0x2cf,0x0,0x400fa,0x32b,0x2ca,0x2cf,0x200f8,0x2ca,0x4003d,0x4a,0x2cd, + 0x2c7,0x50051,0x18,0x664,0x2cd,0x0,0x50051,0x18,0x665,0x2cd,0x1,0x50082, + 0x18,0x34c,0x273,0x664,0x4006f,0xc,0x34d,0x34c,0x50081,0xc,0x34f,0x34d, + 0xe2,0x4006f,0xc,0x352,0x665,0x50088,0xc,0x353,0x34f,0x352,0x50041,0x8c, + 0x357,0x8a,0x8b,0x4003d,0x18,0x358,0x357,0x50041,0x8c,0x35b,0x8a,0x707, + 0x4003d,0x18,0x35c,0x35b,0x4006f,0xc,0x368,0x358,0x50085,0xc,0x369,0x353, + 0x368,0x50083,0xc,0x36c,0x368,0xe2,0x7000c,0xc,0x379,0x1,0x25,0x369, + 0x36c,0x7000c,0xc,0x37e,0x1,0x28,0xe2,0x379,0x4006f,0xc,0x372,0x35c, + 0x50088,0xc,0x373,0x37e,0x372,0x4003d,0xa7,0x381,0xbf,0x4003d,0xab,0x382, + 0xad,0x50056,0xaf,0x383,0x381,0x382,0x70058,0x20,0x385,0x383,0x373,0x2, + 0x79,0x7004f,0xc,0x386,0x385,0x385,0x0,0x1,0x50085,0xc,0x38c,0x386, + 0x368,0x5008e,0xc,0x38d,0x38c,0xe1,0x50081,0xc,0x38f,0xe2,0x38d,0x50051, + 0x6,0x390,0x38f,0x0,0x50051,0x6,0x391,0x38f,0x1,0x4003d,0xb5,0x398, + 0xb7,0x70050,0x20,0x39e,0x390,0x391,0xe1,0x7a,0x40063,0x398,0x273,0x39e, + 0x200f9,0x2cf,0x200f8,0x2cf,0x60041,0x4b,0x2d1,0x289,0x8b,0x111,0x4003d,0x4a, + 0x2d2,0x2d1,0x50051,0x18,0x675,0x2d2,0x0,0x50051,0x18,0x676,0x2d2,0x1, + 0x50080,0x18,0x3a6,0x675,0x676,0x50051,0x17,0x3aa,0x675,0x0,0x500af,0x6e, + 0x3ab,0x310,0x3aa,0x300f7,0x3b2,0x0,0x400fa,0x3ab,0x3ac,0x3b2,0x200f8,0x3ac, + 0x50051,0x17,0x3b0,0x3a6,0x0,0x500b1,0x6e,0x3b1,0x310,0x3b0,0x200f9,0x3b2, + 0x200f8,0x3b2,0x700f5,0x6e,0x3b3,0x3ab,0x2cf,0x3b1,0x3ac,0x300f7,0x3c2,0x0, + 0x400fa,0x3b3,0x3b4,0x3c2,0x200f8,0x3b4,0x50051,0x17,0x3b6,0x273,0x1,0x50051, + 0x17,0x3b8,0x675,0x1,0x500af,0x6e,0x3b9,0x3b6,0x3b8,0x300f7,0x3c0,0x0, + 0x400fa,0x3b9,0x3ba,0x3c0,0x200f8,0x3ba,0x50051,0x17,0x3be,0x3a6,0x1,0x500b1, + 0x6e,0x3bf,0x3b6,0x3be,0x200f9,0x3c0,0x200f8,0x3c0,0x700f5,0x6e,0x3c1,0x3b9, + 0x3b4,0x3bf,0x3ba,0x200f9,0x3c2,0x200f8,0x3c2,0x700f5,0x6e,0x3c3,0x3b3,0x3b2, + 0x3c1,0x3c0,0x300f7,0x2d9,0x0,0x400fa,0x3c3,0x2d4,0x2d9,0x200f8,0x2d4,0x4003d, + 0x4a,0x2d7,0x2d1,0x50051,0x18,0x660,0x2d7,0x0,0x50051,0x18,0x661,0x2d7, + 0x1,0x50082,0x18,0x3df,0x273,0x660,0x4006f,0xc,0x3e0,0x3df,0x50081,0xc, + 0x3e2,0x3e0,0xe2,0x4006f,0xc,0x3e5,0x661,0x50088,0xc,0x3e6,0x3e2,0x3e5, + 0x4003d,0xa7,0x3ea,0xa9,0x4003d,0xab,0x3eb,0xad,0x50056,0xaf,0x3ec,0x3ea, + 0x3eb,0x70058,0x20,0x3ee,0x3ec,0x3e6,0x2,0x79,0x50051,0x6,0x3d2,0x3ee, + 0x3,0x50083,0x6,0x3d3,0x3d2,0x7a,0x8000c,0x6,0x3f2,0x1,0x2b,0x3d3, + 0x79,0x7a,0x4003d,0xb5,0x3f4,0xb7,0x70050,0x20,0x3fa,0x3f2,0x79,0x79, + 0x7a,0x40063,0x3f4,0x273,0x3fa,0x200f9,0x2d9,0x200f8,0x2d9,0x60041,0x4b,0x2db, + 0x289,0x8b,0x96,0x4003d,0x4a,0x2dc,0x2db,0x50051,0x18,0x682,0x2dc,0x0, + 0x50051,0x18,0x683,0x2dc,0x1,0x50080,0x18,0x402,0x682,0x683,0x50051,0x17, + 0x406,0x682,0x0,0x500af,0x6e,0x407,0x310,0x406,0x300f7,0x40e,0x0,0x400fa, + 0x407,0x408,0x40e,0x200f8,0x408,0x50051,0x17,0x40c,0x402,0x0,0x500b1,0x6e, + 0x40d,0x310,0x40c,0x200f9,0x40e,0x200f8,0x40e,0x700f5,0x6e,0x40f,0x407,0x2d9, + 0x40d,0x408,0x300f7,0x41e,0x0,0x400fa,0x40f,0x410,0x41e,0x200f8,0x410,0x50051, + 0x17,0x412,0x273,0x1,0x50051,0x17,0x414,0x682,0x1,0x500af,0x6e,0x415, + 0x412,0x414,0x300f7,0x41c,0x0,0x400fa,0x415,0x416,0x41c,0x200f8,0x416,0x50051, + 0x17,0x41a,0x402,0x1,0x500b1,0x6e,0x41b,0x412,0x41a,0x200f9,0x41c,0x200f8, + 0x41c,0x700f5,0x6e,0x41d,0x415,0x410,0x41b,0x416,0x200f9,0x41e,0x200f8,0x41e, + 0x700f5,0x6e,0x41f,0x40f,0x40e,0x41d,0x41c,0x300f7,0x2e3,0x0,0x400fa,0x41f, + 0x2de,0x2e3,0x200f8,0x2de,0x4003d,0x4a,0x2e1,0x2db,0x50051,0x18,0x65c,0x2e1, + 0x0,0x50051,0x18,0x65d,0x2e1,0x1,0x50082,0x18,0x446,0x273,0x65c,0x4006f, + 0xc,0x447,0x446,0x50081,0xc,0x449,0x447,0xe2,0x4006f,0xc,0x44c,0x65d, + 0x50088,0xc,0x44d,0x449,0x44c,0x50041,0x8c,0x451,0x8a,0x8b,0x4003d,0x18, + 0x452,0x451,0x50041,0x8c,0x455,0x8a,0x707,0x4003d,0x18,0x456,0x455,0x4006f, + 0xc,0x462,0x452,0x50085,0xc,0x463,0x44d,0x462,0x50083,0xc,0x466,0x462, + 0xe2,0x7000c,0xc,0x473,0x1,0x25,0x463,0x466,0x7000c,0xc,0x478,0x1, + 0x28,0xe2,0x473,0x4006f,0xc,0x46c,0x456,0x50088,0xc,0x46d,0x478,0x46c, + 0x4003d,0xa7,0x47b,0xc8,0x4003d,0xab,0x47c,0xad,0x50056,0xaf,0x47d,0x47b, + 0x47c,0x70058,0x20,0x47f,0x47d,0x46d,0x2,0x79,0x50051,0x6,0x480,0x47f, + 0x0,0x50041,0x9c,0x495,0x8a,0x19a,0x4003d,0x20,0x496,0x495,0x50051,0x6, + 0x48d,0x496,0x1,0x50051,0x6,0x490,0x496,0x0,0x50083,0x6,0x491,0x480, + 0x490,0x50088,0x6,0x492,0x48d,0x491,0x50041,0xa2,0x499,0x8a,0x708,0x4003d, + 0x6,0x49a,0x499,0x50085,0x6,0x487,0x492,0x49a,0x50085,0x6,0x43b,0x487, + 0x6d4,0x8000c,0x6,0x49e,0x1,0x2b,0x43b,0x79,0x7a,0x4003d,0xb5,0x4a0, + 0xb7,0x70050,0x20,0x4a6,0x49e,0x79,0x79,0x7a,0x40063,0x4a0,0x273,0x4a6, + 0x200f9,0x2e3,0x200f8,0x2e3,0x60041,0x4b,0x2e5,0x289,0x96,0x8b,0x4003d,0x4a, + 0x2e6,0x2e5,0x50051,0x18,0x68f,0x2e6,0x0,0x50051,0x18,0x690,0x2e6,0x1, + 0x50080,0x18,0x4ae,0x68f,0x690,0x50051,0x17,0x4b2,0x68f,0x0,0x500af,0x6e, + 0x4b3,0x310,0x4b2,0x300f7,0x4ba,0x0,0x400fa,0x4b3,0x4b4,0x4ba,0x200f8,0x4b4, + 0x50051,0x17,0x4b8,0x4ae,0x0,0x500b1,0x6e,0x4b9,0x310,0x4b8,0x200f9,0x4ba, + 0x200f8,0x4ba,0x700f5,0x6e,0x4bb,0x4b3,0x2e3,0x4b9,0x4b4,0x300f7,0x4ca,0x0, + 0x400fa,0x4bb,0x4bc,0x4ca,0x200f8,0x4bc,0x50051,0x17,0x4be,0x273,0x1,0x50051, + 0x17,0x4c0,0x68f,0x1,0x500af,0x6e,0x4c1,0x4be,0x4c0,0x300f7,0x4c8,0x0, + 0x400fa,0x4c1,0x4c2,0x4c8,0x200f8,0x4c2,0x50051,0x17,0x4c6,0x4ae,0x1,0x500b1, + 0x6e,0x4c7,0x4be,0x4c6,0x200f9,0x4c8,0x200f8,0x4c8,0x700f5,0x6e,0x4c9,0x4c1, + 0x4bc,0x4c7,0x4c2,0x200f9,0x4ca,0x200f8,0x4ca,0x700f5,0x6e,0x4cb,0x4bb,0x4ba, + 0x4c9,0x4c8,0x300f7,0x2ed,0x0,0x400fa,0x4cb,0x2e8,0x2ed,0x200f8,0x2e8,0x4003d, + 0x4a,0x2eb,0x2e5,0x50051,0x18,0x658,0x2eb,0x0,0x50051,0x18,0x659,0x2eb, + 0x1,0x50082,0x18,0x4ee,0x273,0x658,0x4006f,0xc,0x4ef,0x4ee,0x50081,0xc, + 0x4f1,0x4ef,0xe2,0x4006f,0xc,0x4f4,0x659,0x50088,0xc,0x4f5,0x4f1,0x4f4, + 0x50041,0x8c,0x4f9,0x8a,0x8b,0x4003d,0x18,0x4fa,0x4f9,0x50041,0x8c,0x4fd, + 0x8a,0x707,0x4003d,0x18,0x4fe,0x4fd,0x4006f,0xc,0x50a,0x4fa,0x50085,0xc, + 0x50b,0x4f5,0x50a,0x50083,0xc,0x50e,0x50a,0xe2,0x7000c,0xc,0x51b,0x1, + 0x25,0x50b,0x50e,0x7000c,0xc,0x520,0x1,0x28,0xe2,0x51b,0x4006f,0xc, + 0x514,0x4fe,0x50088,0xc,0x515,0x520,0x514,0x4003d,0xa7,0x523,0xd3,0x4003d, + 0xab,0x524,0xad,0x50056,0xaf,0x525,0x523,0x524,0x70058,0x20,0x527,0x525, + 0x515,0x2,0x79,0x50051,0x6,0x4e2,0x527,0x1,0x8000c,0x6,0x52b,0x1, + 0x2b,0x4e2,0x79,0x7a,0x4003d,0xb5,0x52d,0xb7,0x70050,0x20,0x533,0x79, + 0x52b,0x79,0x7a,0x40063,0x52d,0x273,0x533,0x200f9,0x2ed,0x200f8,0x2ed,0x60041, + 0x4b,0x2ef,0x289,0x96,0x111,0x4003d,0x4a,0x2f0,0x2ef,0x50051,0x18,0x69c, + 0x2f0,0x0,0x50051,0x18,0x69d,0x2f0,0x1,0x50080,0x18,0x53b,0x69c,0x69d, + 0x50051,0x17,0x53f,0x69c,0x0,0x500af,0x6e,0x540,0x310,0x53f,0x300f7,0x547, + 0x0,0x400fa,0x540,0x541,0x547,0x200f8,0x541,0x50051,0x17,0x545,0x53b,0x0, + 0x500b1,0x6e,0x546,0x310,0x545,0x200f9,0x547,0x200f8,0x547,0x700f5,0x6e,0x548, + 0x540,0x2ed,0x546,0x541,0x300f7,0x557,0x0,0x400fa,0x548,0x549,0x557,0x200f8, + 0x549,0x50051,0x17,0x54b,0x273,0x1,0x50051,0x17,0x54d,0x69c,0x1,0x500af, + 0x6e,0x54e,0x54b,0x54d,0x300f7,0x555,0x0,0x400fa,0x54e,0x54f,0x555,0x200f8, + 0x54f,0x50051,0x17,0x553,0x53b,0x1,0x500b1,0x6e,0x554,0x54b,0x553,0x200f9, + 0x555,0x200f8,0x555,0x700f5,0x6e,0x556,0x54e,0x549,0x554,0x54f,0x200f9,0x557, + 0x200f8,0x557,0x700f5,0x6e,0x558,0x548,0x547,0x556,0x555,0x300f7,0x2f7,0x0, + 0x400fa,0x558,0x2f2,0x2f7,0x200f8,0x2f2,0x4003d,0x4a,0x2f5,0x2ef,0x50051,0x18, + 0x654,0x2f5,0x0,0x50051,0x18,0x655,0x2f5,0x1,0x50082,0x18,0x57b,0x273, + 0x654,0x4006f,0xc,0x57c,0x57b,0x50081,0xc,0x57e,0x57c,0xe2,0x4006f,0xc, + 0x581,0x655,0x50088,0xc,0x582,0x57e,0x581,0x50041,0x8c,0x586,0x8a,0x8b, + 0x4003d,0x18,0x587,0x586,0x50041,0x8c,0x58a,0x8a,0x707,0x4003d,0x18,0x58b, + 0x58a,0x4006f,0xc,0x597,0x587,0x50085,0xc,0x598,0x582,0x597,0x50083,0xc, + 0x59b,0x597,0xe2,0x7000c,0xc,0x5a8,0x1,0x25,0x598,0x59b,0x7000c,0xc, + 0x5ad,0x1,0x28,0xe2,0x5a8,0x4006f,0xc,0x5a1,0x58b,0x50088,0xc,0x5a2, + 0x5ad,0x5a1,0x4003d,0xa7,0x5b0,0xd3,0x4003d,0xab,0x5b1,0xad,0x50056,0xaf, + 0x5b2,0x5b0,0x5b1,0x70058,0x20,0x5b4,0x5b2,0x5a2,0x2,0x79,0x50051,0x6, + 0x56f,0x5b4,0x2,0x8000c,0x6,0x5b8,0x1,0x2b,0x56f,0x79,0x7a,0x4003d, + 0xb5,0x5ba,0xb7,0x70050,0x20,0x5c0,0x79,0x5b8,0x79,0x7a,0x40063,0x5ba, + 0x273,0x5c0,0x200f9,0x2f7,0x200f8,0x2f7,0x60041,0x4b,0x2f9,0x289,0x96,0x96, + 0x4003d,0x4a,0x2fa,0x2f9,0x50051,0x18,0x6a9,0x2fa,0x0,0x50051,0x18,0x6aa, + 0x2fa,0x1,0x50080,0x18,0x5c8,0x6a9,0x6aa,0x50051,0x17,0x5cc,0x6a9,0x0, + 0x500af,0x6e,0x5cd,0x310,0x5cc,0x300f7,0x5d4,0x0,0x400fa,0x5cd,0x5ce,0x5d4, + 0x200f8,0x5ce,0x50051,0x17,0x5d2,0x5c8,0x0,0x500b1,0x6e,0x5d3,0x310,0x5d2, + 0x200f9,0x5d4,0x200f8,0x5d4,0x700f5,0x6e,0x5d5,0x5cd,0x2f7,0x5d3,0x5ce,0x300f7, + 0x5e4,0x0,0x400fa,0x5d5,0x5d6,0x5e4,0x200f8,0x5d6,0x50051,0x17,0x5d8,0x273, + 0x1,0x50051,0x17,0x5da,0x6a9,0x1,0x500af,0x6e,0x5db,0x5d8,0x5da,0x300f7, + 0x5e2,0x0,0x400fa,0x5db,0x5dc,0x5e2,0x200f8,0x5dc,0x50051,0x17,0x5e0,0x5c8, + 0x1,0x500b1,0x6e,0x5e1,0x5d8,0x5e0,0x200f9,0x5e2,0x200f8,0x5e2,0x700f5,0x6e, + 0x5e3,0x5db,0x5d6,0x5e1,0x5dc,0x200f9,0x5e4,0x200f8,0x5e4,0x700f5,0x6e,0x5e5, + 0x5d5,0x5d4,0x5e3,0x5e2,0x300f7,0x301,0x0,0x400fa,0x5e5,0x2fc,0x301,0x200f8, + 0x2fc,0x4003d,0x4a,0x2ff,0x2f9,0x50051,0x18,0x650,0x2ff,0x0,0x50051,0x18, + 0x651,0x2ff,0x1,0x50082,0x18,0x608,0x273,0x650,0x4006f,0xc,0x609,0x608, + 0x50081,0xc,0x60b,0x609,0xe2,0x4006f,0xc,0x60e,0x651,0x50088,0xc,0x60f, + 0x60b,0x60e,0x50041,0x8c,0x613,0x8a,0x8b,0x4003d,0x18,0x614,0x613,0x50041, + 0x8c,0x617,0x8a,0x707,0x4003d,0x18,0x618,0x617,0x4006f,0xc,0x624,0x614, + 0x50085,0xc,0x625,0x60f,0x624,0x50083,0xc,0x628,0x624,0xe2,0x7000c,0xc, + 0x635,0x1,0x25,0x625,0x628,0x7000c,0xc,0x63a,0x1,0x28,0xe2,0x635, + 0x4006f,0xc,0x62e,0x618,0x50088,0xc,0x62f,0x63a,0x62e,0x4003d,0xa7,0x63d, + 0xd3,0x4003d,0xab,0x63e,0xad,0x50056,0xaf,0x63f,0x63d,0x63e,0x70058,0x20, + 0x641,0x63f,0x62f,0x2,0x79,0x50051,0x6,0x5fc,0x641,0x0,0x8000c,0x6, + 0x645,0x1,0x2b,0x5fc,0x79,0x7a,0x4003d,0xb5,0x647,0xb7,0x70050,0x20, + 0x64d,0x79,0x645,0x79,0x7a,0x40063,0x647,0x273,0x64d,0x200f9,0x301,0x200f8, + 0x301,0x100fd,0x10038, +}; +static const char *fu0_debug_view_pass_0_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu0_debug_view_pass_0_cb_bind[] = {6}; +static const uint32_t fu0_debug_view_pass_0_cb_count[] = {1}; +static const uint32_t fu0_debug_view_pass_0_cb_space[] = {0}; +static const char *fu0_debug_view_pass_0_srv_tex_names[] = {"r_dilated_reactive_masks", "r_dilated_motion_vectors", "r_dilated_depth", "r_internal_upscaled_color"}; +static const uint32_t fu0_debug_view_pass_0_srv_tex_bind[] = {0, 1, 2, 3}; +static const uint32_t fu0_debug_view_pass_0_srv_tex_count[] = {1, 1, 1, 1}; +static const uint32_t fu0_debug_view_pass_0_srv_tex_space[] = {0, 0, 0, 0}; +static const char *fu0_debug_view_pass_0_uav_tex_names[] = {"rw_upscaled_output"}; +static const uint32_t fu0_debug_view_pass_0_uav_tex_bind[] = {5}; +static const uint32_t fu0_debug_view_pass_0_uav_tex_count[] = {1}; +static const uint32_t fu0_debug_view_pass_0_uav_tex_space[] = {0}; +static const char *fu0_debug_view_pass_0_sampler_names[] = {"s_LinearClamp"}; +static const uint32_t fu0_debug_view_pass_0_sampler_bind[] = {1001}; +static const uint32_t fu0_debug_view_pass_0_sampler_count[] = {1}; +static const uint32_t fu0_debug_view_pass_0_sampler_space[] = {0}; + +static const uint32_t fu0_autogen_reactive_pass_0_spv[967] = { + 0x7230203,0x10500,0x8000b,0x1c8,0x0,0x20011,0x1,0x6000b,0x1,0x4c534c47,0x6474732e,0x3035342e, + 0x0,0x3000e,0x0,0x1,0xb000f,0x5,0x4,0x6e69616d,0x0,0x32,0x4b,0x53, + 0x8f,0x93,0xee,0x60010,0x4,0x11,0x8,0x8,0x1,0x30003,0x2,0x1c2, + 0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0,0xb0004, + 0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004,0x475f4c47, + 0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45, + 0x64756c63,0x69645f65,0x74636572,0x657669,0x40005,0x4,0x6e69616d,0x0,0x80005,0x30,0x65476263,0x6172656e, + 0x65526574,0x69746361,0x745f6576,0x0,0x80006,0x30,0x0,0x5f6e6567,0x63616572,0x65766974,0x6163735f,0x656c, + 0x90006,0x30,0x1,0x5f6e6567,0x63616572,0x65766974,0x7268745f,0x6f687365,0x646c,0xa0006,0x30,0x2, + 0x5f6e6567,0x63616572,0x65766974,0x6e69625f,0x56797261,0x65756c61,0x0,0x80006,0x30,0x3,0x5f6e6567,0x63616572, + 0x65766974,0x616c665f,0x7367,0x70005,0x32,0x65476263,0x6172656e,0x65526574,0x69746361,0x6576,0x80005,0x4b, + 0x6e695f72,0x5f747570,0x6f6c6f63,0x696a5f72,0x72657474,0x6465,0x70005,0x53,0x6e695f72,0x5f747570,0x7161706f,0x6f5f6575, + 0x796c6e,0x60005,0x8f,0x575f6c67,0x476b726f,0x70756f72,0x4449,0x80005,0x93,0x4c5f6c67,0x6c61636f,0x6f766e49, + 0x69746163,0x44496e6f,0x0,0x80005,0xee,0x6f5f7772,0x75707475,0x75615f74,0x65726f74,0x69746361,0x6576,0x30047, + 0x30,0x2,0x50048,0x30,0x0,0x23,0x0,0x50048,0x30,0x1,0x23,0x4, + 0x50048,0x30,0x2,0x23,0x8,0x50048,0x30,0x3,0x23,0xc,0x40047,0x32, + 0x21,0x5,0x40047,0x32,0x22,0x0,0x40047,0x4b,0x21,0x1,0x40047,0x4b, + 0x22,0x0,0x40047,0x53,0x21,0x0,0x40047,0x53,0x22,0x0,0x40047,0x8f, + 0xb,0x1a,0x40047,0x93,0xb,0x1b,0x40047,0xee,0x21,0x2,0x40047,0xee, + 0x22,0x0,0x40047,0x107,0xb,0x19,0x20013,0x2,0x30021,0x3,0x2,0x30016, + 0x6,0x20,0x40015,0x14,0x20,0x0,0x40015,0x18,0x20,0x1,0x40017,0x19, + 0x18,0x2,0x40017,0x1b,0x6,0x3,0x6001e,0x30,0x6,0x6,0x6,0x14, + 0x40020,0x31,0x2,0x30,0x4003b,0x31,0x32,0x2,0x4002b,0x18,0x33,0x0, + 0x40020,0x34,0x2,0x6,0x4002b,0x18,0x39,0x1,0x4002b,0x18,0x3e,0x2, + 0x4002b,0x18,0x43,0x3,0x40020,0x44,0x2,0x14,0x90019,0x49,0x6,0x1, + 0x0,0x0,0x0,0x1,0x0,0x40020,0x4a,0x0,0x49,0x4003b,0x4a,0x4b, + 0x0,0x40017,0x4e,0x6,0x4,0x4003b,0x4a,0x53,0x0,0x4002b,0x6,0x5b, + 0x0,0x4002b,0x14,0x5e,0x0,0x4002b,0x14,0x63,0x1,0x4002b,0x14,0x67, + 0x2,0x4002b,0x6,0x6e,0x3f800000,0x4002b,0x6,0x75,0x387fda40,0x40017,0x8a,0x14, + 0x2,0x40017,0x8d,0x14,0x3,0x40020,0x8e,0x1,0x8d,0x4003b,0x8e,0x8f, + 0x1,0x4003b,0x8e,0x93,0x1,0x4002b,0x14,0x98,0x8,0x5002c,0x8a,0x99, + 0x98,0x98,0x20014,0xa9,0x4002b,0x14,0xda,0x4,0x90019,0xec,0x6,0x1, + 0x0,0x0,0x0,0x2,0x3,0x40020,0xed,0x0,0xec,0x4003b,0xed,0xee, + 0x0,0x6002c,0x8d,0x107,0x98,0x98,0x63,0x50036,0x2,0x4,0x0,0x3, + 0x200f8,0x5,0x4003d,0x8d,0x90,0x8f,0x7004f,0x8a,0x91,0x90,0x90,0x0, + 0x1,0x4003d,0x8d,0x94,0x93,0x7004f,0x8a,0x95,0x94,0x94,0x0,0x1, + 0x50084,0x8a,0x9a,0x91,0x99,0x50080,0x8a,0x9c,0x9a,0x95,0x4007c,0x19, + 0x9f,0x9c,0x4003d,0x49,0x10a,0x53,0x7005f,0x4e,0x10c,0x10a,0x9f,0x2, + 0x33,0x8004f,0x1b,0x10d,0x10c,0x10c,0x0,0x1,0x2,0x4003d,0x49,0x110, + 0x4b,0x7005f,0x4e,0x112,0x110,0x9f,0x2,0x33,0x8004f,0x1b,0x113,0x112, + 0x112,0x0,0x1,0x2,0x50041,0x44,0x117,0x32,0x43,0x4003d,0x14,0x118, + 0x117,0x500c7,0x14,0xa8,0x118,0x63,0x500ab,0xa9,0xaa,0xa8,0x5e,0x300f7, + 0xac,0x0,0x400fa,0xaa,0xab,0xac,0x200f8,0xab,0x50051,0x6,0x123,0x10c, + 0x0,0x7000c,0x6,0x132,0x1,0x28,0x5b,0x123,0x50051,0x6,0x126,0x10c, + 0x1,0x50051,0x6,0x128,0x10c,0x2,0x7000c,0x6,0x137,0x1,0x28,0x126, + 0x128,0x7000c,0x6,0x13c,0x1,0x28,0x132,0x137,0x50081,0x6,0x12b,0x13c, + 0x6e,0x60050,0x1b,0x12c,0x12b,0x12b,0x12b,0x50088,0x1b,0x12d,0x10d,0x12c, + 0x50051,0x6,0x147,0x112,0x0,0x7000c,0x6,0x156,0x1,0x28,0x5b,0x147, + 0x50051,0x6,0x14a,0x112,0x1,0x50051,0x6,0x14c,0x112,0x2,0x7000c,0x6, + 0x15b,0x1,0x28,0x14a,0x14c,0x7000c,0x6,0x160,0x1,0x28,0x156,0x15b, + 0x50081,0x6,0x14f,0x160,0x6e,0x60050,0x1b,0x150,0x14f,0x14f,0x14f,0x50088, + 0x1b,0x151,0x113,0x150,0x200f9,0xac,0x200f8,0xac,0x700f5,0x1b,0x1c2,0x113, + 0x5,0x151,0xab,0x700f5,0x1b,0x1c1,0x10d,0x5,0x12d,0xab,0x500c7,0x14, + 0xb4,0x118,0x67,0x500ab,0xa9,0xb5,0xb4,0x5e,0x300f7,0xb7,0x0,0x400fa, + 0xb5,0xb6,0xb7,0x200f8,0xb6,0x50051,0x6,0x16f,0x1c1,0x1,0x50051,0x6, + 0x171,0x1c1,0x2,0x7000c,0x6,0x17e,0x1,0x28,0x16f,0x171,0x50051,0x6, + 0x174,0x1c1,0x0,0x7000c,0x6,0x183,0x1,0x28,0x174,0x17e,0x50083,0x6, + 0x176,0x6e,0x183,0x7000c,0x6,0x188,0x1,0x28,0x75,0x176,0x60050,0x1b, + 0x178,0x188,0x188,0x188,0x50088,0x1b,0x179,0x1c1,0x178,0x50051,0x6,0x193, + 0x1c2,0x1,0x50051,0x6,0x195,0x1c2,0x2,0x7000c,0x6,0x1a2,0x1,0x28, + 0x193,0x195,0x50051,0x6,0x198,0x1c2,0x0,0x7000c,0x6,0x1a7,0x1,0x28, + 0x198,0x1a2,0x50083,0x6,0x19a,0x6e,0x1a7,0x7000c,0x6,0x1ac,0x1,0x28, + 0x75,0x19a,0x60050,0x1b,0x19c,0x1ac,0x1ac,0x1ac,0x50088,0x1b,0x19d,0x1c2, + 0x19c,0x200f9,0xb7,0x200f8,0xb7,0x700f5,0x1b,0x1c4,0x1c1,0xac,0x179,0xb6, + 0x700f5,0x1b,0x1c3,0x1c2,0xac,0x19d,0xb6,0x50083,0x1b,0xc2,0x1c3,0x1c4, + 0x6000c,0x1b,0xc3,0x1,0x4,0xc2,0x500c7,0x14,0xc5,0x118,0x98,0x500ab, + 0xa9,0xc6,0xc5,0x5e,0x300f7,0xc9,0x0,0x400fa,0xc6,0xc8,0xd2,0x200f8, + 0xc8,0x50051,0x6,0xcb,0xc3,0x0,0x50051,0x6,0xcd,0xc3,0x1,0x50051, + 0x6,0xcf,0xc3,0x2,0x7000c,0x6,0xd0,0x1,0x28,0xcd,0xcf,0x7000c, + 0x6,0xd1,0x1,0x28,0xcb,0xd0,0x200f9,0xc9,0x200f8,0xd2,0x6000c,0x6, + 0xd4,0x1,0x42,0xc3,0x200f9,0xc9,0x200f8,0xc9,0x700f5,0x6,0x1c5,0xd1, + 0xc8,0xd4,0xd2,0x50041,0x34,0x1b3,0x32,0x33,0x4003d,0x6,0x1b4,0x1b3, + 0x50085,0x6,0xd8,0x1c5,0x1b4,0x500c7,0x14,0xdb,0x118,0xda,0x500ab,0xa9, + 0xdc,0xdb,0x5e,0x300f7,0xdf,0x0,0x400fa,0xdc,0xde,0xe9,0x200f8,0xde, + 0x50041,0x34,0x1bb,0x32,0x39,0x4003d,0x6,0x1bc,0x1bb,0x500b8,0xa9,0xe2, + 0xd8,0x1bc,0x300f7,0xe5,0x0,0x400fa,0xe2,0xe4,0xe6,0x200f8,0xe4,0x200f9, + 0xe5,0x200f8,0xe6,0x50041,0x34,0x1bf,0x32,0x3e,0x4003d,0x6,0x1c0,0x1bf, + 0x200f9,0xe5,0x200f8,0xe5,0x700f5,0x6,0x1c6,0x5b,0xe4,0x1c0,0xe6,0x200f9, + 0xdf,0x200f8,0xe9,0x200f9,0xdf,0x200f8,0xdf,0x700f5,0x6,0x1c7,0x1c6,0xe5, + 0xd8,0xe9,0x4003d,0xec,0xef,0xee,0x70050,0x4e,0xf3,0x1c7,0x5b,0x5b, + 0x5b,0x40063,0xef,0x9f,0xf3,0x100fd,0x10038, +}; +static const char *fu0_autogen_reactive_pass_0_cb_names[] = {"cbGenerateReactive"}; +static const uint32_t fu0_autogen_reactive_pass_0_cb_bind[] = {5}; +static const uint32_t fu0_autogen_reactive_pass_0_cb_count[] = {1}; +static const uint32_t fu0_autogen_reactive_pass_0_cb_space[] = {0}; +static const char *fu0_autogen_reactive_pass_0_srv_tex_names[] = {"r_input_opaque_only", "r_input_color_jittered"}; +static const uint32_t fu0_autogen_reactive_pass_0_srv_tex_bind[] = {0, 1}; +static const uint32_t fu0_autogen_reactive_pass_0_srv_tex_count[] = {1, 1}; +static const uint32_t fu0_autogen_reactive_pass_0_srv_tex_space[] = {0, 0}; +static const char *fu0_autogen_reactive_pass_0_uav_tex_names[] = {"rw_output_autoreactive"}; +static const uint32_t fu0_autogen_reactive_pass_0_uav_tex_bind[] = {2}; +static const uint32_t fu0_autogen_reactive_pass_0_uav_tex_count[] = {1}; +static const uint32_t fu0_autogen_reactive_pass_0_uav_tex_space[] = {0}; + +static const uint32_t fu1_prepare_inputs_pass_0_spv[1563] = { + 0x7230203,0x10500,0x8000b,0x51e,0x0,0x20011,0x1,0x20011,0x31,0x6000b,0x1,0x4c534c47, + 0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0xf000f,0x5,0x4,0x6e69616d,0x0,0xb3, + 0xce,0xd6,0xde,0xec,0xf1,0xfc,0x105,0x10c,0x283,0x60010,0x4,0x11, + 0x8,0x8,0x1,0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373, + 0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0,0x80004,0x455f4c47,0x735f5458,0x65646168,0x36315f72,0x5f746962,0x726f7473, + 0x656761,0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570, + 0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47, + 0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669,0x40005,0x4,0x6e69616d,0x0,0x70005,0xb1, + 0x53466263,0x50553352,0x4c414353,0x745f5245,0x0,0x60006,0xb1,0x0,0x6e655269,0x53726564,0x657a69,0x80006, + 0xb1,0x1,0x76654466,0x54656369,0x6569566f,0x70654477,0x6874,0x80006,0xb1,0x2,0x746f4d66,0x566e6f69, + 0x6f746365,0x61635372,0x656c,0xa0006,0xb1,0x3,0x65695666,0x61705377,0x6f546563,0x6574654d,0x61467372,0x726f7463, + 0x0,0x60005,0xb3,0x53466263,0x70553352,0x6c616373,0x7265,0x60005,0xce,0x6e695f72,0x5f747570,0x74706564, + 0x68,0x80005,0xd6,0x6e695f72,0x5f747570,0x6f6c6f63,0x696a5f72,0x72657474,0x6465,0x80005,0xde,0x6e695f72, + 0x5f747570,0x69746f6d,0x765f6e6f,0x6f746365,0x7372,0x70005,0xec,0x665f7772,0x68747261,0x5f747365,0x74706564,0x68, + 0x60005,0xf1,0x635f7772,0x65727275,0x6c5f746e,0x616d75,0xc0005,0xfc,0x725f7772,0x6e6f6365,0x75727473,0x64657463, + 0x6572705f,0x756f6976,0x656e5f73,0x73657261,0x65645f74,0x687470,0x70005,0x105,0x645f7772,0x74616c69,0x645f6465,0x68747065, + 0x0,0x90005,0x10c,0x645f7772,0x74616c69,0x6d5f6465,0x6f69746f,0x65765f6e,0x726f7463,0x73,0x80005,0x283, + 0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x44,0x30047,0xb1,0x2,0x50048,0xb1,0x0, + 0x23,0x0,0x50048,0xb1,0x1,0x23,0x30,0x50048,0xb1,0x2,0x23,0x50, + 0x50048,0xb1,0x3,0x23,0x78,0x40047,0xb3,0x21,0x8,0x40047,0xb3,0x22, + 0x0,0x40047,0xce,0x21,0x1,0x40047,0xce,0x22,0x0,0x40047,0xd6,0x21, + 0x2,0x40047,0xd6,0x22,0x0,0x40047,0xde,0x21,0x0,0x40047,0xde,0x22, + 0x0,0x40047,0xec,0x21,0x6,0x40047,0xec,0x22,0x0,0x40047,0xf1,0x21, + 0x7,0x40047,0xf1,0x22,0x0,0x40047,0xfc,0x21,0x5,0x40047,0xfc,0x22, + 0x0,0x30047,0x105,0x19,0x40047,0x105,0x21,0x4,0x40047,0x105,0x22,0x0, + 0x30047,0x10c,0x19,0x40047,0x10c,0x21,0x3,0x40047,0x10c,0x22,0x0,0x40047, + 0x283,0xb,0x1c,0x40047,0x297,0xb,0x19,0x30047,0x2cd,0x18,0x30047,0x2d2, + 0x18,0x20013,0x2,0x30021,0x3,0x2,0x30016,0x6,0x20,0x40020,0x7,0x7, + 0x6,0x40017,0x12,0x6,0x2,0x40017,0x21,0x6,0x3,0x40015,0x28,0x20, + 0x1,0x40017,0x29,0x28,0x2,0x40017,0x2d,0x6,0x4,0x40020,0x37,0x7, + 0x29,0x20014,0x65,0x40015,0x71,0x20,0x0,0x4002b,0x71,0x72,0x4,0x4001c, + 0x73,0x29,0x72,0x4001c,0x74,0x6,0x72,0x4002b,0x6,0x99,0x0,0x4002b, + 0x6,0x9a,0x3f800000,0x6001e,0xb1,0x29,0x2d,0x12,0x6,0x40020,0xb2,0x2, + 0xb1,0x4003b,0xb2,0xb3,0x2,0x4002b,0x28,0xb4,0x0,0x40020,0xb5,0x2, + 0x29,0x40020,0xbb,0x2,0x2d,0x4002b,0x28,0xc0,0x9,0x40020,0xc1,0x2, + 0x12,0x40020,0xc7,0x2,0x6,0x90019,0xcc,0x6,0x1,0x0,0x0,0x0, + 0x1,0x0,0x40020,0xcd,0x0,0xcc,0x4003b,0xcd,0xce,0x0,0x4002b,0x71, + 0xd2,0x0,0x4003b,0xcd,0xd6,0x0,0x4003b,0xcd,0xde,0x0,0x90019,0xea, + 0x6,0x1,0x0,0x0,0x0,0x2,0x9,0x40020,0xeb,0x0,0xea,0x4003b, + 0xeb,0xec,0x0,0x4003b,0xeb,0xf1,0x0,0x90019,0xfa,0x71,0x1,0x0, + 0x0,0x0,0x2,0x21,0x40020,0xfb,0x0,0xfa,0x4003b,0xfb,0xfc,0x0, + 0x40020,0xff,0xb,0x71,0x4002b,0x71,0x101,0x1,0x90019,0x103,0x6,0x1, + 0x0,0x0,0x0,0x2,0x3,0x40020,0x104,0x0,0x103,0x4003b,0x104,0x105, + 0x0,0x90019,0x10a,0x6,0x1,0x0,0x0,0x0,0x2,0x7,0x40020,0x10b, + 0x0,0x10a,0x4003b,0x10b,0x10c,0x0,0x4002b,0x6,0x113,0x3e800000,0x4002b,0x6, + 0x114,0x3f400000,0x4002b,0x6,0x121,0x45700000,0x4002b,0x6,0x122,0x45070000,0x5002c,0x12, + 0x123,0x121,0x122,0x4002b,0x6,0x129,0x3e59b3d0,0x4002b,0x6,0x12a,0x3f371759,0x4002b, + 0x6,0x12b,0x3d93dd98,0x6002c,0x21,0x12c,0x129,0x12a,0x12b,0x40017,0x131,0x71, + 0x2,0x40017,0x135,0x65,0x2,0x4002b,0x6,0x152,0x3f000000,0x5002c,0x12,0x153, + 0x152,0x152,0x5002c,0x29,0x160,0xb4,0xb4,0x4002b,0x28,0x162,0x1,0x5002c, + 0x29,0x163,0x162,0xb4,0x5002c,0x29,0x165,0xb4,0x162,0x5002c,0x29,0x168, + 0x162,0x162,0x4002b,0x6,0x18d,0x477fe000,0x4002b,0x28,0x1b7,0x4,0x4002b,0x6, + 0x1c2,0x3a1fe868,0x4002b,0x71,0x1e3,0x9,0x4001c,0x1e4,0x29,0x1e3,0x4002b,0x28, + 0x1e5,0xffffffff,0x5002c,0x29,0x1e6,0xb4,0x1e5,0x5002c,0x29,0x1e7,0x1e5,0xb4, + 0x5002c,0x29,0x1e8,0x1e5,0x162,0x5002c,0x29,0x1e9,0x1e5,0x1e5,0x5002c,0x29, + 0x1ea,0x162,0x1e5,0xc002c,0x1e4,0x1eb,0x160,0x163,0x165,0x1e6,0x1e7,0x1e8, + 0x168,0x1e9,0x1ea,0x40020,0x1ed,0x7,0x1e4,0x4001c,0x1f2,0x6,0x1e3,0x40020, + 0x1f3,0x7,0x1f2,0x6002c,0x21,0x241,0x99,0x99,0x99,0x40017,0x281,0x71, + 0x3,0x40020,0x282,0x1,0x281,0x4003b,0x282,0x283,0x1,0x4002b,0x71,0x296, + 0x8,0x6002c,0x281,0x297,0x296,0x296,0x101,0x40020,0x476,0x7,0x73,0x40020, + 0x478,0x7,0x74,0x7002c,0x73,0x50b,0x160,0x163,0x165,0x168,0x4002b,0x6, + 0x50c,0x3c23d70a,0x4002b,0x71,0x51c,0x2,0x4002b,0x71,0x51d,0x3,0x50036,0x2, + 0x4,0x0,0x3,0x200f8,0x5,0x4003b,0x478,0x492,0x7,0x4003b,0x476,0x491, + 0x7,0x5003b,0x1ed,0x2cd,0x7,0x1eb,0x4003b,0x1f3,0x2ce,0x7,0x5003b,0x1ed, + 0x2d2,0x7,0x1eb,0x4003d,0x281,0x284,0x283,0x7004f,0x131,0x285,0x284,0x284, + 0x0,0x1,0x4007c,0x29,0x286,0x285,0x3003e,0x2cd,0x1eb,0x3003e,0x2d2,0x1eb, + 0x200f9,0x2da,0x200f8,0x2da,0x700f5,0x28,0x4e0,0xb4,0x5,0x2ea,0x2de,0x500b1, + 0x65,0x2dd,0x4e0,0xc0,0x400f6,0x2eb,0x2de,0x0,0x400fa,0x2dd,0x2de,0x2eb, + 0x200f8,0x2de,0x50041,0x37,0x2e1,0x2cd,0x4e0,0x4003d,0x29,0x2e2,0x2e1,0x50080, + 0x29,0x2e3,0x286,0x2e2,0x4003d,0xcc,0x31c,0xce,0x7005f,0x2d,0x31e,0x31c, + 0x2e3,0x2,0xb4,0x50051,0x6,0x31f,0x31e,0x0,0x50041,0x7,0x2e7,0x2ce, + 0x4e0,0x3003e,0x2e7,0x31f,0x50080,0x28,0x2ea,0x4e0,0x162,0x200f9,0x2da,0x200f8, + 0x2eb,0x50041,0x7,0x2ee,0x2ce,0xb4,0x4003d,0x6,0x2ef,0x2ee,0x4003d,0x6, + 0x2f2,0x2ee,0x200f9,0x2f4,0x200f8,0x2f4,0x700f5,0x6,0x4e5,0x2ef,0x2eb,0x4f8, + 0x315,0x700f5,0x29,0x4e4,0x286,0x2eb,0x4f6,0x315,0x700f5,0x6,0x4e3,0x2f2, + 0x2eb,0x4f4,0x315,0x700f5,0x28,0x4e2,0x162,0x2eb,0x317,0x315,0x500b1,0x65, + 0x2f7,0x4e2,0xc0,0x400f6,0x318,0x315,0x0,0x400fa,0x2f7,0x2f8,0x318,0x200f8, + 0x2f8,0x50041,0x37,0x2fb,0x2d2,0x4e2,0x4003d,0x29,0x2fc,0x2fb,0x50080,0x29, + 0x2fd,0x286,0x2fc,0x50041,0xb5,0x322,0xb3,0xb4,0x4003d,0x29,0x323,0x322, + 0x4007c,0x131,0x328,0x2fd,0x4007c,0x131,0x32a,0x323,0x500b0,0x135,0x32b,0x328, + 0x32a,0x4009b,0x65,0x32c,0x32b,0x300f7,0x314,0x0,0x400fa,0x32c,0x301,0x314, + 0x200f8,0x301,0x50041,0x7,0x303,0x2ce,0x4e2,0x4003d,0x6,0x304,0x303,0x500b8, + 0x65,0x308,0x304,0x4e5,0x300f7,0x313,0x0,0x400fa,0x308,0x309,0x313,0x200f8, + 0x309,0x7000c,0x6,0x331,0x1,0x28,0x4e3,0x304,0x200f9,0x313,0x200f8,0x313, + 0x700f5,0x6,0x4f5,0x4e3,0x301,0x331,0x309,0x600a9,0x6,0x50d,0x308,0x304, + 0x4e5,0x50050,0x135,0x50e,0x308,0x308,0x600a9,0x29,0x50f,0x50e,0x2fd,0x4e4, + 0x200f9,0x314,0x200f8,0x314,0x700f5,0x6,0x4f8,0x4e5,0x2f8,0x50d,0x313,0x700f5, + 0x29,0x4f6,0x4e4,0x2f8,0x50f,0x313,0x700f5,0x6,0x4f4,0x4e3,0x2f8,0x4f5, + 0x313,0x200f9,0x315,0x200f8,0x315,0x50080,0x28,0x317,0x4e2,0x162,0x200f9,0x2f4, + 0x200f8,0x318,0x4003d,0xcc,0x341,0xde,0x7005f,0x2d,0x343,0x341,0x4e4,0x2, + 0xb4,0x7004f,0x12,0x344,0x343,0x343,0x0,0x1,0x50041,0xc1,0x34b,0xb3, + 0x51c,0x4003d,0x12,0x34c,0x34b,0x50085,0x12,0x347,0x344,0x34c,0x50041,0xbb, + 0x3ae,0xb3,0x101,0x4003d,0x2d,0x3af,0x3ae,0x50051,0x6,0x3a6,0x3af,0x1, + 0x50051,0x6,0x3a9,0x3af,0x0,0x50083,0x6,0x3aa,0x4e5,0x3a9,0x50088,0x6, + 0x3ab,0x3a6,0x3aa,0x50041,0xc7,0x3b2,0xb3,0x51d,0x4003d,0x6,0x3b3,0x3b2, + 0x50085,0x6,0x3a0,0x3ab,0x3b3,0x7000c,0x6,0x3b8,0x1,0x25,0x3a0,0x18d, + 0x50085,0x6,0x3c0,0x3b8,0x50c,0x8000c,0x6,0x3c6,0x1,0x2b,0x3c0,0x99, + 0x9a,0x8000c,0x6,0x3cc,0x1,0x2e,0x113,0x114,0x3c6,0x50085,0x12,0x3d0, + 0x347,0x123,0x6000c,0x6,0x3d1,0x1,0x42,0x3d0,0x500ba,0x65,0x36a,0x3d1, + 0x3cc,0x600a9,0x6,0x36b,0x36a,0x9a,0x99,0x5008e,0x12,0x36d,0x347,0x36b, + 0x4006f,0x12,0x36f,0x286,0x50081,0x12,0x371,0x36f,0x153,0x50041,0xb5,0x3d4, + 0xb3,0xb4,0x4003d,0x29,0x3d5,0x3d4,0x4006f,0x12,0x373,0x3d5,0x50088,0x12, + 0x374,0x371,0x373,0x50081,0x12,0x377,0x374,0x36d,0x50085,0x12,0x3e3,0x377, + 0x373,0x50083,0x12,0x3e4,0x3e3,0x153,0x6000c,0x12,0x3e6,0x1,0x8,0x3e4, + 0x4006e,0x29,0x3e7,0x3e6,0x6000c,0x12,0x40f,0x1,0xa,0x3e4,0x50051,0x6, + 0x3f0,0x40f,0x0,0x50083,0x6,0x3f1,0x9a,0x3f0,0x50051,0x6,0x3f3,0x40f, + 0x1,0x50083,0x6,0x3f4,0x9a,0x3f3,0x50085,0x6,0x3f5,0x3f1,0x3f4,0x50085, + 0x6,0x3fc,0x3f0,0x3f4,0x50085,0x6,0x403,0x3f1,0x3f3,0x50085,0x6,0x409, + 0x3f0,0x3f3,0x70050,0x74,0x4df,0x3f5,0x3fc,0x403,0x409,0x3003e,0x491,0x50b, + 0x3003e,0x492,0x4df,0x200f9,0x37b,0x200f8,0x37b,0x700f5,0x28,0x4e8,0xb4,0x318, + 0x398,0x396,0x500b1,0x65,0x37e,0x4e8,0x1b7,0x400f6,0x399,0x396,0x0,0x400fa, + 0x37e,0x37f,0x399,0x200f8,0x37f,0x50041,0x37,0x497,0x491,0x4e8,0x4003d,0x29, + 0x382,0x497,0x50041,0x7,0x498,0x492,0x4e8,0x4003d,0x6,0x385,0x498,0x500ba, + 0x65,0x387,0x385,0x1c2,0x300f7,0x395,0x0,0x400fa,0x387,0x388,0x395,0x200f8, + 0x388,0x50080,0x29,0x38c,0x3e7,0x382,0x4007c,0x131,0x417,0x38c,0x4007c,0x131, + 0x419,0x3d5,0x500b0,0x135,0x41a,0x417,0x419,0x4009b,0x65,0x41b,0x41a,0x300f7, + 0x394,0x0,0x400fa,0x41b,0x390,0x394,0x200f8,0x390,0x4007c,0x71,0x41f,0x4e5, + 0x6003c,0xff,0x422,0xfc,0x38c,0xd2,0x700ed,0x71,0x423,0x422,0x101,0xd2, + 0x41f,0x200f9,0x394,0x200f8,0x394,0x200f9,0x395,0x200f8,0x395,0x200f9,0x396,0x200f8, + 0x396,0x50080,0x28,0x398,0x4e8,0x162,0x200f9,0x37b,0x200f8,0x399,0x4003d,0x10a, + 0x425,0x10c,0x50051,0x6,0x428,0x347,0x0,0x50051,0x6,0x429,0x347,0x1, + 0x70050,0x2d,0x42a,0x428,0x429,0x99,0x99,0x40063,0x425,0x286,0x42a,0x4003d, + 0x103,0x42c,0x105,0x70050,0x2d,0x42f,0x4e5,0x99,0x99,0x99,0x40063,0x42c, + 0x286,0x42f,0x50083,0x6,0x440,0x4e3,0x3a9,0x50088,0x6,0x441,0x3a6,0x440, + 0x50085,0x6,0x436,0x441,0x3b3,0x7000c,0x6,0x44e,0x1,0x25,0x436,0x18d, + 0x4003d,0xea,0x450,0xec,0x70050,0x2d,0x453,0x44e,0x99,0x99,0x99,0x40063, + 0x450,0x286,0x453,0x4003d,0xcc,0x464,0xd6,0x7005f,0x2d,0x466,0x464,0x286, + 0x2,0xb4,0x8004f,0x21,0x467,0x466,0x466,0x0,0x1,0x2,0x7000c,0x21, + 0x46c,0x1,0x28,0x241,0x467,0x50094,0x6,0x470,0x46c,0x12c,0x4003d,0xea, + 0x472,0xf1,0x70050,0x2d,0x475,0x470,0x99,0x99,0x99,0x40063,0x472,0x286, + 0x475,0x100fd,0x10038, +}; +static const char *fu1_prepare_inputs_pass_0_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu1_prepare_inputs_pass_0_cb_bind[] = {8}; +static const uint32_t fu1_prepare_inputs_pass_0_cb_count[] = {1}; +static const uint32_t fu1_prepare_inputs_pass_0_cb_space[] = {0}; +static const char *fu1_prepare_inputs_pass_0_srv_tex_names[] = {"r_input_motion_vectors", "r_input_depth", "r_input_color_jittered"}; +static const uint32_t fu1_prepare_inputs_pass_0_srv_tex_bind[] = {0, 1, 2}; +static const uint32_t fu1_prepare_inputs_pass_0_srv_tex_count[] = {1, 1, 1}; +static const uint32_t fu1_prepare_inputs_pass_0_srv_tex_space[] = {0, 0, 0}; +static const char *fu1_prepare_inputs_pass_0_uav_tex_names[] = {"rw_dilated_motion_vectors", "rw_dilated_depth", "rw_reconstructed_previous_nearest_depth", "rw_farthest_depth", "rw_current_luma"}; +static const uint32_t fu1_prepare_inputs_pass_0_uav_tex_bind[] = {3, 4, 5, 6, 7}; +static const uint32_t fu1_prepare_inputs_pass_0_uav_tex_count[] = {1, 1, 1, 1, 1}; +static const uint32_t fu1_prepare_inputs_pass_0_uav_tex_space[] = {0, 0, 0, 0, 0}; + +static const uint32_t fu1_luma_pyramid_pass_0_spv[2504] = { + 0x7230203,0x10500,0x8000b,0x1061,0x0,0x20011,0x1,0x20011,0x9,0x20011,0x31,0x20011, + 0x3d,0x20011,0x44,0x6000b,0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1, + 0xb000f,0x5,0x4,0x6e69616d,0x0,0x109,0x11c,0x126,0x13a,0x144,0x580,0x60010, + 0x4,0x11,0x100,0x1,0x1,0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61, + 0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0,0x80004,0x455f4c47,0x735f5458,0x65646168,0x36315f72, + 0x5f746962,0x726f7473,0x656761,0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d, + 0x79745f63,0x736570,0xd0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63, + 0x5f736570,0x616f6c66,0x363174,0xd0004,0x455f4c47,0x735f5458,0x65646168,0x75735f72,0x6f726762,0x655f7075,0x6e657478,0x5f646564, + 0x65707974,0x6c665f73,0x3174616f,0x36,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f, + 0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669,0x90004,0x4b5f4c47, + 0x735f5248,0x65646168,0x75735f72,0x6f726762,0x625f7075,0x63697361,0x0,0x80004,0x4b5f4c47,0x735f5248,0x65646168,0x75735f72, + 0x6f726762,0x715f7075,0x646175,0x40005,0x4,0x6e69616d,0x0,0x40005,0x107,0x50536263,0x745f44,0x50006, + 0x107,0x0,0x7370696d,0x0,0x70006,0x107,0x1,0x576d756e,0x476b726f,0x70756f72,0x73,0x40005, + 0x109,0x50536263,0x44,0x80005,0x11c,0x735f7772,0x675f6470,0x61626f6c,0x74615f6c,0x63696d6f,0x0,0x50005, + 0x126,0x43647073,0x746e756f,0x7265,0x70005,0x13a,0x49647073,0x7265746e,0x6964656d,0x52657461,0x47,0x70005, + 0x144,0x49647073,0x7265746e,0x6964656d,0x42657461,0x41,0x80005,0x580,0x4c5f6c67,0x6c61636f,0x6f766e49,0x69746163, + 0x6e496e6f,0x786564,0x30047,0x107,0x2,0x50048,0x107,0x0,0x23,0x0,0x50048,0x107, + 0x1,0x23,0x4,0x40047,0x109,0x21,0xc,0x40047,0x109,0x22,0x0,0x30047, + 0x11c,0x17,0x40047,0x11c,0x21,0x2,0x40047,0x11c,0x22,0x0,0x40047,0x580, + 0xb,0x1d,0x40047,0x5b4,0xb,0x19,0x20013,0x2,0x30021,0x3,0x2,0x40015, + 0x6,0x20,0x0,0x30016,0x31,0x10,0x40017,0x32,0x31,0x4,0x40015,0x38, + 0x20,0x1,0x40017,0x39,0x38,0x2,0x20014,0x5c,0x40017,0xd2,0x6,0x3, + 0x4002b,0x38,0xe3,0x0,0x4002b,0x6,0xe9,0x2,0x4002b,0x6,0xea,0x3, + 0x4002b,0x6,0xf0,0x1,0x4001e,0x107,0x6,0x6,0x40020,0x108,0x2,0x107, + 0x4003b,0x108,0x109,0x2,0x40020,0x10a,0x2,0x6,0x4002b,0x38,0x10f,0x1, + 0x4002b,0x38,0x114,0x2,0x90019,0x11a,0x6,0x1,0x0,0x0,0x0,0x2, + 0x21,0x40020,0x11b,0x0,0x11a,0x4003b,0x11b,0x11c,0x0,0x5002c,0x39,0x11d, + 0xe3,0xe3,0x4002b,0x6,0x11e,0x0,0x40020,0x11f,0xb,0x6,0x40017,0x123, + 0x6,0x4,0x7002c,0x123,0x124,0x11e,0x11e,0x11e,0x11e,0x40020,0x125,0x4, + 0x6,0x4003b,0x125,0x126,0x4,0x4002b,0x31,0x12f,0x0,0x7002c,0x32,0x130, + 0x12f,0x12f,0x12f,0x12f,0x40017,0x135,0x31,0x2,0x4002b,0x6,0x136,0x10, + 0x4001c,0x137,0x135,0x136,0x4001c,0x138,0x137,0x136,0x40020,0x139,0x4,0x138, + 0x4003b,0x139,0x13a,0x4,0x40020,0x13d,0x4,0x31,0x4003b,0x139,0x144,0x4, + 0x40020,0x154,0x4,0x135,0x4002b,0x31,0x162,0x3400,0x4002b,0x6,0x166,0xd48, + 0x4002b,0x6,0x167,0x108,0x4002b,0x6,0x207,0x40,0x4002b,0x6,0x21f,0x4, + 0x4002b,0x38,0x29d,0x3,0x4002b,0x6,0x2f0,0x8,0x4002b,0x6,0x4a7,0x7, + 0x4002b,0x38,0x511,0x6,0x4002b,0x38,0x51a,0x7,0x40020,0x57f,0x1,0x6, + 0x4003b,0x57f,0x580,0x1,0x4002b,0x6,0x5b3,0x100,0x6002c,0xd2,0x5b4,0x5b3, + 0xf0,0xf0,0x4002b,0x6,0x105b,0x5,0x4002b,0x6,0x105d,0x9,0x4002b,0x6, + 0x105e,0xa,0x4002b,0x6,0x105f,0xb,0x5002c,0x135,0x1060,0x12f,0x12f,0x50036, + 0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003d,0x6,0x584,0x580,0x50041,0x10a, + 0x5d6,0x109,0xe3,0x4003d,0x6,0x5d7,0x5d6,0x50041,0x10a,0x5da,0x109,0x10f, + 0x4003d,0x6,0x5db,0x5da,0x300f7,0x646,0x0,0x300fb,0x11e,0x610,0x200f8,0x610, + 0x50089,0x6,0x612,0x584,0x207,0x600cb,0x6,0x669,0x612,0x114,0x29d,0x700c9, + 0x6,0x670,0x669,0x612,0xe3,0x10f,0x600cb,0x6,0x678,0x612,0x29d,0x29d, + 0x600cb,0x6,0x680,0x612,0x10f,0x114,0x700c9,0x6,0x687,0x678,0x680,0xe3, + 0x114,0x500c2,0x6,0x617,0x584,0x511,0x50089,0x6,0x618,0x617,0xe9,0x50084, + 0x6,0x619,0x2f0,0x618,0x50080,0x6,0x61a,0x670,0x619,0x500c2,0x6,0x61e, + 0x584,0x51a,0x50084,0x6,0x61f,0x2f0,0x61e,0x50080,0x6,0x620,0x687,0x61f, + 0x300f7,0x7d9,0x0,0x300fb,0x11e,0x6d3,0x200f8,0x6d3,0x500b2,0x5c,0x75d,0x5d7, + 0xf0,0x300f7,0x75f,0x0,0x400fa,0x75d,0x75e,0x75f,0x200f8,0x75e,0x200f9,0x7d9, + 0x200f8,0x75f,0x6016e,0x32,0x922,0xea,0x130,0x11e,0x6016e,0x32,0x924,0xea, + 0x130,0xf0,0x6016e,0x32,0x926,0xea,0x130,0xe9,0x50081,0x32,0x932,0x922, + 0x924,0x50081,0x32,0x934,0x932,0x926,0x5008e,0x32,0x935,0x934,0x162,0x6016e, + 0x32,0x942,0xea,0x130,0x11e,0x6016e,0x32,0x944,0xea,0x130,0xf0,0x6016e, + 0x32,0x946,0xea,0x130,0xe9,0x50081,0x32,0x952,0x942,0x944,0x50081,0x32, + 0x954,0x952,0x946,0x5008e,0x32,0x955,0x954,0x162,0x6016e,0x32,0x962,0xea, + 0x130,0x11e,0x6016e,0x32,0x964,0xea,0x130,0xf0,0x6016e,0x32,0x966,0xea, + 0x130,0xe9,0x50081,0x32,0x972,0x962,0x964,0x50081,0x32,0x974,0x972,0x966, + 0x5008e,0x32,0x975,0x974,0x162,0x6016e,0x32,0x982,0xea,0x130,0x11e,0x6016e, + 0x32,0x984,0xea,0x130,0xf0,0x6016e,0x32,0x986,0xea,0x130,0xe9,0x50081, + 0x32,0x992,0x982,0x984,0x50081,0x32,0x994,0x992,0x986,0x5008e,0x32,0x995, + 0x994,0x162,0x50089,0x6,0x771,0x584,0x21f,0x500aa,0x5c,0x772,0x771,0x11e, + 0x300f7,0x7d8,0x0,0x400fa,0x772,0x773,0x7d8,0x200f8,0x773,0x50086,0x6,0x785, + 0x61a,0xe9,0x50086,0x6,0x787,0x620,0xe9,0x7004f,0x135,0x99b,0x935,0x935, + 0x0,0x1,0x60041,0x154,0x99c,0x13a,0x785,0x787,0x3003e,0x99c,0x99b,0x7004f, + 0x135,0x9a0,0x935,0x935,0x2,0x3,0x60041,0x154,0x9a1,0x144,0x785,0x787, + 0x3003e,0x9a1,0x9a0,0x50080,0x6,0x79e,0x785,0x2f0,0x7004f,0x135,0x9a7,0x955, + 0x955,0x0,0x1,0x60041,0x154,0x9a8,0x13a,0x79e,0x787,0x3003e,0x9a8,0x9a7, + 0x7004f,0x135,0x9ac,0x955,0x955,0x2,0x3,0x60041,0x154,0x9ad,0x144,0x79e, + 0x787,0x3003e,0x9ad,0x9ac,0x50080,0x6,0x7b9,0x787,0x2f0,0x7004f,0x135,0x9b3, + 0x975,0x975,0x0,0x1,0x60041,0x154,0x9b4,0x13a,0x785,0x7b9,0x3003e,0x9b4, + 0x9b3,0x7004f,0x135,0x9b8,0x975,0x975,0x2,0x3,0x60041,0x154,0x9b9,0x144, + 0x785,0x7b9,0x3003e,0x9b9,0x9b8,0x7004f,0x135,0x9bf,0x995,0x995,0x0,0x1, + 0x60041,0x154,0x9c0,0x13a,0x79e,0x7b9,0x3003e,0x9c0,0x9bf,0x7004f,0x135,0x9c4, + 0x995,0x995,0x2,0x3,0x60041,0x154,0x9c5,0x144,0x79e,0x7b9,0x3003e,0x9c5, + 0x9c4,0x200f9,0x7d8,0x200f8,0x7d8,0x200f9,0x7d9,0x200f8,0x7d9,0x300f7,0xa17,0x0, + 0x300fb,0x11e,0x9de,0x200f8,0x9de,0x500b2,0x5c,0x9e1,0x5d7,0xe9,0x300f7,0x9e3, + 0x0,0x400fa,0x9e1,0x9e2,0x9e3,0x200f8,0x9e2,0x200f9,0xa17,0x200f8,0x9e3,0x300e1, + 0xe9,0x166,0x400e0,0xe9,0xe9,0x167,0x70041,0x13d,0xa4b,0x13a,0x61a,0x620, + 0x11e,0x4003d,0x31,0xa4c,0xa4b,0x70041,0x13d,0xa4f,0x13a,0x61a,0x620,0xf0, + 0x4003d,0x31,0xa50,0xa4f,0x70041,0x13d,0xa53,0x144,0x61a,0x620,0x11e,0x4003d, + 0x31,0xa54,0xa53,0x70041,0x13d,0xa57,0x144,0x61a,0x620,0xf0,0x4003d,0x31, + 0xa58,0xa57,0x70050,0x32,0xa59,0xa4c,0xa50,0xa54,0xa58,0x6016e,0x32,0xa66, + 0xea,0xa59,0x11e,0x6016e,0x32,0xa68,0xea,0xa59,0xf0,0x6016e,0x32,0xa6a, + 0xea,0xa59,0xe9,0x50081,0x32,0xa74,0xa59,0xa66,0x50081,0x32,0xa76,0xa74, + 0xa68,0x50081,0x32,0xa78,0xa76,0xa6a,0x5008e,0x32,0xa79,0xa78,0x162,0x50089, + 0x6,0xa2b,0x584,0x21f,0x500aa,0x5c,0xa2c,0xa2b,0x11e,0x300f7,0xa46,0x0, + 0x400fa,0xa2c,0xa2d,0xa46,0x200f8,0xa2d,0x50086,0x6,0xa40,0x620,0xe9,0x50089, + 0x6,0xa41,0xa40,0xe9,0x50080,0x6,0xa42,0x61a,0xa41,0x7004f,0x135,0xa7f, + 0xa79,0xa79,0x0,0x1,0x60041,0x154,0xa80,0x13a,0xa42,0x620,0x3003e,0xa80, + 0xa7f,0x7004f,0x135,0xa84,0xa79,0xa79,0x2,0x3,0x60041,0x154,0xa85,0x144, + 0xa42,0x620,0x3003e,0xa85,0xa84,0x200f9,0xa46,0x200f8,0xa46,0x500b2,0x5c,0x9ef, + 0x5d7,0xea,0x300f7,0x9f1,0x0,0x400fa,0x9ef,0x9f0,0x9f1,0x200f8,0x9f0,0x200f9, + 0xa17,0x200f8,0x9f1,0x300e1,0xe9,0x166,0x400e0,0xe9,0xe9,0x167,0x500b0,0x5c, + 0xa94,0x584,0x207,0x300f7,0xabe,0x0,0x400fa,0xa94,0xa95,0xabe,0x200f8,0xa95, + 0x50084,0x6,0xa97,0x61a,0xe9,0x50089,0x6,0xa99,0x620,0xe9,0x50080,0x6, + 0xa9a,0xa97,0xa99,0x50084,0x6,0xa9c,0x620,0xe9,0x70041,0x13d,0xac3,0x13a, + 0xa9a,0xa9c,0x11e,0x4003d,0x31,0xac4,0xac3,0x70041,0x13d,0xac7,0x13a,0xa9a, + 0xa9c,0xf0,0x4003d,0x31,0xac8,0xac7,0x70041,0x13d,0xacb,0x144,0xa9a,0xa9c, + 0x11e,0x4003d,0x31,0xacc,0xacb,0x70041,0x13d,0xacf,0x144,0xa9a,0xa9c,0xf0, + 0x4003d,0x31,0xad0,0xacf,0x70050,0x32,0xad1,0xac4,0xac8,0xacc,0xad0,0x6016e, + 0x32,0xade,0xea,0xad1,0x11e,0x6016e,0x32,0xae0,0xea,0xad1,0xf0,0x6016e, + 0x32,0xae2,0xea,0xad1,0xe9,0x50081,0x32,0xaec,0xad1,0xade,0x50081,0x32, + 0xaee,0xaec,0xae0,0x50081,0x32,0xaf0,0xaee,0xae2,0x5008e,0x32,0xaf1,0xaf0, + 0x162,0x300f7,0xabd,0x0,0x400fa,0xa2c,0xaa3,0xabd,0x200f8,0xaa3,0x50086,0x6, + 0xab7,0x620,0xe9,0x50080,0x6,0xab8,0xa97,0xab7,0x7004f,0x135,0xaf7,0xaf1, + 0xaf1,0x0,0x1,0x60041,0x154,0xaf8,0x13a,0xab8,0xa9c,0x3003e,0xaf8,0xaf7, + 0x7004f,0x135,0xafc,0xaf1,0xaf1,0x2,0x3,0x60041,0x154,0xafd,0x144,0xab8, + 0xa9c,0x3003e,0xafd,0xafc,0x200f9,0xabd,0x200f8,0xabd,0x200f9,0xabe,0x200f8,0xabe, + 0x500b2,0x5c,0x9fe,0x5d7,0x21f,0x300f7,0xa00,0x0,0x400fa,0x9fe,0x9ff,0xa00, + 0x200f8,0x9ff,0x200f9,0xa17,0x200f8,0xa00,0x300e1,0xe9,0x166,0x400e0,0xe9,0xe9, + 0x167,0x500b0,0x5c,0xb0c,0x584,0x136,0x300f7,0xb32,0x0,0x400fa,0xb0c,0xb0d, + 0xb32,0x200f8,0xb0d,0x50084,0x6,0xb0f,0x61a,0x21f,0x50080,0x6,0xb11,0xb0f, + 0x620,0x50084,0x6,0xb13,0x620,0x21f,0x70041,0x13d,0xb37,0x13a,0xb11,0xb13, + 0x11e,0x4003d,0x31,0xb38,0xb37,0x70041,0x13d,0xb3b,0x13a,0xb11,0xb13,0xf0, + 0x4003d,0x31,0xb3c,0xb3b,0x70041,0x13d,0xb3f,0x144,0xb11,0xb13,0x11e,0x4003d, + 0x31,0xb40,0xb3f,0x70041,0x13d,0xb43,0x144,0xb11,0xb13,0xf0,0x4003d,0x31, + 0xb44,0xb43,0x70050,0x32,0xb45,0xb38,0xb3c,0xb40,0xb44,0x6016e,0x32,0xb52, + 0xea,0xb45,0x11e,0x6016e,0x32,0xb54,0xea,0xb45,0xf0,0x6016e,0x32,0xb56, + 0xea,0xb45,0xe9,0x50081,0x32,0xb60,0xb45,0xb52,0x50081,0x32,0xb62,0xb60, + 0xb54,0x50081,0x32,0xb64,0xb62,0xb56,0x5008e,0x32,0xb65,0xb64,0x162,0x300f7, + 0xb31,0x0,0x400fa,0xa2c,0xb1a,0xb31,0x200f8,0xb1a,0x50086,0x6,0xb2c,0x61a, + 0xe9,0x50080,0x6,0xb2e,0xb2c,0x620,0x7004f,0x135,0xb6b,0xb65,0xb65,0x0, + 0x1,0x60041,0x154,0xb6c,0x13a,0xb2e,0x11e,0x3003e,0xb6c,0xb6b,0x7004f,0x135, + 0xb70,0xb65,0xb65,0x2,0x3,0x60041,0x154,0xb71,0x144,0xb2e,0x11e,0x3003e, + 0xb71,0xb70,0x200f9,0xb31,0x200f8,0xb31,0x200f9,0xb32,0x200f8,0xb32,0x500b2,0x5c, + 0xa0d,0x5d7,0x105b,0x300f7,0xa0f,0x0,0x400fa,0xa0d,0xa0e,0xa0f,0x200f8,0xa0e, + 0x200f9,0xa17,0x200f8,0xa0f,0x300e1,0xe9,0x166,0x400e0,0xe9,0xe9,0x167,0x500b0, + 0x5c,0xb7d,0x584,0x21f,0x300f7,0xb8e,0x0,0x400fa,0xb7d,0xb7e,0xb8e,0x200f8, + 0xb7e,0x70041,0x13d,0xb93,0x13a,0x584,0x11e,0x11e,0x4003d,0x31,0xb94,0xb93, + 0x70041,0x13d,0xb97,0x13a,0x584,0x11e,0xf0,0x4003d,0x31,0xb98,0xb97,0x70041, + 0x13d,0xb9b,0x144,0x584,0x11e,0x11e,0x4003d,0x31,0xb9c,0xb9b,0x70041,0x13d, + 0xb9f,0x144,0x584,0x11e,0xf0,0x4003d,0x31,0xba0,0xb9f,0x70050,0x32,0xba1, + 0xb94,0xb98,0xb9c,0xba0,0x6016e,0x32,0xbae,0xea,0xba1,0x11e,0x6016e,0x32, + 0xbb0,0xea,0xba1,0xf0,0x6016e,0x32,0xbb2,0xea,0xba1,0xe9,0x200f9,0xb8e, + 0x200f8,0xb8e,0x200f9,0xa17,0x200f8,0xa17,0x500b0,0x5c,0x630,0x5d7,0x4a7,0x300f7, + 0x632,0x0,0x400fa,0x630,0x631,0x632,0x200f8,0x631,0x200f9,0x646,0x200f8,0x632, + 0x500aa,0x5c,0xbc7,0x584,0x11e,0x300f7,0xbcb,0x0,0x400fa,0xbc7,0xbc8,0xbcb, + 0x200f8,0xbc8,0x6003c,0x11f,0xbd7,0x11c,0x11d,0x11e,0x700ea,0x6,0xbd8,0xbd7, + 0xf0,0x11e,0xf0,0x3003e,0x126,0xbd8,0x200f9,0xbcb,0x200f8,0xbcb,0x300e1,0xe9, + 0x166,0x400e0,0xe9,0xe9,0x167,0x4003d,0x6,0xbdc,0x126,0x50082,0x6,0xbcf, + 0x5db,0xf0,0x500ab,0x5c,0xbd0,0xbdc,0xbcf,0x300f7,0x638,0x0,0x400fa,0xbd0, + 0x637,0x638,0x200f8,0x637,0x200f9,0x646,0x200f8,0x638,0x4003d,0x11a,0xbe0,0x11c, + 0x50063,0xbe0,0x11d,0x124,0x2000,0x300f7,0xc8b,0x0,0x300fb,0x11e,0xc0d,0x200f8, + 0xc0d,0x500b0,0x5c,0xc77,0x5d7,0x2f0,0x300f7,0xc79,0x0,0x400fa,0xc77,0xc78, + 0xc79,0x200f8,0xc78,0x200f9,0xc8b,0x200f8,0xc79,0x60041,0x154,0xdc8,0x13a,0x61a, + 0x620,0x3003e,0xdc8,0x1060,0x60041,0x154,0xdcd,0x144,0x61a,0x620,0x3003e,0xdcd, + 0x1060,0x200f9,0xc8b,0x200f8,0xc8b,0x300f7,0xe1f,0x0,0x300fb,0x11e,0xde6,0x200f8, + 0xde6,0x500b2,0x5c,0xde9,0x5d7,0x2f0,0x300f7,0xdeb,0x0,0x400fa,0xde9,0xdea, + 0xdeb,0x200f8,0xdea,0x200f9,0xe1f,0x200f8,0xdeb,0x300e1,0xe9,0x166,0x400e0,0xe9, + 0xe9,0x167,0x70041,0x13d,0xe53,0x13a,0x61a,0x620,0x11e,0x4003d,0x31,0xe54, + 0xe53,0x70041,0x13d,0xe57,0x13a,0x61a,0x620,0xf0,0x4003d,0x31,0xe58,0xe57, + 0x70041,0x13d,0xe5b,0x144,0x61a,0x620,0x11e,0x4003d,0x31,0xe5c,0xe5b,0x70041, + 0x13d,0xe5f,0x144,0x61a,0x620,0xf0,0x4003d,0x31,0xe60,0xe5f,0x70050,0x32, + 0xe61,0xe54,0xe58,0xe5c,0xe60,0x6016e,0x32,0xe6e,0xea,0xe61,0x11e,0x6016e, + 0x32,0xe70,0xea,0xe61,0xf0,0x6016e,0x32,0xe72,0xea,0xe61,0xe9,0x50081, + 0x32,0xe7c,0xe61,0xe6e,0x50081,0x32,0xe7e,0xe7c,0xe70,0x50081,0x32,0xe80, + 0xe7e,0xe72,0x5008e,0x32,0xe81,0xe80,0x162,0x50089,0x6,0xe33,0x584,0x21f, + 0x500aa,0x5c,0xe34,0xe33,0x11e,0x300f7,0xe4e,0x0,0x400fa,0xe34,0xe35,0xe4e, + 0x200f8,0xe35,0x50086,0x6,0xe48,0x620,0xe9,0x50089,0x6,0xe49,0xe48,0xe9, + 0x50080,0x6,0xe4a,0x61a,0xe49,0x7004f,0x135,0xe87,0xe81,0xe81,0x0,0x1, + 0x60041,0x154,0xe88,0x13a,0xe4a,0x620,0x3003e,0xe88,0xe87,0x7004f,0x135,0xe8c, + 0xe81,0xe81,0x2,0x3,0x60041,0x154,0xe8d,0x144,0xe4a,0x620,0x3003e,0xe8d, + 0xe8c,0x200f9,0xe4e,0x200f8,0xe4e,0x500b2,0x5c,0xdf7,0x5d7,0x105d,0x300f7,0xdf9, + 0x0,0x400fa,0xdf7,0xdf8,0xdf9,0x200f8,0xdf8,0x200f9,0xe1f,0x200f8,0xdf9,0x300e1, + 0xe9,0x166,0x400e0,0xe9,0xe9,0x167,0x500b0,0x5c,0xe9c,0x584,0x207,0x300f7, + 0xec6,0x0,0x400fa,0xe9c,0xe9d,0xec6,0x200f8,0xe9d,0x50084,0x6,0xe9f,0x61a, + 0xe9,0x50089,0x6,0xea1,0x620,0xe9,0x50080,0x6,0xea2,0xe9f,0xea1,0x50084, + 0x6,0xea4,0x620,0xe9,0x70041,0x13d,0xecb,0x13a,0xea2,0xea4,0x11e,0x4003d, + 0x31,0xecc,0xecb,0x70041,0x13d,0xecf,0x13a,0xea2,0xea4,0xf0,0x4003d,0x31, + 0xed0,0xecf,0x70041,0x13d,0xed3,0x144,0xea2,0xea4,0x11e,0x4003d,0x31,0xed4, + 0xed3,0x70041,0x13d,0xed7,0x144,0xea2,0xea4,0xf0,0x4003d,0x31,0xed8,0xed7, + 0x70050,0x32,0xed9,0xecc,0xed0,0xed4,0xed8,0x6016e,0x32,0xee6,0xea,0xed9, + 0x11e,0x6016e,0x32,0xee8,0xea,0xed9,0xf0,0x6016e,0x32,0xeea,0xea,0xed9, + 0xe9,0x50081,0x32,0xef4,0xed9,0xee6,0x50081,0x32,0xef6,0xef4,0xee8,0x50081, + 0x32,0xef8,0xef6,0xeea,0x5008e,0x32,0xef9,0xef8,0x162,0x300f7,0xec5,0x0, + 0x400fa,0xe34,0xeab,0xec5,0x200f8,0xeab,0x50086,0x6,0xebf,0x620,0xe9,0x50080, + 0x6,0xec0,0xe9f,0xebf,0x7004f,0x135,0xeff,0xef9,0xef9,0x0,0x1,0x60041, + 0x154,0xf00,0x13a,0xec0,0xea4,0x3003e,0xf00,0xeff,0x7004f,0x135,0xf04,0xef9, + 0xef9,0x2,0x3,0x60041,0x154,0xf05,0x144,0xec0,0xea4,0x3003e,0xf05,0xf04, + 0x200f9,0xec5,0x200f8,0xec5,0x200f9,0xec6,0x200f8,0xec6,0x500b2,0x5c,0xe06,0x5d7, + 0x105e,0x300f7,0xe08,0x0,0x400fa,0xe06,0xe07,0xe08,0x200f8,0xe07,0x200f9,0xe1f, + 0x200f8,0xe08,0x300e1,0xe9,0x166,0x400e0,0xe9,0xe9,0x167,0x500b0,0x5c,0xf14, + 0x584,0x136,0x300f7,0xf3a,0x0,0x400fa,0xf14,0xf15,0xf3a,0x200f8,0xf15,0x50084, + 0x6,0xf17,0x61a,0x21f,0x50080,0x6,0xf19,0xf17,0x620,0x50084,0x6,0xf1b, + 0x620,0x21f,0x70041,0x13d,0xf3f,0x13a,0xf19,0xf1b,0x11e,0x4003d,0x31,0xf40, + 0xf3f,0x70041,0x13d,0xf43,0x13a,0xf19,0xf1b,0xf0,0x4003d,0x31,0xf44,0xf43, + 0x70041,0x13d,0xf47,0x144,0xf19,0xf1b,0x11e,0x4003d,0x31,0xf48,0xf47,0x70041, + 0x13d,0xf4b,0x144,0xf19,0xf1b,0xf0,0x4003d,0x31,0xf4c,0xf4b,0x70050,0x32, + 0xf4d,0xf40,0xf44,0xf48,0xf4c,0x6016e,0x32,0xf5a,0xea,0xf4d,0x11e,0x6016e, + 0x32,0xf5c,0xea,0xf4d,0xf0,0x6016e,0x32,0xf5e,0xea,0xf4d,0xe9,0x50081, + 0x32,0xf68,0xf4d,0xf5a,0x50081,0x32,0xf6a,0xf68,0xf5c,0x50081,0x32,0xf6c, + 0xf6a,0xf5e,0x5008e,0x32,0xf6d,0xf6c,0x162,0x300f7,0xf39,0x0,0x400fa,0xe34, + 0xf22,0xf39,0x200f8,0xf22,0x50086,0x6,0xf34,0x61a,0xe9,0x50080,0x6,0xf36, + 0xf34,0x620,0x7004f,0x135,0xf73,0xf6d,0xf6d,0x0,0x1,0x60041,0x154,0xf74, + 0x13a,0xf36,0x11e,0x3003e,0xf74,0xf73,0x7004f,0x135,0xf78,0xf6d,0xf6d,0x2, + 0x3,0x60041,0x154,0xf79,0x144,0xf36,0x11e,0x3003e,0xf79,0xf78,0x200f9,0xf39, + 0x200f8,0xf39,0x200f9,0xf3a,0x200f8,0xf3a,0x500b2,0x5c,0xe15,0x5d7,0x105f,0x300f7, + 0xe17,0x0,0x400fa,0xe15,0xe16,0xe17,0x200f8,0xe16,0x200f9,0xe1f,0x200f8,0xe17, + 0x300e1,0xe9,0x166,0x400e0,0xe9,0xe9,0x167,0x500b0,0x5c,0xf85,0x584,0x21f, + 0x300f7,0xf96,0x0,0x400fa,0xf85,0xf86,0xf96,0x200f8,0xf86,0x70041,0x13d,0xf9b, + 0x13a,0x584,0x11e,0x11e,0x4003d,0x31,0xf9c,0xf9b,0x70041,0x13d,0xf9f,0x13a, + 0x584,0x11e,0xf0,0x4003d,0x31,0xfa0,0xf9f,0x70041,0x13d,0xfa3,0x144,0x584, + 0x11e,0x11e,0x4003d,0x31,0xfa4,0xfa3,0x70041,0x13d,0xfa7,0x144,0x584,0x11e, + 0xf0,0x4003d,0x31,0xfa8,0xfa7,0x70050,0x32,0xfa9,0xf9c,0xfa0,0xfa4,0xfa8, + 0x6016e,0x32,0xfb6,0xea,0xfa9,0x11e,0x6016e,0x32,0xfb8,0xea,0xfa9,0xf0, + 0x6016e,0x32,0xfba,0xea,0xfa9,0xe9,0x200f9,0xf96,0x200f8,0xf96,0x200f9,0xe1f, + 0x200f8,0xe1f,0x200f9,0x646,0x200f8,0x646,0x100fd,0x10038, +}; +static const char *fu1_luma_pyramid_pass_0_cb_names[] = {"cbSPD"}; +static const uint32_t fu1_luma_pyramid_pass_0_cb_bind[] = {12}; +static const uint32_t fu1_luma_pyramid_pass_0_cb_count[] = {1}; +static const uint32_t fu1_luma_pyramid_pass_0_cb_space[] = {0}; +static const char *fu1_luma_pyramid_pass_0_uav_tex_names[] = {"rw_spd_global_atomic"}; +static const uint32_t fu1_luma_pyramid_pass_0_uav_tex_bind[] = {2}; +static const uint32_t fu1_luma_pyramid_pass_0_uav_tex_count[] = {1}; +static const uint32_t fu1_luma_pyramid_pass_0_uav_tex_space[] = {0}; + +static const uint32_t fu1_shading_change_pyramid_pass_0_spv[2504] = { + 0x7230203,0x10500,0x8000b,0x1064,0x0,0x20011,0x1,0x20011,0x9,0x20011,0x31,0x20011, + 0x3d,0x20011,0x44,0x6000b,0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1, + 0xb000f,0x5,0x4,0x6e69616d,0x0,0x109,0x11c,0x126,0x13a,0x144,0x580,0x60010, + 0x4,0x11,0x100,0x1,0x1,0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61, + 0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0,0x80004,0x455f4c47,0x735f5458,0x65646168,0x36315f72, + 0x5f746962,0x726f7473,0x656761,0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d, + 0x79745f63,0x736570,0xd0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63, + 0x5f736570,0x616f6c66,0x363174,0xd0004,0x455f4c47,0x735f5458,0x65646168,0x75735f72,0x6f726762,0x655f7075,0x6e657478,0x5f646564, + 0x65707974,0x6c665f73,0x3174616f,0x36,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f, + 0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669,0x90004,0x4b5f4c47, + 0x735f5248,0x65646168,0x75735f72,0x6f726762,0x625f7075,0x63697361,0x0,0x80004,0x4b5f4c47,0x735f5248,0x65646168,0x75735f72, + 0x6f726762,0x715f7075,0x646175,0x40005,0x4,0x6e69616d,0x0,0x40005,0x107,0x50536263,0x745f44,0x50006, + 0x107,0x0,0x7370696d,0x0,0x70006,0x107,0x1,0x576d756e,0x476b726f,0x70756f72,0x73,0x40005, + 0x109,0x50536263,0x44,0x80005,0x11c,0x735f7772,0x675f6470,0x61626f6c,0x74615f6c,0x63696d6f,0x0,0x50005, + 0x126,0x43647073,0x746e756f,0x7265,0x70005,0x13a,0x49647073,0x7265746e,0x6964656d,0x52657461,0x47,0x70005, + 0x144,0x49647073,0x7265746e,0x6964656d,0x42657461,0x41,0x80005,0x580,0x4c5f6c67,0x6c61636f,0x6f766e49,0x69746163, + 0x6e496e6f,0x786564,0x30047,0x107,0x2,0x50048,0x107,0x0,0x23,0x0,0x50048,0x107, + 0x1,0x23,0x4,0x40047,0x109,0x21,0xc,0x40047,0x109,0x22,0x0,0x30047, + 0x11c,0x17,0x40047,0x11c,0x21,0x4,0x40047,0x11c,0x22,0x0,0x40047,0x580, + 0xb,0x1d,0x40047,0x5b8,0xb,0x19,0x20013,0x2,0x30021,0x3,0x2,0x40015, + 0x6,0x20,0x0,0x30016,0x31,0x10,0x40017,0x32,0x31,0x4,0x40015,0x38, + 0x20,0x1,0x40017,0x39,0x38,0x2,0x20014,0x5c,0x40017,0xd2,0x6,0x3, + 0x4002b,0x38,0xe3,0x0,0x4002b,0x6,0xe9,0x2,0x4002b,0x6,0xea,0x3, + 0x4002b,0x6,0xf0,0x1,0x4001e,0x107,0x6,0x6,0x40020,0x108,0x2,0x107, + 0x4003b,0x108,0x109,0x2,0x40020,0x10a,0x2,0x6,0x4002b,0x38,0x10f,0x1, + 0x4002b,0x38,0x114,0x2,0x90019,0x11a,0x6,0x1,0x0,0x0,0x0,0x2, + 0x21,0x40020,0x11b,0x0,0x11a,0x4003b,0x11b,0x11c,0x0,0x5002c,0x39,0x11d, + 0xe3,0xe3,0x4002b,0x6,0x11e,0x0,0x40020,0x11f,0xb,0x6,0x40017,0x123, + 0x6,0x4,0x7002c,0x123,0x124,0x11e,0x11e,0x11e,0x11e,0x40020,0x125,0x4, + 0x6,0x4003b,0x125,0x126,0x4,0x4002b,0x31,0x12f,0x0,0x7002c,0x32,0x130, + 0x12f,0x12f,0x12f,0x12f,0x40017,0x135,0x31,0x2,0x4002b,0x6,0x136,0x10, + 0x4001c,0x137,0x135,0x136,0x4001c,0x138,0x137,0x136,0x40020,0x139,0x4,0x138, + 0x4003b,0x139,0x13a,0x4,0x40020,0x13d,0x4,0x31,0x4003b,0x139,0x144,0x4, + 0x40020,0x154,0x4,0x135,0x4002b,0x31,0x162,0x3400,0x4002b,0x6,0x166,0xd48, + 0x4002b,0x6,0x167,0x108,0x4002b,0x6,0x207,0x40,0x4002b,0x6,0x21f,0x4, + 0x4002b,0x38,0x29d,0x3,0x4002b,0x6,0x2f0,0x8,0x4002b,0x6,0x4a7,0x7, + 0x4002b,0x38,0x511,0x6,0x4002b,0x38,0x51a,0x7,0x40020,0x57f,0x1,0x6, + 0x4003b,0x57f,0x580,0x1,0x4002b,0x6,0x5af,0x5,0x4002b,0x6,0x5b7,0x100, + 0x6002c,0xd2,0x5b8,0x5b7,0xf0,0xf0,0x4002b,0x6,0x1060,0x9,0x4002b,0x6, + 0x1061,0xa,0x4002b,0x6,0x1062,0xb,0x5002c,0x135,0x1063,0x12f,0x12f,0x50036, + 0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003d,0x6,0x584,0x580,0x50041,0x10a, + 0x5da,0x109,0xe3,0x4003d,0x6,0x5db,0x5da,0x50041,0x10a,0x5de,0x109,0x10f, + 0x4003d,0x6,0x5df,0x5de,0x300f7,0x64a,0x0,0x300fb,0x11e,0x614,0x200f8,0x614, + 0x50089,0x6,0x616,0x584,0x207,0x600cb,0x6,0x66d,0x616,0x114,0x29d,0x700c9, + 0x6,0x674,0x66d,0x616,0xe3,0x10f,0x600cb,0x6,0x67c,0x616,0x29d,0x29d, + 0x600cb,0x6,0x684,0x616,0x10f,0x114,0x700c9,0x6,0x68b,0x67c,0x684,0xe3, + 0x114,0x500c2,0x6,0x61b,0x584,0x511,0x50089,0x6,0x61c,0x61b,0xe9,0x50084, + 0x6,0x61d,0x2f0,0x61c,0x50080,0x6,0x61e,0x674,0x61d,0x500c2,0x6,0x622, + 0x584,0x51a,0x50084,0x6,0x623,0x2f0,0x622,0x50080,0x6,0x624,0x68b,0x623, + 0x300f7,0x7dd,0x0,0x300fb,0x11e,0x6d7,0x200f8,0x6d7,0x500b2,0x5c,0x761,0x5db, + 0xf0,0x300f7,0x763,0x0,0x400fa,0x761,0x762,0x763,0x200f8,0x762,0x200f9,0x7dd, + 0x200f8,0x763,0x6016e,0x32,0x926,0xea,0x130,0x11e,0x6016e,0x32,0x928,0xea, + 0x130,0xf0,0x6016e,0x32,0x92a,0xea,0x130,0xe9,0x50081,0x32,0x936,0x926, + 0x928,0x50081,0x32,0x938,0x936,0x92a,0x5008e,0x32,0x939,0x938,0x162,0x6016e, + 0x32,0x946,0xea,0x130,0x11e,0x6016e,0x32,0x948,0xea,0x130,0xf0,0x6016e, + 0x32,0x94a,0xea,0x130,0xe9,0x50081,0x32,0x956,0x946,0x948,0x50081,0x32, + 0x958,0x956,0x94a,0x5008e,0x32,0x959,0x958,0x162,0x6016e,0x32,0x966,0xea, + 0x130,0x11e,0x6016e,0x32,0x968,0xea,0x130,0xf0,0x6016e,0x32,0x96a,0xea, + 0x130,0xe9,0x50081,0x32,0x976,0x966,0x968,0x50081,0x32,0x978,0x976,0x96a, + 0x5008e,0x32,0x979,0x978,0x162,0x6016e,0x32,0x986,0xea,0x130,0x11e,0x6016e, + 0x32,0x988,0xea,0x130,0xf0,0x6016e,0x32,0x98a,0xea,0x130,0xe9,0x50081, + 0x32,0x996,0x986,0x988,0x50081,0x32,0x998,0x996,0x98a,0x5008e,0x32,0x999, + 0x998,0x162,0x50089,0x6,0x775,0x584,0x21f,0x500aa,0x5c,0x776,0x775,0x11e, + 0x300f7,0x7dc,0x0,0x400fa,0x776,0x777,0x7dc,0x200f8,0x777,0x50086,0x6,0x789, + 0x61e,0xe9,0x50086,0x6,0x78b,0x624,0xe9,0x7004f,0x135,0x99f,0x939,0x939, + 0x0,0x1,0x60041,0x154,0x9a0,0x13a,0x789,0x78b,0x3003e,0x9a0,0x99f,0x7004f, + 0x135,0x9a4,0x939,0x939,0x2,0x3,0x60041,0x154,0x9a5,0x144,0x789,0x78b, + 0x3003e,0x9a5,0x9a4,0x50080,0x6,0x7a2,0x789,0x2f0,0x7004f,0x135,0x9ab,0x959, + 0x959,0x0,0x1,0x60041,0x154,0x9ac,0x13a,0x7a2,0x78b,0x3003e,0x9ac,0x9ab, + 0x7004f,0x135,0x9b0,0x959,0x959,0x2,0x3,0x60041,0x154,0x9b1,0x144,0x7a2, + 0x78b,0x3003e,0x9b1,0x9b0,0x50080,0x6,0x7bd,0x78b,0x2f0,0x7004f,0x135,0x9b7, + 0x979,0x979,0x0,0x1,0x60041,0x154,0x9b8,0x13a,0x789,0x7bd,0x3003e,0x9b8, + 0x9b7,0x7004f,0x135,0x9bc,0x979,0x979,0x2,0x3,0x60041,0x154,0x9bd,0x144, + 0x789,0x7bd,0x3003e,0x9bd,0x9bc,0x7004f,0x135,0x9c3,0x999,0x999,0x0,0x1, + 0x60041,0x154,0x9c4,0x13a,0x7a2,0x7bd,0x3003e,0x9c4,0x9c3,0x7004f,0x135,0x9c8, + 0x999,0x999,0x2,0x3,0x60041,0x154,0x9c9,0x144,0x7a2,0x7bd,0x3003e,0x9c9, + 0x9c8,0x200f9,0x7dc,0x200f8,0x7dc,0x200f9,0x7dd,0x200f8,0x7dd,0x300f7,0xa1b,0x0, + 0x300fb,0x11e,0x9e2,0x200f8,0x9e2,0x500b2,0x5c,0x9e5,0x5db,0xe9,0x300f7,0x9e7, + 0x0,0x400fa,0x9e5,0x9e6,0x9e7,0x200f8,0x9e6,0x200f9,0xa1b,0x200f8,0x9e7,0x300e1, + 0xe9,0x166,0x400e0,0xe9,0xe9,0x167,0x70041,0x13d,0xa4f,0x13a,0x61e,0x624, + 0x11e,0x4003d,0x31,0xa50,0xa4f,0x70041,0x13d,0xa53,0x13a,0x61e,0x624,0xf0, + 0x4003d,0x31,0xa54,0xa53,0x70041,0x13d,0xa57,0x144,0x61e,0x624,0x11e,0x4003d, + 0x31,0xa58,0xa57,0x70041,0x13d,0xa5b,0x144,0x61e,0x624,0xf0,0x4003d,0x31, + 0xa5c,0xa5b,0x70050,0x32,0xa5d,0xa50,0xa54,0xa58,0xa5c,0x6016e,0x32,0xa6a, + 0xea,0xa5d,0x11e,0x6016e,0x32,0xa6c,0xea,0xa5d,0xf0,0x6016e,0x32,0xa6e, + 0xea,0xa5d,0xe9,0x50081,0x32,0xa78,0xa5d,0xa6a,0x50081,0x32,0xa7a,0xa78, + 0xa6c,0x50081,0x32,0xa7c,0xa7a,0xa6e,0x5008e,0x32,0xa7d,0xa7c,0x162,0x50089, + 0x6,0xa2f,0x584,0x21f,0x500aa,0x5c,0xa30,0xa2f,0x11e,0x300f7,0xa4a,0x0, + 0x400fa,0xa30,0xa31,0xa4a,0x200f8,0xa31,0x50086,0x6,0xa44,0x624,0xe9,0x50089, + 0x6,0xa45,0xa44,0xe9,0x50080,0x6,0xa46,0x61e,0xa45,0x7004f,0x135,0xa83, + 0xa7d,0xa7d,0x0,0x1,0x60041,0x154,0xa84,0x13a,0xa46,0x624,0x3003e,0xa84, + 0xa83,0x7004f,0x135,0xa88,0xa7d,0xa7d,0x2,0x3,0x60041,0x154,0xa89,0x144, + 0xa46,0x624,0x3003e,0xa89,0xa88,0x200f9,0xa4a,0x200f8,0xa4a,0x500b2,0x5c,0x9f3, + 0x5db,0xea,0x300f7,0x9f5,0x0,0x400fa,0x9f3,0x9f4,0x9f5,0x200f8,0x9f4,0x200f9, + 0xa1b,0x200f8,0x9f5,0x300e1,0xe9,0x166,0x400e0,0xe9,0xe9,0x167,0x500b0,0x5c, + 0xa98,0x584,0x207,0x300f7,0xac2,0x0,0x400fa,0xa98,0xa99,0xac2,0x200f8,0xa99, + 0x50084,0x6,0xa9b,0x61e,0xe9,0x50089,0x6,0xa9d,0x624,0xe9,0x50080,0x6, + 0xa9e,0xa9b,0xa9d,0x50084,0x6,0xaa0,0x624,0xe9,0x70041,0x13d,0xac7,0x13a, + 0xa9e,0xaa0,0x11e,0x4003d,0x31,0xac8,0xac7,0x70041,0x13d,0xacb,0x13a,0xa9e, + 0xaa0,0xf0,0x4003d,0x31,0xacc,0xacb,0x70041,0x13d,0xacf,0x144,0xa9e,0xaa0, + 0x11e,0x4003d,0x31,0xad0,0xacf,0x70041,0x13d,0xad3,0x144,0xa9e,0xaa0,0xf0, + 0x4003d,0x31,0xad4,0xad3,0x70050,0x32,0xad5,0xac8,0xacc,0xad0,0xad4,0x6016e, + 0x32,0xae2,0xea,0xad5,0x11e,0x6016e,0x32,0xae4,0xea,0xad5,0xf0,0x6016e, + 0x32,0xae6,0xea,0xad5,0xe9,0x50081,0x32,0xaf0,0xad5,0xae2,0x50081,0x32, + 0xaf2,0xaf0,0xae4,0x50081,0x32,0xaf4,0xaf2,0xae6,0x5008e,0x32,0xaf5,0xaf4, + 0x162,0x300f7,0xac1,0x0,0x400fa,0xa30,0xaa7,0xac1,0x200f8,0xaa7,0x50086,0x6, + 0xabb,0x624,0xe9,0x50080,0x6,0xabc,0xa9b,0xabb,0x7004f,0x135,0xafb,0xaf5, + 0xaf5,0x0,0x1,0x60041,0x154,0xafc,0x13a,0xabc,0xaa0,0x3003e,0xafc,0xafb, + 0x7004f,0x135,0xb00,0xaf5,0xaf5,0x2,0x3,0x60041,0x154,0xb01,0x144,0xabc, + 0xaa0,0x3003e,0xb01,0xb00,0x200f9,0xac1,0x200f8,0xac1,0x200f9,0xac2,0x200f8,0xac2, + 0x500b2,0x5c,0xa02,0x5db,0x21f,0x300f7,0xa04,0x0,0x400fa,0xa02,0xa03,0xa04, + 0x200f8,0xa03,0x200f9,0xa1b,0x200f8,0xa04,0x300e1,0xe9,0x166,0x400e0,0xe9,0xe9, + 0x167,0x500b0,0x5c,0xb10,0x584,0x136,0x300f7,0xb36,0x0,0x400fa,0xb10,0xb11, + 0xb36,0x200f8,0xb11,0x50084,0x6,0xb13,0x61e,0x21f,0x50080,0x6,0xb15,0xb13, + 0x624,0x50084,0x6,0xb17,0x624,0x21f,0x70041,0x13d,0xb3b,0x13a,0xb15,0xb17, + 0x11e,0x4003d,0x31,0xb3c,0xb3b,0x70041,0x13d,0xb3f,0x13a,0xb15,0xb17,0xf0, + 0x4003d,0x31,0xb40,0xb3f,0x70041,0x13d,0xb43,0x144,0xb15,0xb17,0x11e,0x4003d, + 0x31,0xb44,0xb43,0x70041,0x13d,0xb47,0x144,0xb15,0xb17,0xf0,0x4003d,0x31, + 0xb48,0xb47,0x70050,0x32,0xb49,0xb3c,0xb40,0xb44,0xb48,0x6016e,0x32,0xb56, + 0xea,0xb49,0x11e,0x6016e,0x32,0xb58,0xea,0xb49,0xf0,0x6016e,0x32,0xb5a, + 0xea,0xb49,0xe9,0x50081,0x32,0xb64,0xb49,0xb56,0x50081,0x32,0xb66,0xb64, + 0xb58,0x50081,0x32,0xb68,0xb66,0xb5a,0x5008e,0x32,0xb69,0xb68,0x162,0x300f7, + 0xb35,0x0,0x400fa,0xa30,0xb1e,0xb35,0x200f8,0xb1e,0x50086,0x6,0xb30,0x61e, + 0xe9,0x50080,0x6,0xb32,0xb30,0x624,0x7004f,0x135,0xb6f,0xb69,0xb69,0x0, + 0x1,0x60041,0x154,0xb70,0x13a,0xb32,0x11e,0x3003e,0xb70,0xb6f,0x7004f,0x135, + 0xb74,0xb69,0xb69,0x2,0x3,0x60041,0x154,0xb75,0x144,0xb32,0x11e,0x3003e, + 0xb75,0xb74,0x200f9,0xb35,0x200f8,0xb35,0x200f9,0xb36,0x200f8,0xb36,0x500b2,0x5c, + 0xa11,0x5db,0x5af,0x300f7,0xa13,0x0,0x400fa,0xa11,0xa12,0xa13,0x200f8,0xa12, + 0x200f9,0xa1b,0x200f8,0xa13,0x300e1,0xe9,0x166,0x400e0,0xe9,0xe9,0x167,0x500b0, + 0x5c,0xb81,0x584,0x21f,0x300f7,0xb92,0x0,0x400fa,0xb81,0xb82,0xb92,0x200f8, + 0xb82,0x70041,0x13d,0xb97,0x13a,0x584,0x11e,0x11e,0x4003d,0x31,0xb98,0xb97, + 0x70041,0x13d,0xb9b,0x13a,0x584,0x11e,0xf0,0x4003d,0x31,0xb9c,0xb9b,0x70041, + 0x13d,0xb9f,0x144,0x584,0x11e,0x11e,0x4003d,0x31,0xba0,0xb9f,0x70041,0x13d, + 0xba3,0x144,0x584,0x11e,0xf0,0x4003d,0x31,0xba4,0xba3,0x70050,0x32,0xba5, + 0xb98,0xb9c,0xba0,0xba4,0x6016e,0x32,0xbb2,0xea,0xba5,0x11e,0x6016e,0x32, + 0xbb4,0xea,0xba5,0xf0,0x6016e,0x32,0xbb6,0xea,0xba5,0xe9,0x200f9,0xb92, + 0x200f8,0xb92,0x200f9,0xa1b,0x200f8,0xa1b,0x500b0,0x5c,0x634,0x5db,0x4a7,0x300f7, + 0x636,0x0,0x400fa,0x634,0x635,0x636,0x200f8,0x635,0x200f9,0x64a,0x200f8,0x636, + 0x500aa,0x5c,0xbcb,0x584,0x11e,0x300f7,0xbcf,0x0,0x400fa,0xbcb,0xbcc,0xbcf, + 0x200f8,0xbcc,0x6003c,0x11f,0xbdb,0x11c,0x11d,0x11e,0x700ea,0x6,0xbdc,0xbdb, + 0xf0,0x11e,0xf0,0x3003e,0x126,0xbdc,0x200f9,0xbcf,0x200f8,0xbcf,0x300e1,0xe9, + 0x166,0x400e0,0xe9,0xe9,0x167,0x4003d,0x6,0xbe0,0x126,0x50082,0x6,0xbd3, + 0x5df,0xf0,0x500ab,0x5c,0xbd4,0xbe0,0xbd3,0x300f7,0x63c,0x0,0x400fa,0xbd4, + 0x63b,0x63c,0x200f8,0x63b,0x200f9,0x64a,0x200f8,0x63c,0x4003d,0x11a,0xbe4,0x11c, + 0x50063,0xbe4,0x11d,0x124,0x2000,0x300f7,0xc8f,0x0,0x300fb,0x11e,0xc11,0x200f8, + 0xc11,0x500b0,0x5c,0xc7b,0x5db,0x2f0,0x300f7,0xc7d,0x0,0x400fa,0xc7b,0xc7c, + 0xc7d,0x200f8,0xc7c,0x200f9,0xc8f,0x200f8,0xc7d,0x60041,0x154,0xdcc,0x13a,0x61e, + 0x624,0x3003e,0xdcc,0x1063,0x60041,0x154,0xdd1,0x144,0x61e,0x624,0x3003e,0xdd1, + 0x1063,0x200f9,0xc8f,0x200f8,0xc8f,0x300f7,0xe23,0x0,0x300fb,0x11e,0xdea,0x200f8, + 0xdea,0x500b2,0x5c,0xded,0x5db,0x2f0,0x300f7,0xdef,0x0,0x400fa,0xded,0xdee, + 0xdef,0x200f8,0xdee,0x200f9,0xe23,0x200f8,0xdef,0x300e1,0xe9,0x166,0x400e0,0xe9, + 0xe9,0x167,0x70041,0x13d,0xe57,0x13a,0x61e,0x624,0x11e,0x4003d,0x31,0xe58, + 0xe57,0x70041,0x13d,0xe5b,0x13a,0x61e,0x624,0xf0,0x4003d,0x31,0xe5c,0xe5b, + 0x70041,0x13d,0xe5f,0x144,0x61e,0x624,0x11e,0x4003d,0x31,0xe60,0xe5f,0x70041, + 0x13d,0xe63,0x144,0x61e,0x624,0xf0,0x4003d,0x31,0xe64,0xe63,0x70050,0x32, + 0xe65,0xe58,0xe5c,0xe60,0xe64,0x6016e,0x32,0xe72,0xea,0xe65,0x11e,0x6016e, + 0x32,0xe74,0xea,0xe65,0xf0,0x6016e,0x32,0xe76,0xea,0xe65,0xe9,0x50081, + 0x32,0xe80,0xe65,0xe72,0x50081,0x32,0xe82,0xe80,0xe74,0x50081,0x32,0xe84, + 0xe82,0xe76,0x5008e,0x32,0xe85,0xe84,0x162,0x50089,0x6,0xe37,0x584,0x21f, + 0x500aa,0x5c,0xe38,0xe37,0x11e,0x300f7,0xe52,0x0,0x400fa,0xe38,0xe39,0xe52, + 0x200f8,0xe39,0x50086,0x6,0xe4c,0x624,0xe9,0x50089,0x6,0xe4d,0xe4c,0xe9, + 0x50080,0x6,0xe4e,0x61e,0xe4d,0x7004f,0x135,0xe8b,0xe85,0xe85,0x0,0x1, + 0x60041,0x154,0xe8c,0x13a,0xe4e,0x624,0x3003e,0xe8c,0xe8b,0x7004f,0x135,0xe90, + 0xe85,0xe85,0x2,0x3,0x60041,0x154,0xe91,0x144,0xe4e,0x624,0x3003e,0xe91, + 0xe90,0x200f9,0xe52,0x200f8,0xe52,0x500b2,0x5c,0xdfb,0x5db,0x1060,0x300f7,0xdfd, + 0x0,0x400fa,0xdfb,0xdfc,0xdfd,0x200f8,0xdfc,0x200f9,0xe23,0x200f8,0xdfd,0x300e1, + 0xe9,0x166,0x400e0,0xe9,0xe9,0x167,0x500b0,0x5c,0xea0,0x584,0x207,0x300f7, + 0xeca,0x0,0x400fa,0xea0,0xea1,0xeca,0x200f8,0xea1,0x50084,0x6,0xea3,0x61e, + 0xe9,0x50089,0x6,0xea5,0x624,0xe9,0x50080,0x6,0xea6,0xea3,0xea5,0x50084, + 0x6,0xea8,0x624,0xe9,0x70041,0x13d,0xecf,0x13a,0xea6,0xea8,0x11e,0x4003d, + 0x31,0xed0,0xecf,0x70041,0x13d,0xed3,0x13a,0xea6,0xea8,0xf0,0x4003d,0x31, + 0xed4,0xed3,0x70041,0x13d,0xed7,0x144,0xea6,0xea8,0x11e,0x4003d,0x31,0xed8, + 0xed7,0x70041,0x13d,0xedb,0x144,0xea6,0xea8,0xf0,0x4003d,0x31,0xedc,0xedb, + 0x70050,0x32,0xedd,0xed0,0xed4,0xed8,0xedc,0x6016e,0x32,0xeea,0xea,0xedd, + 0x11e,0x6016e,0x32,0xeec,0xea,0xedd,0xf0,0x6016e,0x32,0xeee,0xea,0xedd, + 0xe9,0x50081,0x32,0xef8,0xedd,0xeea,0x50081,0x32,0xefa,0xef8,0xeec,0x50081, + 0x32,0xefc,0xefa,0xeee,0x5008e,0x32,0xefd,0xefc,0x162,0x300f7,0xec9,0x0, + 0x400fa,0xe38,0xeaf,0xec9,0x200f8,0xeaf,0x50086,0x6,0xec3,0x624,0xe9,0x50080, + 0x6,0xec4,0xea3,0xec3,0x7004f,0x135,0xf03,0xefd,0xefd,0x0,0x1,0x60041, + 0x154,0xf04,0x13a,0xec4,0xea8,0x3003e,0xf04,0xf03,0x7004f,0x135,0xf08,0xefd, + 0xefd,0x2,0x3,0x60041,0x154,0xf09,0x144,0xec4,0xea8,0x3003e,0xf09,0xf08, + 0x200f9,0xec9,0x200f8,0xec9,0x200f9,0xeca,0x200f8,0xeca,0x500b2,0x5c,0xe0a,0x5db, + 0x1061,0x300f7,0xe0c,0x0,0x400fa,0xe0a,0xe0b,0xe0c,0x200f8,0xe0b,0x200f9,0xe23, + 0x200f8,0xe0c,0x300e1,0xe9,0x166,0x400e0,0xe9,0xe9,0x167,0x500b0,0x5c,0xf18, + 0x584,0x136,0x300f7,0xf3e,0x0,0x400fa,0xf18,0xf19,0xf3e,0x200f8,0xf19,0x50084, + 0x6,0xf1b,0x61e,0x21f,0x50080,0x6,0xf1d,0xf1b,0x624,0x50084,0x6,0xf1f, + 0x624,0x21f,0x70041,0x13d,0xf43,0x13a,0xf1d,0xf1f,0x11e,0x4003d,0x31,0xf44, + 0xf43,0x70041,0x13d,0xf47,0x13a,0xf1d,0xf1f,0xf0,0x4003d,0x31,0xf48,0xf47, + 0x70041,0x13d,0xf4b,0x144,0xf1d,0xf1f,0x11e,0x4003d,0x31,0xf4c,0xf4b,0x70041, + 0x13d,0xf4f,0x144,0xf1d,0xf1f,0xf0,0x4003d,0x31,0xf50,0xf4f,0x70050,0x32, + 0xf51,0xf44,0xf48,0xf4c,0xf50,0x6016e,0x32,0xf5e,0xea,0xf51,0x11e,0x6016e, + 0x32,0xf60,0xea,0xf51,0xf0,0x6016e,0x32,0xf62,0xea,0xf51,0xe9,0x50081, + 0x32,0xf6c,0xf51,0xf5e,0x50081,0x32,0xf6e,0xf6c,0xf60,0x50081,0x32,0xf70, + 0xf6e,0xf62,0x5008e,0x32,0xf71,0xf70,0x162,0x300f7,0xf3d,0x0,0x400fa,0xe38, + 0xf26,0xf3d,0x200f8,0xf26,0x50086,0x6,0xf38,0x61e,0xe9,0x50080,0x6,0xf3a, + 0xf38,0x624,0x7004f,0x135,0xf77,0xf71,0xf71,0x0,0x1,0x60041,0x154,0xf78, + 0x13a,0xf3a,0x11e,0x3003e,0xf78,0xf77,0x7004f,0x135,0xf7c,0xf71,0xf71,0x2, + 0x3,0x60041,0x154,0xf7d,0x144,0xf3a,0x11e,0x3003e,0xf7d,0xf7c,0x200f9,0xf3d, + 0x200f8,0xf3d,0x200f9,0xf3e,0x200f8,0xf3e,0x500b2,0x5c,0xe19,0x5db,0x1062,0x300f7, + 0xe1b,0x0,0x400fa,0xe19,0xe1a,0xe1b,0x200f8,0xe1a,0x200f9,0xe23,0x200f8,0xe1b, + 0x300e1,0xe9,0x166,0x400e0,0xe9,0xe9,0x167,0x500b0,0x5c,0xf89,0x584,0x21f, + 0x300f7,0xf9a,0x0,0x400fa,0xf89,0xf8a,0xf9a,0x200f8,0xf8a,0x70041,0x13d,0xf9f, + 0x13a,0x584,0x11e,0x11e,0x4003d,0x31,0xfa0,0xf9f,0x70041,0x13d,0xfa3,0x13a, + 0x584,0x11e,0xf0,0x4003d,0x31,0xfa4,0xfa3,0x70041,0x13d,0xfa7,0x144,0x584, + 0x11e,0x11e,0x4003d,0x31,0xfa8,0xfa7,0x70041,0x13d,0xfab,0x144,0x584,0x11e, + 0xf0,0x4003d,0x31,0xfac,0xfab,0x70050,0x32,0xfad,0xfa0,0xfa4,0xfa8,0xfac, + 0x6016e,0x32,0xfba,0xea,0xfad,0x11e,0x6016e,0x32,0xfbc,0xea,0xfad,0xf0, + 0x6016e,0x32,0xfbe,0xea,0xfad,0xe9,0x200f9,0xf9a,0x200f8,0xf9a,0x200f9,0xe23, + 0x200f8,0xe23,0x200f9,0x64a,0x200f8,0x64a,0x100fd,0x10038, +}; +static const char *fu1_shading_change_pyramid_pass_0_cb_names[] = {"cbSPD"}; +static const uint32_t fu1_shading_change_pyramid_pass_0_cb_bind[] = {12}; +static const uint32_t fu1_shading_change_pyramid_pass_0_cb_count[] = {1}; +static const uint32_t fu1_shading_change_pyramid_pass_0_cb_space[] = {0}; +static const char *fu1_shading_change_pyramid_pass_0_uav_tex_names[] = {"rw_spd_global_atomic"}; +static const uint32_t fu1_shading_change_pyramid_pass_0_uav_tex_bind[] = {4}; +static const uint32_t fu1_shading_change_pyramid_pass_0_uav_tex_count[] = {1}; +static const uint32_t fu1_shading_change_pyramid_pass_0_uav_tex_space[] = {0}; + +static const uint32_t fu1_shading_change_pass_0_spv[742] = { + 0x7230203,0x10500,0x8000b,0x239,0x0,0x20011,0x1,0x20011,0x31,0x20011,0x32,0x6000b, + 0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0xa000f,0x5,0x4,0x6e69616d, + 0x0,0x68,0x77,0x81,0x8e,0x128,0x60010,0x4,0x11,0x8,0x8,0x1, + 0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75, + 0x736e6f69,0x0,0x80004,0x455f4c47,0x735f5458,0x65646168,0x36315f72,0x5f746962,0x726f7473,0x656761,0xb0004,0x455f4c47, + 0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004,0x475f4c47,0x4c474f4f, + 0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63, + 0x69645f65,0x74636572,0x657669,0x40005,0x4,0x6e69616d,0x0,0x70005,0x66,0x53466263,0x50553352,0x4c414353, + 0x745f5245,0x0,0x60006,0x66,0x0,0x6e655269,0x53726564,0x657a69,0x50006,0x66,0x1,0x74694a66, + 0x726574,0x60005,0x68,0x53466263,0x70553352,0x6c616373,0x7265,0x50005,0x77,0x70735f72,0x696d5f64,0x7370, + 0x60005,0x81,0x694c5f73,0x7261656e,0x6d616c43,0x70,0x70005,0x8e,0x735f7772,0x69646168,0x635f676e,0x676e6168, + 0x65,0x80005,0x128,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x44,0x30047,0x66,0x2, + 0x50048,0x66,0x0,0x23,0x0,0x50048,0x66,0x1,0x23,0x40,0x40047,0x68, + 0x21,0x2,0x40047,0x68,0x22,0x0,0x40047,0x77,0x21,0x0,0x40047,0x77, + 0x22,0x0,0x40047,0x81,0x21,0x3e9,0x40047,0x81,0x22,0x0,0x40047,0x8e, + 0x21,0x1,0x40047,0x8e,0x22,0x0,0x40047,0x128,0xb,0x1c,0x40047,0x13c, + 0xb,0x19,0x20013,0x2,0x30021,0x3,0x2,0x30016,0x6,0x20,0x40020,0x7, + 0x7,0x6,0x40017,0xc,0x6,0x2,0x40015,0x1c,0x20,0x1,0x40017,0x1d, + 0x1c,0x2,0x40015,0x24,0x20,0x0,0x20014,0x3d,0x4002b,0x24,0x43,0x3, + 0x4001c,0x44,0x6,0x43,0x4002b,0x6,0x51,0x0,0x4002b,0x6,0x52,0x3f800000, + 0x40017,0x65,0x6,0x4,0x4001e,0x66,0x1d,0xc,0x40020,0x67,0x2,0x66, + 0x4003b,0x67,0x68,0x2,0x4002b,0x1c,0x69,0x0,0x40020,0x6a,0x2,0x1d, + 0x40020,0x70,0x2,0xc,0x90019,0x75,0x6,0x1,0x0,0x0,0x0,0x1, + 0x0,0x40020,0x76,0x0,0x75,0x4003b,0x76,0x77,0x0,0x2001a,0x7f,0x40020, + 0x80,0x0,0x7f,0x4003b,0x80,0x81,0x0,0x3001b,0x83,0x75,0x90019,0x8c, + 0x6,0x1,0x0,0x0,0x0,0x2,0xf,0x40020,0x8d,0x0,0x8c,0x4003b, + 0x8d,0x8e,0x0,0x4002b,0x6,0x95,0x3f000000,0x5002c,0xc,0xa0,0x95,0x95, + 0x40017,0xb4,0x24,0x2,0x40017,0xb8,0x3d,0x2,0x4002b,0x1c,0xcf,0x3, + 0x4002b,0x24,0xdd,0x1,0x4002b,0x1c,0xe4,0x1,0x40017,0x126,0x24,0x3, + 0x40020,0x127,0x1,0x126,0x4003b,0x127,0x128,0x1,0x4002b,0x24,0x13b,0x8, + 0x6002c,0x126,0x13c,0x13b,0x13b,0xdd,0x40020,0x21a,0x7,0x44,0x50036,0x2, + 0x4,0x0,0x3,0x200f8,0x5,0x4003b,0x21a,0x223,0x7,0x4003b,0x21a,0x21b, + 0x7,0x4003d,0x126,0x129,0x128,0x7004f,0xb4,0x12a,0x129,0x129,0x0,0x1, + 0x4007c,0x1d,0x12b,0x12a,0x50041,0x6a,0x183,0x68,0x69,0x4003d,0x1d,0x184, + 0x183,0x4006f,0xc,0x17e,0x184,0x5008e,0xc,0x17f,0x17e,0x95,0x4006e,0x1d, + 0x180,0x17f,0x4007c,0xb4,0x18b,0x180,0x500b0,0xb8,0x18c,0x12a,0x18b,0x4009b, + 0x3d,0x18d,0x18c,0x300f7,0x17a,0x0,0x400fa,0x18d,0x14f,0x17a,0x200f8,0x14f, + 0x4006f,0xc,0x151,0x12b,0x50081,0xc,0x153,0x151,0xa0,0x4006f,0xc,0x155, + 0x180,0x50088,0xc,0x156,0x153,0x155,0x50041,0x70,0x19a,0x68,0xdd,0x4003d, + 0xc,0x19b,0x19a,0x50088,0xc,0x15b,0x19b,0x17e,0x50081,0xc,0x15c,0x156, + 0x15b,0x4003d,0x75,0x1dc,0x77,0x50067,0x1d,0x1df,0x1dc,0x69,0x50085,0xc, + 0x1ec,0x15c,0x155,0x50083,0xc,0x1ef,0x155,0xa0,0x7000c,0xc,0x1fc,0x1, + 0x25,0x1ec,0x1ef,0x7000c,0xc,0x201,0x1,0x28,0xa0,0x1fc,0x4006f,0xc, + 0x1f5,0x1df,0x50088,0xc,0x1f6,0x201,0x1f5,0x200f9,0x1ba,0x200f8,0x1ba,0x700f5, + 0x1c,0x231,0x69,0x14f,0x1cd,0x1be,0x500b1,0x3d,0x1bd,0x231,0xcf,0x400f6, + 0x1ce,0x1be,0x0,0x400fa,0x1bd,0x1be,0x1ce,0x200f8,0x1be,0x4007c,0x24,0x1c0, + 0x231,0x4003d,0x75,0x204,0x77,0x4003d,0x7f,0x205,0x81,0x50056,0x83,0x206, + 0x204,0x205,0x40070,0x6,0x209,0x1c0,0x70058,0x65,0x20a,0x206,0x1f6,0x2, + 0x209,0x50051,0x6,0x1c5,0x20a,0x0,0x50051,0x6,0x1c7,0x20a,0x1,0x50085, + 0x6,0x1c8,0x1c5,0x1c7,0x6000c,0x6,0x1c9,0x1,0x4,0x1c8,0x50041,0x7, + 0x21c,0x21b,0x231,0x3003e,0x21c,0x1c9,0x50080,0x1c,0x1cd,0x231,0xe4,0x200f9, + 0x1ba,0x200f8,0x1ce,0x4003d,0x44,0x21d,0x21b,0x3003e,0x223,0x21d,0x200f9,0x161, + 0x200f8,0x161,0x700f5,0x6,0x233,0x51,0x1ce,0x238,0x172,0x700f5,0x1c,0x232, + 0x69,0x1ce,0x174,0x172,0x500b1,0x3d,0x164,0x232,0xcf,0x400f6,0x175,0x172, + 0x0,0x400fa,0x164,0x165,0x175,0x200f8,0x165,0x50041,0x7,0x225,0x223,0x232, + 0x4003d,0x6,0x168,0x225,0x500ba,0x3d,0x169,0x168,0x51,0x300f7,0x171,0x0, + 0x400fa,0x169,0x16a,0x171,0x200f8,0x16a,0x4003d,0x6,0x16e,0x225,0x7000c,0x6, + 0x210,0x1,0x28,0x233,0x16e,0x200f9,0x171,0x200f8,0x171,0x700f5,0x6,0x238, + 0x233,0x165,0x210,0x16a,0x200f9,0x172,0x200f8,0x172,0x50080,0x1c,0x174,0x232, + 0xe4,0x200f9,0x161,0x200f8,0x175,0x8000c,0x6,0x214,0x1,0x2b,0x233,0x51, + 0x52,0x4003d,0x8c,0x216,0x8e,0x70050,0x65,0x219,0x214,0x51,0x51,0x51, + 0x40063,0x216,0x12b,0x219,0x200f9,0x17a,0x200f8,0x17a,0x100fd,0x10038, +}; +static const char *fu1_shading_change_pass_0_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu1_shading_change_pass_0_cb_bind[] = {2}; +static const uint32_t fu1_shading_change_pass_0_cb_count[] = {1}; +static const uint32_t fu1_shading_change_pass_0_cb_space[] = {0}; +static const char *fu1_shading_change_pass_0_srv_tex_names[] = {"r_spd_mips"}; +static const uint32_t fu1_shading_change_pass_0_srv_tex_bind[] = {0}; +static const uint32_t fu1_shading_change_pass_0_srv_tex_count[] = {1}; +static const uint32_t fu1_shading_change_pass_0_srv_tex_space[] = {0}; +static const char *fu1_shading_change_pass_0_uav_tex_names[] = {"rw_shading_change"}; +static const uint32_t fu1_shading_change_pass_0_uav_tex_bind[] = {1}; +static const uint32_t fu1_shading_change_pass_0_uav_tex_count[] = {1}; +static const uint32_t fu1_shading_change_pass_0_uav_tex_space[] = {0}; +static const char *fu1_shading_change_pass_0_sampler_names[] = {"s_LinearClamp"}; +static const uint32_t fu1_shading_change_pass_0_sampler_bind[] = {1001}; +static const uint32_t fu1_shading_change_pass_0_sampler_count[] = {1}; +static const uint32_t fu1_shading_change_pass_0_sampler_space[] = {0}; + +static const uint32_t fu1_prepare_reactivity_pass_0_spv[3249] = { + 0x7230203,0x10500,0x8000b,0xc04,0x0,0x20011,0x1,0x20011,0x31,0x20011,0x32,0x6000b, + 0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0x14000f,0x5,0x4,0x6e69616d, + 0x0,0x10b,0x13f,0x14b,0x153,0x15c,0x167,0x16c,0x179,0x180,0x187,0x190, + 0x197,0x19f,0x1ad,0x513,0x60010,0x4,0x11,0x8,0x8,0x1,0x30003,0x2, + 0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0, + 0x80004,0x455f4c47,0x735f5458,0x65646168,0x36315f72,0x5f746962,0x726f7473,0x656761,0xb0004,0x455f4c47,0x735f5458,0x65646168, + 0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70, + 0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572, + 0x657669,0x40005,0x4,0x6e69616d,0x0,0x70005,0x109,0x53466263,0x50553352,0x4c414353,0x745f5245,0x0, + 0x60006,0x109,0x0,0x6e655269,0x53726564,0x657a69,0xa0006,0x109,0x1,0x65725069,0x756f6976,0x61724673, + 0x6552656d,0x7265646e,0x657a6953,0x0,0x70006,0x109,0x2,0x73705569,0x656c6163,0x657a6953,0x0,0x70006, + 0x109,0x3,0x78614d69,0x646e6552,0x69537265,0x657a,0x80006,0x109,0x4,0x76654466,0x54656369,0x6569566f, + 0x70654477,0x6874,0x50006,0x109,0x5,0x74694a66,0x726574,0xa0006,0x109,0x6,0x65695666,0x61705377, + 0x6f546563,0x6574654d,0x61467372,0x726f7463,0x0,0x80006,0x109,0x7,0x61655266,0x76697463,0x73656e65,0x61635373, + 0x656c,0x80006,0x109,0x8,0x61685366,0x676e6964,0x6e616843,0x63536567,0x656c61,0xa0006,0x109,0x9, + 0x63634166,0x6c756d75,0x6f697461,0x6464416e,0x65506465,0x61724672,0x656d,0xb0006,0x109,0xa,0x6e694d66,0x6f736944, + 0x756c6363,0x6e6f6973,0x75636341,0x616c756d,0x6e6f6974,0x0,0x60005,0x10b,0x53466263,0x70553352,0x6c616373,0x7265, + 0x60005,0x13f,0x65725f72,0x69746361,0x6d5f6576,0x6b7361,0xb0005,0x14b,0x72745f72,0x70736e61,0x6e657261,0x615f7963, + 0x635f646e,0x6f706d6f,0x69746973,0x6d5f6e6f,0x6b7361,0x60005,0x153,0x694c5f73,0x7261656e,0x6d616c43,0x70,0x60005, + 0x15c,0x63615f72,0x756d7563,0x6974616c,0x6e6f,0x60005,0x167,0x615f7772,0x6d756363,0x74616c75,0x6e6f69,0x70005, + 0x16c,0x68735f72,0x6e696461,0x68635f67,0x65676e61,0x0,0x60005,0x179,0x75635f72,0x6e657272,0x756c5f74,0x616d, + 0x60005,0x180,0x6e5f7772,0x6c5f7765,0x736b636f,0x0,0xc0005,0x187,0x65725f72,0x736e6f63,0x63757274,0x5f646574, + 0x76657270,0x73756f69,0x61656e5f,0x74736572,0x7065645f,0x6874,0x90005,0x190,0x69645f72,0x6574616c,0x6f6d5f64,0x6e6f6974, + 0x6365765f,0x73726f74,0x0,0x60005,0x197,0x69645f72,0x6574616c,0x65645f64,0x687470,0x70005,0x19f,0x6e695f72, + 0x5f747570,0x6f707865,0x65727573,0x0,0x90005,0x1ad,0x645f7772,0x74616c69,0x725f6465,0x74636165,0x5f657669,0x6b73616d, + 0x73,0x80005,0x513,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x44,0x30047,0x109,0x2, + 0x50048,0x109,0x0,0x23,0x0,0x50048,0x109,0x1,0x23,0x8,0x50048,0x109, + 0x2,0x23,0x10,0x50048,0x109,0x3,0x23,0x20,0x50048,0x109,0x4,0x23, + 0x30,0x50048,0x109,0x5,0x23,0x40,0x50048,0x109,0x6,0x23,0x78,0x50048, + 0x109,0x7,0x23,0x84,0x50048,0x109,0x8,0x23,0x88,0x50048,0x109,0x9, + 0x23,0x8c,0x50048,0x109,0xa,0x23,0x90,0x40047,0x10b,0x21,0xc,0x40047, + 0x10b,0x22,0x0,0x40047,0x13f,0x21,0x3,0x40047,0x13f,0x22,0x0,0x40047, + 0x14b,0x21,0x4,0x40047,0x14b,0x22,0x0,0x40047,0x153,0x21,0x3e9,0x40047, + 0x153,0x22,0x0,0x40047,0x15c,0x21,0x5,0x40047,0x15c,0x22,0x0,0x40047, + 0x167,0x21,0xb,0x40047,0x167,0x22,0x0,0x40047,0x16c,0x21,0x6,0x40047, + 0x16c,0x22,0x0,0x40047,0x179,0x21,0x7,0x40047,0x179,0x22,0x0,0x40047, + 0x180,0x21,0xa,0x40047,0x180,0x22,0x0,0x40047,0x187,0x21,0x0,0x40047, + 0x187,0x22,0x0,0x40047,0x190,0x21,0x1,0x40047,0x190,0x22,0x0,0x40047, + 0x197,0x21,0x2,0x40047,0x197,0x22,0x0,0x40047,0x19f,0x21,0x8,0x40047, + 0x19f,0x22,0x0,0x30047,0x1ad,0x19,0x40047,0x1ad,0x21,0x9,0x40047,0x1ad, + 0x22,0x0,0x40047,0x513,0xb,0x1c,0x40047,0x522,0xb,0x19,0x30047,0x9aa, + 0x18,0x30047,0x9be,0x18,0x30047,0x9bf,0x18,0x20013,0x2,0x30021,0x3,0x2, + 0x30016,0x6,0x20,0x40020,0x7,0x7,0x6,0x40017,0x12,0x6,0x2,0x40015, + 0x22,0x20,0x1,0x40017,0x35,0x22,0x2,0x40017,0x42,0x6,0x4,0x40020, + 0x4d,0x7,0x35,0x20014,0x8b,0x40015,0xab,0x20,0x0,0x4002b,0xab,0xac, + 0x4,0x4001c,0xad,0x35,0xac,0x4001c,0xae,0x6,0xac,0x4002b,0x6,0xe2, + 0x0,0x4002b,0x6,0xe3,0x3f800000,0xd001e,0x109,0x35,0x35,0x35,0x35,0x42, + 0x12,0x6,0x6,0x6,0x6,0x6,0x40020,0x10a,0x2,0x109,0x4003b,0x10a, + 0x10b,0x2,0x4002b,0x22,0x10c,0x0,0x40020,0x10d,0x2,0x35,0x4002b,0x22, + 0x112,0x1,0x4002b,0x22,0x117,0x4,0x4002b,0x22,0x11c,0x2,0x40020,0x122, + 0x2,0x12,0x40020,0x128,0x2,0x42,0x40020,0x12e,0x2,0x6,0x90019,0x13d, + 0x6,0x1,0x0,0x0,0x0,0x1,0x0,0x40020,0x13e,0x0,0x13d,0x4003b, + 0x13e,0x13f,0x0,0x4002b,0xab,0x143,0x0,0x4003b,0x13e,0x14b,0x0,0x2001a, + 0x151,0x40020,0x152,0x0,0x151,0x4003b,0x152,0x153,0x0,0x3001b,0x155,0x13d, + 0x4003b,0x13e,0x15c,0x0,0x90019,0x165,0x6,0x1,0x0,0x0,0x0,0x2, + 0xf,0x40020,0x166,0x0,0x165,0x4003b,0x166,0x167,0x0,0x4003b,0x13e,0x16c, + 0x0,0x4003b,0x13e,0x179,0x0,0x4003b,0x166,0x180,0x0,0x90019,0x185,0xab, + 0x1,0x0,0x0,0x0,0x1,0x0,0x40020,0x186,0x0,0x185,0x4003b,0x186, + 0x187,0x0,0x40017,0x18a,0xab,0x4,0x4003b,0x13e,0x190,0x0,0x4003b,0x13e, + 0x197,0x0,0x4003b,0x13e,0x19f,0x0,0x5002c,0x35,0x1a1,0x10c,0x10c,0x90019, + 0x1ab,0x6,0x1,0x0,0x0,0x0,0x2,0x4,0x40020,0x1ac,0x0,0x1ab, + 0x4003b,0x1ac,0x1ad,0x0,0x4002b,0x6,0x1b1,0x3e800000,0x4002b,0x6,0x1b2,0x3f400000, + 0x4002b,0x6,0x1b4,0x42c80000,0x4002b,0x6,0x1c0,0x3f000000,0x4002b,0x6,0x1cc,0x45700000, + 0x4002b,0x6,0x1cd,0x45070000,0x5002c,0x12,0x1ce,0x1cc,0x1cd,0x4002b,0xab,0x1f0, + 0x1,0x5002c,0x12,0x222,0x1c0,0x1c0,0x40017,0x236,0xab,0x2,0x40017,0x23a, + 0x8b,0x2,0x5002c,0x35,0x278,0x112,0x10c,0x5002c,0x35,0x27a,0x10c,0x112, + 0x5002c,0x35,0x27d,0x112,0x112,0x4002b,0x6,0x2a2,0x477fe000,0x30029,0x8b,0x2c0, + 0x4002b,0x6,0x2e4,0x3a1fe868,0x4002b,0x6,0x2f4,0x800000,0x4002b,0x6,0x306,0x3765d90d, + 0x4002b,0x22,0x36b,0xffffffff,0x4002b,0x6,0x3a1,0x7f7fffff,0x4002b,0x22,0x3aa,0x9, + 0x4002b,0xab,0x3ad,0x9,0x4001c,0x3ae,0x35,0x3ad,0x5002c,0x35,0x3af,0x36b, + 0x36b,0x5002c,0x35,0x3b0,0x10c,0x36b,0x5002c,0x35,0x3b1,0x112,0x36b,0x5002c, + 0x35,0x3b2,0x36b,0x10c,0x5002c,0x35,0x3b3,0x36b,0x112,0xc002c,0x3ae,0x3b4, + 0x1a1,0x3af,0x3b0,0x3b1,0x3b2,0x278,0x3b3,0x27a,0x27d,0x40020,0x3ba,0x7, + 0x3ae,0x4001c,0x3c0,0x6,0x3ad,0x40020,0x3c1,0x7,0x3c0,0x40020,0x3dc,0x7, + 0xab,0x4002b,0x6,0x3f4,0x3f666666,0x3002a,0x8b,0x41c,0x4001c,0x42c,0xab,0xac, + 0x4002b,0xab,0x42d,0x17,0x4002b,0xab,0x42e,0x2d,0x4002b,0xab,0x42f,0xd1, + 0x4002b,0xab,0x430,0x1a1,0x7002c,0x42c,0x431,0x42d,0x42e,0x42f,0x430,0x40020, + 0x433,0x7,0x42c,0x4002b,0x6,0x506,0x3c23d70a,0x40017,0x511,0xab,0x3,0x40020, + 0x512,0x1,0x511,0x4003b,0x512,0x513,0x1,0x4002b,0xab,0x521,0x8,0x6002c, + 0x511,0x522,0x521,0x521,0x1f0,0x40020,0xabb,0x7,0xad,0x40020,0xabd,0x7, + 0xae,0x30001,0x6,0xb6d,0x7002c,0xad,0xbb7,0x1a1,0x278,0x27a,0x27d,0x4002b, + 0x6,0xbb8,0x3dcccccd,0x4002b,0xab,0xbee,0x6,0x4002b,0xab,0xbef,0x7,0x4002b, + 0xab,0xbf0,0x5,0x4002b,0xab,0xbf1,0x3,0x4002b,0xab,0xbf2,0xa,0x50036, + 0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003b,0xabd,0xad7,0x7,0x4003b,0xabb, + 0xad6,0x7,0x5003b,0x3ba,0x9aa,0x7,0x3b4,0x4003b,0x3c1,0x9ac,0x7,0x5003b, + 0x433,0x9be,0x7,0x431,0x5003b,0x433,0x9bf,0x7,0x431,0x4003d,0x511,0x514, + 0x513,0x7004f,0x236,0x515,0x514,0x514,0x0,0x1,0x4007c,0x35,0x516,0x515, + 0x4006f,0x12,0x559,0x516,0x50081,0x12,0x55b,0x559,0x222,0x50041,0x10d,0x59c, + 0x10b,0x10c,0x4003d,0x35,0x59d,0x59c,0x4006f,0x12,0x55d,0x59d,0x50088,0x12, + 0x55e,0x55b,0x55d,0x4003d,0x13d,0x5a0,0x190,0x7005f,0x42,0x5a2,0x5a0,0x516, + 0x2,0x10c,0x7004f,0x12,0x5a3,0x5a2,0x5a2,0x0,0x1,0x4003d,0x13d,0x5ab, + 0x197,0x7005f,0x42,0x5ad,0x5ab,0x516,0x2,0x10c,0x50051,0x6,0x5ae,0x5ad, + 0x0,0x50041,0x128,0x5d6,0x10b,0xac,0x4003d,0x42,0x5d7,0x5d6,0x50051,0x6, + 0x5ce,0x5d7,0x1,0x50051,0x6,0x5d1,0x5d7,0x0,0x50083,0x6,0x5d2,0x5ae, + 0x5d1,0x50088,0x6,0x5d3,0x5ce,0x5d2,0x50041,0x12e,0x661,0x10b,0xbee,0x4003d, + 0x6,0x662,0x661,0x50085,0x6,0x5fe,0x5d3,0x662,0x7000c,0x6,0x667,0x1, + 0x25,0x5fe,0x2a2,0x50085,0x6,0x66f,0x667,0x506,0x8000c,0x6,0x675,0x1, + 0x2b,0x66f,0xe2,0xe3,0x8000c,0x6,0x67b,0x1,0x2e,0x1b1,0x1b2,0x675, + 0x50085,0x12,0x67f,0x5a3,0x1ce,0x6000c,0x6,0x680,0x1,0x42,0x67f,0x500ba, + 0x8b,0x605,0x680,0x67b,0x600a9,0x6,0x606,0x605,0xe3,0xe2,0x5008e,0x12, + 0x608,0x5a3,0x606,0x50081,0x12,0x60b,0x55e,0x608,0x50085,0x12,0x68e,0x60b, + 0x55d,0x50083,0x12,0x68f,0x68e,0x222,0x6000c,0x12,0x691,0x1,0x8,0x68f, + 0x4006e,0x35,0x692,0x691,0x6000c,0x12,0x6ba,0x1,0xa,0x68f,0x50051,0x6, + 0x69b,0x6ba,0x0,0x50083,0x6,0x69c,0xe3,0x69b,0x50051,0x6,0x69e,0x6ba, + 0x1,0x50083,0x6,0x69f,0xe3,0x69e,0x50085,0x6,0x6a0,0x69c,0x69f,0x50085, + 0x6,0x6a7,0x69b,0x69f,0x50085,0x6,0x6ae,0x69c,0x69e,0x50085,0x6,0x6b4, + 0x69b,0x69e,0x70050,0xae,0xb09,0x6a0,0x6a7,0x6ae,0x6b4,0x3003e,0xad6,0xbb7, + 0x3003e,0xad7,0xb09,0x200f9,0x60f,0x200f8,0x60f,0x700f5,0x6,0xb0d,0xe2,0x5, + 0xb8d,0x64d,0x700f5,0x6,0xb0c,0xe2,0x5,0xb8a,0x64d,0x700f5,0x8b,0xb0b, + 0x2c0,0x5,0xb87,0x64d,0x700f5,0x22,0xb0a,0x10c,0x5,0x64f,0x64d,0x500b1, + 0x8b,0x612,0xb0a,0x117,0x500a7,0x8b,0x614,0x612,0xb0b,0x400f6,0x650,0x64d, + 0x0,0x400fa,0x614,0x615,0x650,0x200f8,0x615,0x50041,0x4d,0xadc,0xad6,0xb0a, + 0x4003d,0x35,0x618,0xadc,0x50080,0x35,0x6cc,0x692,0x618,0x50051,0x22,0x6ce, + 0x59d,0x0,0x50082,0x22,0x6cf,0x6ce,0x112,0x50051,0x22,0x6d1,0x6cc,0x0, + 0x7000c,0x22,0x6e2,0x1,0x27,0x6d1,0x6cf,0x7000c,0x22,0x6e7,0x1,0x2a, + 0x10c,0x6e2,0x50051,0x22,0x6d6,0x59d,0x1,0x50082,0x22,0x6d7,0x6d6,0x112, + 0x50051,0x22,0x6d9,0x6cc,0x1,0x7000c,0x22,0x6ec,0x1,0x27,0x6d9,0x6d7, + 0x7000c,0x22,0x6f1,0x1,0x2a,0x10c,0x6ec,0x50050,0x35,0xc03,0x6e7,0x6f1, + 0x4007c,0x236,0x6f9,0xc03,0x4007c,0x236,0x6fb,0x59d,0x500b0,0x23a,0x6fc,0x6f9, + 0x6fb,0x4009b,0x8b,0x6fd,0x6fc,0x300f7,0x64c,0x0,0x400fa,0x6fd,0x621,0x64c, + 0x200f8,0x621,0x50041,0x7,0xadd,0xad7,0xb0a,0x4003d,0x6,0x624,0xadd,0x500ba, + 0x8b,0x626,0x624,0x2e4,0x300f7,0x64b,0x0,0x400fa,0x626,0x627,0x64b,0x200f8, + 0x627,0x4003d,0x185,0x700,0x187,0x7005f,0x18a,0x702,0x700,0xc03,0x2002,0x10c, + 0x50051,0xab,0x703,0x702,0x0,0x4007c,0x6,0x704,0x703,0x50083,0x6,0x70e, + 0x704,0x5d1,0x50088,0x6,0x70f,0x5ce,0x70e,0x50083,0x6,0x62d,0x5d3,0x70f, + 0x500ba,0x8b,0x630,0x62d,0x2f4,0x500a7,0x8b,0x631,0xb0b,0x630,0x300f7,0x64a, + 0x0,0x400fa,0x631,0x633,0x64a,0x200f8,0x633,0x5008e,0x12,0x636,0x55d,0x1c0, + 0x6000c,0x6,0x637,0x1,0x42,0x636,0x7000c,0x6,0x71c,0x1,0x28,0x5d3, + 0x70f,0x50085,0x6,0x63c,0x306,0x637,0x50085,0x6,0x63e,0x63c,0x71c,0x50088, + 0x6,0x641,0x63e,0x62d,0x8000c,0x6,0x720,0x1,0x2b,0x641,0xe2,0xe3, + 0x50085,0x6,0x644,0x720,0x624,0x50081,0x6,0x646,0xb0d,0x644,0x50081,0x6, + 0x649,0xb0c,0x624,0x200f9,0x64a,0x200f8,0x64a,0x700f5,0x6,0xb8f,0xb0d,0x627, + 0x646,0x633,0x700f5,0x6,0xb8c,0xb0c,0x627,0x649,0x633,0x200f9,0x64b,0x200f8, + 0x64b,0x700f5,0x6,0xb8e,0xb0d,0x621,0xb8f,0x64a,0x700f5,0x6,0xb8b,0xb0c, + 0x621,0xb8c,0x64a,0x700f5,0x8b,0xb88,0xb0b,0x621,0x631,0x64a,0x200f9,0x64c, + 0x200f8,0x64c,0x700f5,0x6,0xb8d,0xb0d,0x615,0xb8e,0x64b,0x700f5,0x6,0xb8a, + 0xb0c,0x615,0xb8b,0x64b,0x700f5,0x8b,0xb87,0xb0b,0x615,0xb88,0x64b,0x200f9, + 0x64d,0x200f8,0x64d,0x50080,0x22,0x64f,0xb0a,0x112,0x200f9,0x60f,0x200f8,0x650, + 0x500ba,0x8b,0x653,0xb0c,0xe2,0x500a7,0x8b,0x654,0xb0b,0x653,0x300f7,0x65c, + 0x0,0x400fa,0x654,0x655,0x65b,0x200f8,0x655,0x50088,0x6,0x658,0xb0d,0xb0c, + 0x50083,0x6,0x659,0xe3,0x658,0x8000c,0x6,0x724,0x1,0x2b,0x659,0xe2, + 0xe3,0x200f9,0x65c,0x200f8,0x65b,0x200f9,0x65c,0x200f8,0x65c,0x700f5,0x6,0xb0e, + 0x724,0x655,0xe2,0x65b,0x200f9,0x731,0x200f8,0x731,0x700f5,0x6,0xb14,0xe2, + 0x65c,0xb81,0x749,0x700f5,0x22,0xb13,0x36b,0x65c,0x74b,0x749,0x500b3,0x8b, + 0x734,0xb13,0x112,0x400f6,0x74c,0x749,0x0,0x400fa,0x734,0x735,0x74c,0x200f8, + 0x735,0x200f9,0x736,0x200f8,0x736,0x700f5,0x6,0xb81,0xb14,0x735,0x792,0x73a, + 0x700f5,0x22,0xb7d,0x36b,0x735,0x747,0x73a,0x500b3,0x8b,0x739,0xb7d,0x112, + 0x400f6,0x748,0x73a,0x0,0x400fa,0x739,0x73a,0x748,0x200f8,0x73a,0x50050,0x35, + 0x73d,0xb7d,0xb13,0x50080,0x35,0x75f,0x516,0x73d,0x50051,0x22,0x761,0x59d, + 0x0,0x50082,0x22,0x762,0x761,0x112,0x50051,0x22,0x764,0x75f,0x0,0x7000c, + 0x22,0x775,0x1,0x27,0x764,0x762,0x7000c,0x22,0x77a,0x1,0x2a,0x10c, + 0x775,0x50051,0x22,0x769,0x59d,0x1,0x50082,0x22,0x76a,0x769,0x112,0x50051, + 0x22,0x76c,0x75f,0x1,0x7000c,0x22,0x77f,0x1,0x27,0x76c,0x76a,0x7000c, + 0x22,0x784,0x1,0x2a,0x10c,0x77f,0x50050,0x35,0xc02,0x77a,0x784,0x4003d, + 0x13d,0x787,0x13f,0x7005f,0x42,0x789,0x787,0xc02,0x2,0x10c,0x50051,0x6, + 0x78a,0x789,0x0,0x50041,0x12e,0x78b,0x10b,0xbef,0x4003d,0x6,0x78c,0x78b, + 0x50085,0x6,0x78d,0x78a,0x78c,0x7000c,0x6,0x792,0x1,0x28,0xb81,0x78d, + 0x50080,0x22,0x747,0xb7d,0x112,0x200f9,0x736,0x200f8,0x748,0x200f9,0x749,0x200f8, + 0x749,0x50080,0x22,0x74b,0xb13,0x112,0x200f9,0x731,0x200f8,0x74c,0x50041,0x122, + 0x7ab,0x10b,0xbf0,0x4003d,0x12,0x7ac,0x7ab,0x50088,0x12,0x7a0,0x7ac,0x55d, + 0x50083,0x12,0x7a1,0x55e,0x7a0,0x5008e,0x12,0x7b5,0x55d,0x1c0,0x4006e,0x35, + 0x7b6,0x7b5,0x50041,0x10d,0x7c3,0x10b,0xbf1,0x4003d,0x35,0x7c4,0x7c3,0x4006f, + 0x12,0x7be,0x7c4,0x5008e,0x12,0x7bf,0x7be,0x1c0,0x4006e,0x35,0x7c0,0x7bf, + 0x4006f,0x12,0x7d0,0x7b6,0x50085,0x12,0x7d1,0x7a1,0x7d0,0x50083,0x12,0x7d4, + 0x7d0,0x222,0x7000c,0x12,0x7e1,0x1,0x25,0x7d1,0x7d4,0x7000c,0x12,0x7e6, + 0x1,0x28,0x222,0x7e1,0x4006f,0x12,0x7da,0x7c0,0x50088,0x12,0x7db,0x7e6, + 0x7da,0x4003d,0x13d,0x7e9,0x16c,0x4003d,0x151,0x7ea,0x153,0x50056,0x155,0x7eb, + 0x7e9,0x7ea,0x70058,0x42,0x7ed,0x7eb,0x7db,0x2,0xe2,0x50051,0x6,0x7ee, + 0x7ed,0x0,0x50041,0x12e,0x7ef,0x10b,0x521,0x4003d,0x6,0x7f0,0x7ef,0x50085, + 0x6,0x7f1,0x7ee,0x7f0,0x8000c,0x6,0x7f5,0x1,0x2b,0x7f1,0xe2,0xe3, + 0x7000c,0x6,0x7fa,0x1,0x28,0xb14,0x7f5,0x50081,0x12,0x812,0x55e,0x5a3, + 0x50085,0x12,0x815,0x812,0x55d,0x4006e,0x35,0x816,0x815,0x4003d,0x13d,0x83e, + 0x197,0x7005f,0x42,0x840,0x83e,0x816,0x2,0x10c,0x50051,0x6,0x841,0x840, + 0x0,0x4003d,0x13d,0x844,0x190,0x7005f,0x42,0x846,0x844,0x816,0x2,0x10c, + 0x7004f,0x12,0x847,0x846,0x846,0x0,0x1,0x50085,0x12,0x84b,0x847,0x1ce, + 0x6000c,0x6,0x84c,0x1,0x42,0x84b,0x50083,0x6,0x862,0x841,0x5d1,0x50088, + 0x6,0x863,0x5ce,0x862,0x50085,0x6,0x858,0x863,0x662,0x7000c,0x6,0x89c, + 0x1,0x28,0x858,0x5fe,0x500b7,0x8b,0x890,0x89c,0xe2,0x300f7,0x896,0x0, + 0x400fa,0x890,0x891,0x895,0x200f8,0x891,0x7000c,0x6,0x8a1,0x1,0x25,0x858, + 0x5fe,0x50088,0x6,0x894,0x8a1,0x89c,0x200f9,0x896,0x200f8,0x895,0x200f9,0x896, + 0x200f8,0x896,0x700f5,0x6,0xb1c,0x894,0x891,0xe2,0x895,0x50085,0x6,0x82c, + 0x680,0xbb8,0x8000c,0x6,0x8a5,0x1,0x2b,0x82c,0xe2,0xe3,0x50088,0x6, + 0x830,0x84c,0x680,0x8000c,0x6,0x8a9,0x1,0x2b,0x830,0xe2,0xe3,0x50083, + 0x6,0x832,0xe3,0x8a9,0x50085,0x6,0x834,0x832,0xb1c,0x50085,0x6,0x836, + 0x834,0x8a5,0x4003d,0x13d,0x8bd,0x14b,0x50067,0x35,0x8be,0x8bd,0x10c,0x50083, + 0x12,0x8ce,0x55d,0x222,0x7000c,0x12,0x8db,0x1,0x25,0x55b,0x8ce,0x7000c, + 0x12,0x8e0,0x1,0x28,0x222,0x8db,0x4006f,0x12,0x8d4,0x8be,0x50088,0x12, + 0x8d5,0x8e0,0x8d4,0x4003d,0x13d,0x8e3,0x14b,0x4003d,0x151,0x8e4,0x153,0x50056, + 0x155,0x8e5,0x8e3,0x8e4,0x70058,0x42,0x8e7,0x8e5,0x8d5,0x2,0xe2,0x50051, + 0x6,0x8e8,0x8e7,0x0,0x7000c,0x6,0x8ed,0x1,0x28,0x836,0x8e8,0x50051, + 0x6,0x932,0x812,0x0,0x500be,0x8b,0x933,0x932,0xe2,0x300f7,0x938,0x0, + 0x400fa,0x933,0x934,0x938,0x200f8,0x934,0x500bc,0x8b,0x937,0x932,0xe3,0x200f9, + 0x938,0x200f8,0x938,0x700f5,0x8b,0x939,0x933,0x896,0x937,0x934,0x300f7,0x944, + 0x0,0x400fa,0x939,0x93a,0x944,0x200f8,0x93a,0x50051,0x6,0x93c,0x812,0x1, + 0x500be,0x8b,0x93d,0x93c,0xe2,0x300f7,0x942,0x0,0x400fa,0x93d,0x93e,0x942, + 0x200f8,0x93e,0x500bc,0x8b,0x941,0x93c,0xe3,0x200f9,0x942,0x200f8,0x942,0x700f5, + 0x8b,0x943,0x93d,0x93a,0x941,0x93e,0x200f9,0x944,0x200f8,0x944,0x700f5,0x8b, + 0x945,0x939,0x938,0x943,0x942,0x300f7,0x914,0x0,0x400fa,0x945,0x90c,0x914, + 0x200f8,0x90c,0x50041,0x10d,0x948,0x10b,0x112,0x4003d,0x35,0x949,0x948,0x4006f, + 0x12,0x959,0x949,0x50085,0x12,0x95a,0x812,0x959,0x50083,0x12,0x95d,0x959, + 0x222,0x7000c,0x12,0x96a,0x1,0x25,0x95a,0x95d,0x7000c,0x12,0x96f,0x1, + 0x28,0x222,0x96a,0x50088,0x12,0x964,0x96f,0x7be,0x4003d,0x13d,0x972,0x15c, + 0x4003d,0x151,0x973,0x153,0x50056,0x155,0x974,0x972,0x973,0x70058,0x42,0x976, + 0x974,0x964,0x2,0xe2,0x50051,0x6,0x977,0x976,0x0,0x8000c,0x6,0x97b, + 0x1,0x2b,0x977,0xe2,0xe3,0x200f9,0x914,0x200f8,0x914,0x700f5,0x6,0xb29, + 0xe2,0x944,0x97b,0x90c,0x50041,0x12e,0x97e,0x10b,0x3ad,0x4003d,0x6,0x97f, + 0x97e,0x8000c,0x6,0x985,0x1,0x2e,0xb29,0xe2,0x7fa,0x50041,0x12e,0x988, + 0x10b,0xbf2,0x4003d,0x6,0x989,0x988,0x7000c,0x6,0x98e,0x1,0x25,0x989, + 0x985,0x8000c,0x6,0x994,0x1,0x2e,0x985,0x98e,0xb0e,0x50085,0x6,0x921, + 0x994,0x1b4,0x6000c,0x6,0x922,0x1,0x1,0x921,0x500ba,0x8b,0x923,0x922, + 0xe3,0x600a9,0x6,0x924,0x923,0xe3,0xe2,0x50085,0x6,0x926,0x994,0x924, + 0x50081,0x6,0x929,0x926,0x97f,0x8000c,0x6,0x998,0x1,0x2b,0x929,0xe2, + 0xe3,0x4003d,0x165,0x99a,0x167,0x70050,0x42,0x99d,0x998,0xe2,0xe2,0xe2, + 0x40063,0x99a,0x516,0x99d,0x70050,0x42,0xc00,0x8ed,0xb0e,0x7fa,0x926,0x4003d, + 0x1ab,0x99f,0x1ad,0x40063,0x99f,0x516,0xc00,0x3003e,0x9aa,0x3b4,0x3003e,0x9be, + 0x431,0x3003e,0x9bf,0x431,0x300f7,0xa36,0x0,0x300fb,0x143,0x9c2,0x200f8,0x9c2, + 0x200f9,0x9c3,0x200f8,0x9c3,0x700f5,0x6,0xb5f,0x2f4,0x9c2,0xa89,0x9c7,0x700f5, + 0x6,0xb5a,0x3a1,0x9c2,0xa84,0x9c7,0x700f5,0x22,0xb49,0x10c,0x9c2,0x9e0, + 0x9c7,0x500b1,0x8b,0x9c6,0xb49,0x3aa,0x400f6,0x9e1,0x9c7,0x0,0x400fa,0x9c6, + 0x9c7,0x9e1,0x200f8,0x9c7,0x50041,0x4d,0x9cb,0x9aa,0xb49,0x4003d,0x35,0x9cc, + 0x9cb,0x50080,0x35,0xa49,0x516,0x9cc,0x50051,0x22,0xa4b,0x59d,0x0,0x50082, + 0x22,0xa4c,0xa4b,0x112,0x50051,0x22,0xa4e,0xa49,0x0,0x7000c,0x22,0xa5f, + 0x1,0x27,0xa4e,0xa4c,0x7000c,0x22,0xa64,0x1,0x2a,0x10c,0xa5f,0x50051, + 0x22,0xa53,0x59d,0x1,0x50082,0x22,0xa54,0xa53,0x112,0x50051,0x22,0xa56, + 0xa49,0x1,0x7000c,0x22,0xa69,0x1,0x27,0xa56,0xa54,0x7000c,0x22,0xa6e, + 0x1,0x2a,0x10c,0xa69,0x50050,0x35,0xc01,0xa64,0xa6e,0x4003d,0x13d,0xa71, + 0x179,0x7005f,0x42,0xa73,0xa71,0xc01,0x2,0x10c,0x50051,0x6,0xa74,0xa73, + 0x0,0x4003d,0x13d,0xa78,0x19f,0x7005f,0x42,0xa79,0xa78,0x1a1,0x2,0x10c, + 0x50051,0x6,0xa7a,0xa79,0x0,0x500b4,0x8b,0xa7c,0xa7a,0xe2,0x600a9,0x6, + 0xbb9,0xa7c,0xe3,0xa7a,0x50085,0x6,0x9d2,0xa74,0xbb9,0x50041,0x7,0x9d3, + 0x9ac,0xb49,0x3003e,0x9d3,0x9d2,0x4003d,0x6,0x9d7,0x9d3,0x7000c,0x6,0xa84, + 0x1,0x25,0xb5a,0x9d7,0x4003d,0x6,0x9dc,0x9d3,0x7000c,0x6,0xa89,0x1, + 0x28,0xb5f,0x9dc,0x50080,0x22,0x9e0,0xb49,0x112,0x200f9,0x9c3,0x200f8,0x9e1, + 0x200f9,0x9e2,0x200f8,0x9e2,0x700f5,0x22,0xb75,0x112,0x9e1,0xa09,0xa05,0x700f5, + 0xab,0xb50,0x1f0,0x9e1,0xba3,0xa05,0x700f5,0x6,0xb4c,0x3a1,0x9e1,0xba2, + 0xa05,0x700f5,0x6,0xb4b,0xe2,0x9e1,0xba1,0xa05,0x700f5,0x22,0xb4a,0x112, + 0x9e1,0xa07,0xa05,0x500b1,0x8b,0x9e5,0xb4a,0x3aa,0x400f6,0xa0a,0xa05,0x0, + 0x400fa,0x9e5,0x9e6,0xa0a,0x200f8,0x9e6,0x50041,0x7,0x9e8,0x9ac,0xb4a,0x4003d, + 0x6,0x9e9,0x9e8,0x50041,0x7,0x9ea,0x9ac,0x10c,0x4003d,0x6,0x9eb,0x9ea, + 0x50083,0x6,0x9ec,0x9e9,0x9eb,0x6000c,0x6,0x9ed,0x1,0x4,0x9ec,0x50083, + 0x6,0x9f0,0xb5f,0xb5a,0x50088,0x6,0x9f1,0x9ed,0x9f0,0x500b8,0x8b,0x9f3, + 0x9f1,0x3f4,0x300f7,0xa04,0x0,0x400fa,0x9f3,0x9f4,0x9f9,0x200f8,0x9f4,0x500c4, + 0xab,0x9f6,0x1f0,0xb75,0x500c5,0xab,0x9f8,0xb50,0x9f6,0x200f9,0xa04,0x200f8, + 0x9f9,0x4003d,0x6,0x9fd,0x9e8,0x7000c,0x6,0xa8e,0x1,0x25,0xb4c,0x9fd, + 0x4003d,0x6,0xa02,0x9e8,0x7000c,0x6,0xa93,0x1,0x28,0xb4b,0xa02,0x200f9, + 0xa04,0x200f8,0xa04,0x700f5,0xab,0xba3,0x9f8,0x9f4,0xb50,0x9f9,0x700f5,0x6, + 0xba2,0xb4c,0x9f4,0xa8e,0x9f9,0x700f5,0x6,0xba1,0xb4b,0x9f4,0xa93,0x9f9, + 0x200f9,0xa05,0x200f8,0xa05,0x50080,0x22,0xa07,0xb4a,0x112,0x50080,0x22,0xa09, + 0xb75,0x112,0x200f9,0x9e2,0x200f8,0xa0a,0x50041,0x7,0xa0b,0x9ac,0x10c,0x4003d, + 0x6,0xa0c,0xa0b,0x500ba,0x8b,0xa0e,0xa0c,0xb4b,0x400a8,0x8b,0xa0f,0xa0e, + 0x300f7,0xa15,0x0,0x400fa,0xa0f,0xa10,0xa15,0x200f8,0xa10,0x4003d,0x6,0xa12, + 0xa0b,0x500b8,0x8b,0xa14,0xa12,0xb4c,0x200f9,0xa15,0x200f8,0xa15,0x700f5,0x8b, + 0xa16,0xa0e,0xa0a,0xa14,0xa10,0x400a8,0x8b,0xa18,0xa16,0x300f7,0xa1a,0x0, + 0x400fa,0xa18,0xa19,0xa1a,0x200f8,0xa19,0x200f9,0xa36,0x200f8,0xa1a,0x200f9,0xa1b, + 0x200f8,0xa1b,0x700f5,0x22,0xb4d,0x10c,0xa1a,0xa2e,0xa2c,0x4007c,0xab,0xa1e, + 0xb4d,0x500b0,0x8b,0xa1f,0xa1e,0xac,0x400f6,0xa2f,0xa2c,0x0,0x400fa,0xa1f, + 0xa20,0xa2f,0x200f8,0xa20,0x50041,0x3dc,0xa23,0x9be,0xb4d,0x4003d,0xab,0xa24, + 0xa23,0x500c7,0xab,0xa25,0xb50,0xa24,0x50041,0x3dc,0xa27,0x9bf,0xb4d,0x4003d, + 0xab,0xa28,0xa27,0x500aa,0x8b,0xa29,0xa25,0xa28,0x300f7,0xa2b,0x0,0x400fa, + 0xa29,0xa2a,0xa2b,0x200f8,0xa2a,0x200f9,0xa2f,0x200f8,0xa2b,0x200f9,0xa2c,0x200f8, + 0xa2c,0x50080,0x22,0xa2e,0xb4d,0x112,0x200f9,0xa1b,0x200f8,0xa2f,0x700f5,0x6, + 0xb61,0xb6d,0xa1b,0xe2,0xa2a,0x700f5,0x8b,0xb51,0x41c,0xa1b,0x2c0,0xa2a, + 0x300f7,0xa31,0x0,0x400fa,0xb51,0xa36,0xa31,0x200f8,0xa31,0x50088,0x6,0xa34, + 0xb5a,0xb5f,0x50083,0x6,0xa35,0xe3,0xa34,0x200f9,0xa36,0x200f8,0xa36,0x900f5, + 0x6,0xb60,0xe2,0xa19,0xb61,0xa2f,0xa35,0xa31,0x500ba,0x8b,0x593,0xb60, + 0x506,0x300f7,0x599,0x0,0x400fa,0x593,0x594,0x599,0x200f8,0x594,0x50083,0x12, + 0xa9e,0x55b,0x7ac,0x50088,0x12,0xaa2,0xa9e,0x55d,0x50041,0x10d,0xab4,0x10b, + 0x11c,0x4003d,0x35,0xab5,0xab4,0x4006f,0x12,0xaa4,0xab5,0x50085,0x12,0xaa5, + 0xaa2,0xaa4,0x6000c,0x12,0xaa7,0x1,0x8,0xaa5,0x4006e,0x35,0xaa8,0xaa7, + 0x4003d,0x165,0xab7,0x180,0x70050,0x42,0xaba,0xb60,0xe2,0xe2,0xe2,0x40063, + 0xab7,0xaa8,0xaba,0x200f9,0x599,0x200f8,0x599,0x100fd,0x10038, +}; +static const char *fu1_prepare_reactivity_pass_0_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu1_prepare_reactivity_pass_0_cb_bind[] = {12}; +static const uint32_t fu1_prepare_reactivity_pass_0_cb_count[] = {1}; +static const uint32_t fu1_prepare_reactivity_pass_0_cb_space[] = {0}; +static const char *fu1_prepare_reactivity_pass_0_srv_tex_names[] = {"r_reconstructed_previous_nearest_depth", "r_dilated_motion_vectors", "r_dilated_depth", "r_reactive_mask", "r_transparency_and_composition_mask", "r_accumulation", "r_shading_change", "r_current_luma", "r_input_exposure"}; +static const uint32_t fu1_prepare_reactivity_pass_0_srv_tex_bind[] = {0, 1, 2, 3, 4, 5, 6, 7, 8}; +static const uint32_t fu1_prepare_reactivity_pass_0_srv_tex_count[] = {1, 1, 1, 1, 1, 1, 1, 1, 1}; +static const uint32_t fu1_prepare_reactivity_pass_0_srv_tex_space[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; +static const char *fu1_prepare_reactivity_pass_0_uav_tex_names[] = {"rw_dilated_reactive_masks", "rw_new_locks", "rw_accumulation"}; +static const uint32_t fu1_prepare_reactivity_pass_0_uav_tex_bind[] = {9, 10, 11}; +static const uint32_t fu1_prepare_reactivity_pass_0_uav_tex_count[] = {1, 1, 1}; +static const uint32_t fu1_prepare_reactivity_pass_0_uav_tex_space[] = {0, 0, 0}; +static const char *fu1_prepare_reactivity_pass_0_sampler_names[] = {"s_LinearClamp"}; +static const uint32_t fu1_prepare_reactivity_pass_0_sampler_bind[] = {1001}; +static const uint32_t fu1_prepare_reactivity_pass_0_sampler_count[] = {1}; +static const uint32_t fu1_prepare_reactivity_pass_0_sampler_space[] = {0}; + +static const uint32_t fu1_luma_instability_pass_0_spv[1586] = { + 0x7230203,0x10500,0x8000b,0x57d,0x0,0x20011,0x1,0x20011,0x31,0x20011,0x32,0x6000b, + 0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0xf000f,0x5,0x4,0x6e69616d, + 0x0,0x95,0xb9,0xbf,0xc3,0xda,0xe5,0xea,0xf2,0xfe,0x264,0x60010, + 0x4,0x11,0x8,0x8,0x1,0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61, + 0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0,0x80004,0x455f4c47,0x735f5458,0x65646168,0x36315f72, + 0x5f746962,0x726f7473,0x656761,0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d, + 0x79745f63,0x736570,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576, + 0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669,0x40005,0x4,0x6e69616d,0x0, + 0x70005,0x93,0x53466263,0x50553352,0x4c414353,0x745f5245,0x0,0x60006,0x93,0x0,0x6e655269,0x53726564, + 0x657a69,0xa0006,0x93,0x1,0x65725069,0x756f6976,0x61724673,0x6552656d,0x7265646e,0x657a6953,0x0,0x70006, + 0x93,0x2,0x78614d69,0x646e6552,0x69537265,0x657a,0x50006,0x93,0x3,0x74694a66,0x726574,0x90006, + 0x93,0x4,0x65725066,0x756f6976,0x61724673,0x694a656d,0x72657474,0x0,0x80006,0x93,0x5,0x6c654466, + 0x72506174,0x70784565,0x7275736f,0x65,0x60005,0x95,0x53466263,0x70553352,0x6c616373,0x7265,0x60005,0xb9, + 0x6c5f7772,0x5f616d75,0x74736968,0x79726f,0x60005,0xbf,0x756c5f72,0x685f616d,0x6f747369,0x7972,0x60005,0xc3, + 0x694c5f73,0x7261656e,0x6d616c43,0x70,0x60005,0xda,0x75635f72,0x6e657272,0x756c5f74,0x616d,0x70005,0xe5, + 0x6c5f7772,0x5f616d75,0x74736e69,0x6c696261,0x797469,0x90005,0xea,0x69645f72,0x6574616c,0x6f6d5f64,0x6e6f6974,0x6365765f, + 0x73726f74,0x0,0x70005,0xf2,0x6e695f72,0x5f747570,0x6f707865,0x65727573,0x0,0x90005,0xfe,0x69645f72, + 0x6574616c,0x65725f64,0x69746361,0x6d5f6576,0x736b7361,0x0,0x80005,0x264,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f, + 0x496e6f69,0x44,0x30047,0x93,0x2,0x50048,0x93,0x0,0x23,0x0,0x50048,0x93, + 0x1,0x23,0x8,0x50048,0x93,0x2,0x23,0x20,0x50048,0x93,0x3,0x23, + 0x40,0x50048,0x93,0x4,0x23,0x48,0x50048,0x93,0x5,0x23,0x74,0x40047, + 0x95,0x21,0x9,0x40047,0x95,0x22,0x0,0x40047,0xb9,0x21,0x7,0x40047, + 0xb9,0x22,0x0,0x40047,0xbf,0x21,0x4,0x40047,0xbf,0x22,0x0,0x40047, + 0xc3,0x21,0x3e9,0x40047,0xc3,0x22,0x0,0x40047,0xda,0x21,0x6,0x40047, + 0xda,0x22,0x0,0x40047,0xe5,0x21,0x8,0x40047,0xe5,0x22,0x0,0x40047, + 0xea,0x21,0x2,0x40047,0xea,0x22,0x0,0x40047,0xf2,0x21,0x0,0x40047, + 0xf2,0x22,0x0,0x40047,0xfe,0x21,0x1,0x40047,0xfe,0x22,0x0,0x40047, + 0x264,0xb,0x1c,0x40047,0x279,0xb,0x19,0x20013,0x2,0x30021,0x3,0x2, + 0x30016,0x6,0x20,0x40020,0x7,0x7,0x6,0x40017,0x11,0x6,0x2,0x40015, + 0x20,0x20,0x1,0x40017,0x21,0x20,0x2,0x40017,0x32,0x6,0x4,0x40020, + 0x33,0x7,0x32,0x20014,0x62,0x4002b,0x6,0x7a,0x0,0x4002b,0x6,0x7b, + 0x3f800000,0x8001e,0x93,0x21,0x21,0x21,0x11,0x11,0x6,0x40020,0x94,0x2, + 0x93,0x4003b,0x94,0x95,0x2,0x4002b,0x20,0x96,0x0,0x40020,0x97,0x2, + 0x21,0x4002b,0x20,0x9c,0x1,0x40020,0xa7,0x2,0x11,0x40020,0xb2,0x2, + 0x6,0x90019,0xb7,0x6,0x1,0x0,0x0,0x0,0x2,0x2,0x40020,0xb8, + 0x0,0xb7,0x4003b,0xb8,0xb9,0x0,0x90019,0xbd,0x6,0x1,0x0,0x0, + 0x0,0x1,0x0,0x40020,0xbe,0x0,0xbd,0x4003b,0xbe,0xbf,0x0,0x2001a, + 0xc1,0x40020,0xc2,0x0,0xc1,0x4003b,0xc2,0xc3,0x0,0x3001b,0xc5,0xbd, + 0x40015,0xd5,0x20,0x0,0x4002b,0xd5,0xd6,0x0,0x4003b,0xbe,0xda,0x0, + 0x90019,0xe3,0x6,0x1,0x0,0x0,0x0,0x2,0x9,0x40020,0xe4,0x0, + 0xe3,0x4003b,0xe4,0xe5,0x0,0x4003b,0xbe,0xea,0x0,0x4003b,0xbe,0xf2, + 0x0,0x5002c,0x21,0xf4,0x96,0x96,0x4003b,0xbe,0xfe,0x0,0x4002b,0x6, + 0x107,0x45700000,0x4002b,0x6,0x108,0x45070000,0x5002c,0x11,0x109,0x107,0x108,0x4002b, + 0xd5,0x13d,0x1,0x4002b,0x6,0x150,0x3f000000,0x5002c,0x11,0x151,0x150,0x150, + 0x4002b,0x20,0x17d,0x3,0x4002b,0xd5,0x19d,0x2,0x4002b,0xd5,0x1a0,0x3, + 0x7002c,0x32,0x1bc,0x7a,0x7a,0x7a,0x7a,0x4002b,0x6,0x204,0x3f666666,0x40017, + 0x262,0xd5,0x3,0x40020,0x263,0x1,0x262,0x4003b,0x263,0x264,0x1,0x40017, + 0x265,0xd5,0x2,0x4002b,0xd5,0x278,0x8,0x6002c,0x262,0x279,0x278,0x278, + 0x13d,0x4002b,0x6,0x56f,0x3d4ccccd,0x4002b,0xd5,0x57b,0x4,0x4002b,0xd5,0x57c, + 0x5,0x50036,0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003b,0x33,0x4f9,0x7, + 0x4003d,0x262,0x266,0x264,0x7004f,0x265,0x267,0x266,0x266,0x0,0x1,0x4007c, + 0x21,0x268,0x267,0x4003d,0xbd,0x320,0xea,0x7005f,0x32,0x322,0x320,0x268, + 0x2,0x96,0x7004f,0x11,0x323,0x322,0x322,0x0,0x1,0x4006f,0x11,0x2b3, + 0x268,0x50081,0x11,0x2b5,0x2b3,0x151,0x50041,0x97,0x326,0x95,0x96,0x4003d, + 0x21,0x327,0x326,0x4006f,0x11,0x2b7,0x327,0x50088,0x11,0x2b8,0x2b5,0x2b7, + 0x50041,0xa7,0x32a,0x95,0x1a0,0x4003d,0x11,0x32b,0x32a,0x50088,0x11,0x2bd, + 0x32b,0x2b7,0x50081,0x11,0x2be,0x2b8,0x2bd,0x50041,0xa7,0x332,0x95,0x57b, + 0x4003d,0x11,0x333,0x332,0x50041,0x97,0x336,0x95,0x9c,0x4003d,0x21,0x337, + 0x336,0x4006f,0x11,0x2c2,0x337,0x50088,0x11,0x2c3,0x333,0x2c2,0x50081,0x11, + 0x2c4,0x2b8,0x2c3,0x50081,0x11,0x2c7,0x2c4,0x323,0x50051,0x6,0x33b,0x2c7, + 0x0,0x500be,0x62,0x33c,0x33b,0x7a,0x300f7,0x341,0x0,0x400fa,0x33c,0x33d, + 0x341,0x200f8,0x33d,0x500bc,0x62,0x340,0x33b,0x7b,0x200f9,0x341,0x200f8,0x341, + 0x700f5,0x62,0x342,0x33c,0x5,0x340,0x33d,0x300f7,0x34d,0x0,0x400fa,0x342, + 0x343,0x34d,0x200f8,0x343,0x50051,0x6,0x345,0x2c7,0x1,0x500be,0x62,0x346, + 0x345,0x7a,0x300f7,0x34b,0x0,0x400fa,0x346,0x347,0x34b,0x200f8,0x347,0x500bc, + 0x62,0x34a,0x345,0x7b,0x200f9,0x34b,0x200f8,0x34b,0x700f5,0x62,0x34c,0x346, + 0x343,0x34a,0x347,0x200f9,0x34d,0x200f8,0x34d,0x700f5,0x62,0x34e,0x342,0x341, + 0x34c,0x34b,0x300f7,0x315,0x0,0x400fa,0x34e,0x2ca,0x315,0x200f8,0x2ca,0x50041, + 0x97,0x355,0x95,0x19d,0x4003d,0x21,0x356,0x355,0x50085,0x11,0x363,0x2be, + 0x2b7,0x50083,0x11,0x366,0x2b7,0x151,0x7000c,0x11,0x373,0x1,0x25,0x363, + 0x366,0x7000c,0x11,0x378,0x1,0x28,0x151,0x373,0x4006f,0x11,0x36c,0x356, + 0x50088,0x11,0x36d,0x378,0x36c,0x4003d,0xbd,0x37b,0xfe,0x4003d,0xc1,0x37c, + 0xc3,0x50056,0xc5,0x37d,0x37b,0x37c,0x70058,0x32,0x37f,0x37d,0x36d,0x2, + 0x7a,0x50051,0x6,0x2d2,0x37f,0x0,0x8000c,0x6,0x383,0x1,0x2b,0x2d2, + 0x7a,0x7b,0x50051,0x6,0x2d5,0x37f,0x1,0x8000c,0x6,0x387,0x1,0x2b, + 0x2d5,0x7a,0x7b,0x50051,0x6,0x2d8,0x37f,0x2,0x8000c,0x6,0x38b,0x1, + 0x2b,0x2d8,0x7a,0x7b,0x50051,0x6,0x2db,0x37f,0x3,0x8000c,0x6,0x38f, + 0x1,0x2b,0x2db,0x7a,0x7b,0x500ba,0x62,0x2de,0x38f,0x204,0x300f7,0x314, + 0x0,0x400fa,0x2de,0x2e1,0x314,0x200f8,0x2e1,0x4003d,0xbd,0x3bc,0xda,0x4003d, + 0xc1,0x3bd,0xc3,0x50056,0xc5,0x3be,0x3bc,0x3bd,0x70058,0x32,0x3c0,0x3be, + 0x36d,0x2,0x7a,0x50051,0x6,0x3c1,0x3c0,0x0,0x4003d,0xbd,0x3c5,0xf2, + 0x7005f,0x32,0x3c6,0x3c5,0xf4,0x2,0x96,0x50051,0x6,0x3c7,0x3c6,0x0, + 0x500b4,0x62,0x3c9,0x3c7,0x7a,0x600a9,0x6,0x570,0x3c9,0x7b,0x3c7,0x50085, + 0x6,0x2e9,0x3c1,0x570,0x50085,0x11,0x3e1,0x2c7,0x2c2,0x50083,0x11,0x3e4, + 0x2c2,0x151,0x7000c,0x11,0x3f1,0x1,0x25,0x3e1,0x3e4,0x7000c,0x11,0x3f6, + 0x1,0x28,0x151,0x3f1,0x50088,0x11,0x3eb,0x3f6,0x36c,0x4003d,0xbd,0x3f9, + 0xbf,0x4003d,0xc1,0x3fa,0xc3,0x50056,0xc5,0x3fb,0x3f9,0x3fa,0x70058,0x32, + 0x3fd,0x3fb,0x3eb,0x2,0x7a,0x50041,0xb2,0x400,0x95,0x57c,0x4003d,0x6, + 0x401,0x400,0x5008e,0x32,0x2f1,0x3fd,0x401,0x4003d,0xbd,0x405,0xf2,0x7005f, + 0x32,0x406,0x405,0xf4,0x2,0x96,0x50051,0x6,0x407,0x406,0x0,0x500b4, + 0x62,0x409,0x407,0x7a,0x600a9,0x6,0x571,0x409,0x7b,0x407,0x5008e,0x32, + 0x2f3,0x2f1,0x571,0x3003e,0x4f9,0x2f3,0x50041,0x7,0x4fd,0x4f9,0xd6,0x4003d, + 0x6,0x44c,0x4fd,0x50083,0x6,0x44d,0x2e9,0x44c,0x4003d,0x6,0x450,0x4fd, + 0x7000c,0x6,0x4a7,0x1,0x28,0x2e9,0x450,0x500b7,0x62,0x49b,0x4a7,0x7a, + 0x300f7,0x4a1,0x0,0x400fa,0x49b,0x49c,0x4a0,0x200f8,0x49c,0x7000c,0x6,0x4ac, + 0x1,0x25,0x2e9,0x450,0x50088,0x6,0x49f,0x4ac,0x4a7,0x200f9,0x4a1,0x200f8, + 0x4a0,0x200f9,0x4a1,0x200f8,0x4a1,0x700f5,0x6,0x51d,0x49f,0x49c,0x7b,0x4a0, + 0x500b8,0x62,0x454,0x51d,0x7b,0x300f7,0x477,0x0,0x400fa,0x454,0x455,0x477, + 0x200f8,0x455,0x200f9,0x456,0x200f8,0x456,0x700f5,0x6,0x51f,0x51d,0x455,0x55d, + 0x46f,0x700f5,0x20,0x51e,0x9c,0x455,0x471,0x46f,0x500b3,0x62,0x459,0x51e, + 0x17d,0x400f6,0x472,0x46f,0x0,0x400fa,0x459,0x45a,0x472,0x200f8,0x45a,0x50041, + 0x7,0x4ff,0x4f9,0x51e,0x4003d,0x6,0x45e,0x4ff,0x50083,0x6,0x45f,0x2e9, + 0x45e,0x4003d,0x6,0x463,0x4ff,0x7000c,0x6,0x4c3,0x1,0x28,0x2e9,0x463, + 0x500b7,0x62,0x4b7,0x4c3,0x7a,0x300f7,0x4bd,0x0,0x400fa,0x4b7,0x4b8,0x4bc, + 0x200f8,0x4b8,0x7000c,0x6,0x4c8,0x1,0x25,0x2e9,0x463,0x50088,0x6,0x4bb, + 0x4c8,0x4c3,0x200f9,0x4bd,0x200f8,0x4bc,0x200f9,0x4bd,0x200f8,0x4bd,0x700f5,0x6, + 0x555,0x4bb,0x4b8,0x7a,0x4bc,0x6000c,0x6,0x466,0x1,0x6,0x44d,0x6000c, + 0x6,0x468,0x1,0x6,0x45f,0x500b4,0x62,0x469,0x466,0x468,0x300f7,0x46e, + 0x0,0x400fa,0x469,0x46a,0x46e,0x200f8,0x46a,0x7000c,0x6,0x4cd,0x1,0x28, + 0x51f,0x555,0x200f9,0x46e,0x200f8,0x46e,0x700f5,0x6,0x55d,0x51f,0x4bd,0x4cd, + 0x46a,0x200f9,0x46f,0x200f8,0x46f,0x50080,0x20,0x471,0x51e,0x9c,0x200f9,0x456, + 0x200f8,0x472,0x500ba,0x62,0x475,0x51f,0x51d,0x600a9,0x6,0x476,0x475,0x7b, + 0x7a,0x200f9,0x477,0x200f8,0x477,0x700f5,0x6,0x526,0x7a,0x4a1,0x476,0x472, + 0x50041,0x7,0x501,0x4f9,0x19d,0x4003d,0x6,0x479,0x501,0x50041,0x7,0x502, + 0x4f9,0x1a0,0x3003e,0x502,0x479,0x50041,0x7,0x503,0x4f9,0x13d,0x4003d,0x6, + 0x47c,0x503,0x3003e,0x501,0x47c,0x4003d,0x6,0x47f,0x4fd,0x3003e,0x503,0x47f, + 0x3003e,0x4fd,0x2e9,0x4003d,0xbd,0x4d1,0xf2,0x7005f,0x32,0x4d2,0x4d1,0xf4, + 0x2,0x96,0x50051,0x6,0x4d3,0x4d2,0x0,0x500b4,0x62,0x4d5,0x4d3,0x7a, + 0x600a9,0x6,0x572,0x4d5,0x7b,0x4d3,0x4003d,0x32,0x485,0x4f9,0x70050,0x32, + 0x486,0x572,0x572,0x572,0x572,0x50088,0x32,0x487,0x485,0x486,0x3003e,0x4f9, + 0x487,0x4003d,0x6,0x48b,0x502,0x500b7,0x62,0x48c,0x48b,0x7a,0x600a9,0x6, + 0x48d,0x48c,0x7b,0x7a,0x50085,0x6,0x48e,0x526,0x48d,0x50085,0x11,0x4dc, + 0x323,0x109,0x6000c,0x6,0x4dd,0x1,0x42,0x4dc,0x50085,0x6,0x303,0x4dd, + 0x56f,0x8000c,0x6,0x4e1,0x1,0x2b,0x303,0x7a,0x7b,0x50083,0x6,0x305, + 0x7b,0x4e1,0x50083,0x6,0x308,0x7b,0x387,0x50085,0x6,0x309,0x305,0x308, + 0x50083,0x6,0x30b,0x7b,0x383,0x50085,0x6,0x30c,0x309,0x30b,0x50083,0x6, + 0x30e,0x7b,0x38b,0x50085,0x6,0x30f,0x30c,0x30e,0x50085,0x6,0x312,0x48e, + 0x30f,0x200f9,0x314,0x200f8,0x314,0x700f5,0x6,0x554,0x7a,0x2ca,0x312,0x477, + 0x700f5,0x32,0x552,0x1bc,0x2ca,0x487,0x477,0x200f9,0x315,0x200f8,0x315,0x700f5, + 0x6,0x553,0x7a,0x34d,0x554,0x314,0x700f5,0x32,0x54e,0x1bc,0x34d,0x552, + 0x314,0x4003d,0xb7,0x4e3,0xb9,0x40063,0x4e3,0x268,0x54e,0x4003d,0xe3,0x4e7, + 0xe5,0x70050,0x32,0x4ea,0x553,0x7a,0x7a,0x7a,0x40063,0x4e7,0x268,0x4ea, + 0x100fd,0x10038, +}; +static const char *fu1_luma_instability_pass_0_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu1_luma_instability_pass_0_cb_bind[] = {9}; +static const uint32_t fu1_luma_instability_pass_0_cb_count[] = {1}; +static const uint32_t fu1_luma_instability_pass_0_cb_space[] = {0}; +static const char *fu1_luma_instability_pass_0_srv_tex_names[] = {"r_input_exposure", "r_dilated_reactive_masks", "r_dilated_motion_vectors", "r_luma_history", "r_current_luma"}; +static const uint32_t fu1_luma_instability_pass_0_srv_tex_bind[] = {0, 1, 2, 4, 6}; +static const uint32_t fu1_luma_instability_pass_0_srv_tex_count[] = {1, 1, 1, 1, 1}; +static const uint32_t fu1_luma_instability_pass_0_srv_tex_space[] = {0, 0, 0, 0, 0}; +static const char *fu1_luma_instability_pass_0_uav_tex_names[] = {"rw_luma_history", "rw_luma_instability"}; +static const uint32_t fu1_luma_instability_pass_0_uav_tex_bind[] = {7, 8}; +static const uint32_t fu1_luma_instability_pass_0_uav_tex_count[] = {1, 1}; +static const uint32_t fu1_luma_instability_pass_0_uav_tex_space[] = {0, 0}; +static const char *fu1_luma_instability_pass_0_sampler_names[] = {"s_LinearClamp"}; +static const uint32_t fu1_luma_instability_pass_0_sampler_bind[] = {1001}; +static const uint32_t fu1_luma_instability_pass_0_sampler_count[] = {1}; +static const uint32_t fu1_luma_instability_pass_0_sampler_space[] = {0}; + +static const uint32_t fu1_accumulate_pass_0_spv[4784] = { + 0x7230203,0x10500,0x8000b,0x18af,0x0,0x20011,0x1,0x20011,0x16,0x20011,0x31,0x20011, + 0x32,0x20011,0x38,0x6000b,0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1, + 0x12000f,0x5,0x4,0x6e69616d,0x0,0x160,0x193,0x19a,0x19e,0x1a8,0x1ae,0x1b6, + 0x1c5,0x1d0,0x1db,0x1e3,0x1ef,0x7be,0x60010,0x4,0x11,0x8,0x8,0x1, + 0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75, + 0x736e6f69,0x0,0x80004,0x455f4c47,0x735f5458,0x65646168,0x36315f72,0x5f746962,0x726f7473,0x656761,0xb0004,0x455f4c47, + 0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004,0x455f4c47,0x735f5458, + 0x65646168,0x6d695f72,0x5f656761,0x64616f6c,0x726f665f,0x7474616d,0x6465,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70, + 0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572, + 0x657669,0x40005,0x4,0x6e69616d,0x0,0x70005,0x15e,0x53466263,0x50553352,0x4c414353,0x745f5245,0x0, + 0x60006,0x15e,0x0,0x6e655269,0x53726564,0x657a69,0x70006,0x15e,0x1,0x73705569,0x656c6163,0x657a6953, + 0x0,0x70006,0x15e,0x2,0x78614d69,0x646e6552,0x69537265,0x657a,0x50006,0x15e,0x3,0x74694a66, + 0x726574,0x80006,0x15e,0x4,0x776f4466,0x6163736e,0x6146656c,0x726f7463,0x0,0x90006,0x15e,0x5, + 0x74694a66,0x53726574,0x65757165,0x4c65636e,0x74676e65,0x68,0x80006,0x15e,0x6,0x6c654466,0x72506174,0x70784565, + 0x7275736f,0x65,0x60006,0x15e,0x7,0x61724666,0x6e49656d,0x786564,0x70006,0x15e,0x8,0x6c655666, + 0x7469636f,0x63614679,0x726f74,0x60005,0x160,0x53466263,0x70553352,0x6c616373,0x7265,0x80005,0x193,0x6e695f72, + 0x5f747570,0x6f6c6f63,0x696a5f72,0x72657474,0x6465,0x90005,0x19a,0x6e695f72,0x6e726574,0x755f6c61,0x61637370,0x5f64656c, + 0x6f6c6f63,0x72,0x60005,0x19e,0x694c5f73,0x7261656e,0x6d616c43,0x70,0x90005,0x1a8,0x695f7772,0x7265746e, + 0x5f6c616e,0x63737075,0x64656c61,0x6c6f635f,0x726f,0x70005,0x1ae,0x755f7772,0x61637370,0x5f64656c,0x7074756f,0x7475, + 0x80005,0x1b6,0x61665f72,0x65687472,0x645f7473,0x68747065,0x70696d5f,0x31,0x70005,0x1c5,0x756c5f72,0x695f616d, + 0x6174736e,0x696c6962,0x7974,0x60005,0x1d0,0x6e5f7772,0x6c5f7765,0x736b636f,0x0,0x90005,0x1db,0x69645f72, + 0x6574616c,0x6f6d5f64,0x6e6f6974,0x6365765f,0x73726f74,0x0,0x70005,0x1e3,0x6e695f72,0x5f747570,0x6f707865,0x65727573, + 0x0,0x90005,0x1ef,0x69645f72,0x6574616c,0x65725f64,0x69746361,0x6d5f6576,0x736b7361,0x0,0x80005,0x7be, + 0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x44,0x30047,0x15e,0x2,0x50048,0x15e,0x0, + 0x23,0x0,0x50048,0x15e,0x1,0x23,0x10,0x50048,0x15e,0x2,0x23,0x20, + 0x50048,0x15e,0x3,0x23,0x40,0x50048,0x15e,0x4,0x23,0x58,0x50048,0x15e, + 0x5,0x23,0x6c,0x50048,0x15e,0x6,0x23,0x74,0x50048,0x15e,0x7,0x23, + 0x7c,0x50048,0x15e,0x8,0x23,0x80,0x40047,0x160,0x21,0xc,0x40047,0x160, + 0x22,0x0,0x40047,0x193,0x21,0x8,0x40047,0x193,0x22,0x0,0x40047,0x19a, + 0x21,0x3,0x40047,0x19a,0x22,0x0,0x40047,0x19e,0x21,0x3e9,0x40047,0x19e, + 0x22,0x0,0x30047,0x1a8,0x19,0x40047,0x1a8,0x21,0x9,0x40047,0x1a8,0x22, + 0x0,0x30047,0x1ae,0x19,0x40047,0x1ae,0x21,0xa,0x40047,0x1ae,0x22,0x0, + 0x40047,0x1b6,0x21,0x5,0x40047,0x1b6,0x22,0x0,0x40047,0x1c5,0x21,0x7, + 0x40047,0x1c5,0x22,0x0,0x40047,0x1d0,0x21,0xb,0x40047,0x1d0,0x22,0x0, + 0x40047,0x1db,0x21,0x2,0x40047,0x1db,0x22,0x0,0x40047,0x1e3,0x21,0x0, + 0x40047,0x1e3,0x22,0x0,0x40047,0x1ef,0x21,0x1,0x40047,0x1ef,0x22,0x0, + 0x40047,0x7be,0xb,0x1c,0x40047,0x7cf,0xb,0x19,0x20013,0x2,0x30021,0x3, + 0x2,0x30016,0x6,0x20,0x40017,0xe,0x6,0x3,0x40020,0xf,0x7,0xe, + 0x40017,0x1f,0x6,0x2,0x40015,0x2b,0x20,0x1,0x40017,0x3e,0x6,0x4, + 0x40017,0x4d,0x2b,0x2,0x20014,0x9c,0x4002b,0x6,0x127,0x0,0x4002b,0x6, + 0x128,0x3f800000,0xb001e,0x15e,0x4d,0x4d,0x4d,0x1f,0x1f,0x6,0x6,0x6, + 0x6,0x40020,0x15f,0x2,0x15e,0x4003b,0x15f,0x160,0x2,0x4002b,0x2b,0x161, + 0x0,0x40020,0x162,0x2,0x4d,0x4002b,0x2b,0x16c,0x2,0x40020,0x172,0x2, + 0x1f,0x40020,0x17d,0x2,0x6,0x90019,0x191,0x6,0x1,0x0,0x0,0x0, + 0x1,0x0,0x40020,0x192,0x0,0x191,0x4003b,0x192,0x193,0x0,0x4003b,0x192, + 0x19a,0x0,0x2001a,0x19c,0x40020,0x19d,0x0,0x19c,0x4003b,0x19d,0x19e,0x0, + 0x3001b,0x1a0,0x191,0x90019,0x1a6,0x6,0x1,0x0,0x0,0x0,0x2,0x2, + 0x40020,0x1a7,0x0,0x1a6,0x4003b,0x1a7,0x1a8,0x0,0x90019,0x1ac,0x6,0x1, + 0x0,0x0,0x0,0x2,0x0,0x40020,0x1ad,0x0,0x1ac,0x4003b,0x1ad,0x1ae, + 0x0,0x4003b,0x192,0x1b6,0x0,0x40015,0x1c0,0x20,0x0,0x4003b,0x192,0x1c5, + 0x0,0x90019,0x1ce,0x6,0x1,0x0,0x0,0x0,0x2,0xf,0x40020,0x1cf, + 0x0,0x1ce,0x4003b,0x1cf,0x1d0,0x0,0x4003b,0x192,0x1db,0x0,0x4003b,0x192, + 0x1e3,0x0,0x5002c,0x4d,0x1e5,0x161,0x161,0x4003b,0x192,0x1ef,0x0,0x4002b, + 0x6,0x1f8,0x45700000,0x4002b,0x6,0x1f9,0x45070000,0x5002c,0x1f,0x1fa,0x1f8,0x1f9, + 0x4002b,0x2b,0x200,0x3,0x4002b,0x2b,0x206,0x1,0x4002b,0x6,0x233,0x800000, + 0x4002b,0x1c0,0x25b,0x1,0x4002b,0x6,0x275,0x3e800000,0x4002b,0x6,0x279,0x3f000000, + 0x4002b,0x6,0x289,0xbe800000,0x4002b,0x6,0x2af,0x387fda40,0x5002c,0x1f,0x300,0x279, + 0x279,0x40017,0x314,0x1c0,0x2,0x40017,0x318,0x9c,0x2,0x4002b,0x6,0x31e, + 0x3ecccccd,0x4002b,0x6,0x326,0x3fc80000,0x4002b,0x6,0x32b,0x3f100000,0x4002b,0x6,0x333, + 0x40800000,0x4002b,0x6,0x359,0x3ffeb852,0x6002c,0xe,0x361,0x127,0x127,0x127,0x4002b, + 0x2b,0x38d,0xfffffffe,0x4002b,0x2b,0x38e,0xffffffff,0x4002b,0x1c0,0x3dc,0x9,0x4001c, + 0x3dd,0xe,0x3dc,0x40020,0x3de,0x7,0x3dd,0x4002b,0x2b,0x3f4,0x9,0x4002b, + 0x6,0x40b,0x3e99999a,0x4002b,0x6,0x418,0x40a00000,0x4002b,0x6,0x483,0xc0133333,0x4002b, + 0x6,0x4bb,0x3d3d70a4,0x40015,0x4dc,0x10,0x1,0x40017,0x4dd,0x4dc,0x2,0x4002b, + 0x6,0x502,0xbf000000,0x4002b,0x6,0x510,0xc0200000,0x4002b,0x6,0x511,0x3fc00000,0x4002b, + 0x6,0x51c,0x40000000,0x7002c,0x3e,0x59e,0x127,0x127,0x127,0x127,0x4002b,0x6, + 0x608,0x3f400000,0x4002b,0x6,0x62d,0x40400000,0x4002b,0x6,0x636,0x3fd9999a,0x6002c,0xe, + 0x637,0x636,0x128,0x128,0x4002b,0x6,0x63c,0x340018ef,0x6002c,0xe,0x63d,0x63c, + 0x63c,0x63c,0x4002b,0x6,0x6b7,0x3dcccccd,0x4002b,0x6,0x6d7,0x3e19999a,0x4002b,0x6, + 0x757,0x42c80000,0x40017,0x7bc,0x1c0,0x3,0x40020,0x7bd,0x1,0x7bc,0x4003b,0x7bd, + 0x7be,0x1,0x4002b,0x1c0,0x7ce,0x8,0x6002c,0x7bc,0x7cf,0x7ce,0x7ce,0x25b, + 0x30001,0x6,0x14ae,0x30001,0xe,0x14b1,0x5002c,0x4d,0x17ef,0x16c,0x16c,0x5002c, + 0x1f,0x17f0,0x128,0x128,0x5002c,0x1f,0x17f1,0x502,0x502,0x5002c,0x1f,0x17f2, + 0x510,0x510,0x5002c,0x1f,0x17f3,0x51c,0x51c,0x4002b,0x6,0x17f4,0x40200000,0x5002c, + 0x1f,0x17f5,0x17f4,0x17f4,0x4002b,0x6,0x17f8,0x3d4ccccd,0x4002b,0x1c0,0x189d,0x3, + 0x4002b,0x1c0,0x189e,0x2,0x4002b,0x1c0,0x189f,0x7,0x4002b,0x1c0,0x18a0,0x6, + 0x4002b,0x1c0,0x18a1,0x5,0x4002b,0x1c0,0x18a2,0x4,0x50036,0x2,0x4,0x0, + 0x3,0x200f8,0x5,0x4003b,0x3de,0xbb1,0x7,0x4003d,0x7bc,0x7bf,0x7be,0x7004f, + 0x314,0x7c0,0x7bf,0x7bf,0x0,0x1,0x4007c,0x4d,0x7c1,0x7c0,0x4006f,0x1f, + 0x843,0x7c1,0x50081,0x1f,0x845,0x843,0x300,0x50041,0x162,0x8a3,0x160,0x25b, + 0x4003d,0x4d,0x8a4,0x8a3,0x4006f,0x1f,0x847,0x8a4,0x50088,0x1f,0x848,0x845, + 0x847,0x50041,0x172,0x8a7,0x160,0x189d,0x4003d,0x1f,0x8a8,0x8a7,0x50041,0x162, + 0x8ab,0x160,0x161,0x4003d,0x4d,0x8ac,0x8ab,0x4006f,0x1f,0x84e,0x8ac,0x50088, + 0x1f,0x84f,0x8a8,0x84e,0x50081,0x1f,0x850,0x848,0x84f,0x50041,0x162,0x8b3, + 0x160,0x189e,0x4003d,0x4d,0x8b4,0x8b3,0x50085,0x1f,0x8c1,0x850,0x84e,0x50083, + 0x1f,0x8c4,0x84e,0x300,0x7000c,0x1f,0x8d1,0x1,0x25,0x8c1,0x8c4,0x7000c, + 0x1f,0x8d6,0x1,0x28,0x300,0x8d1,0x4006f,0x1f,0x8ca,0x8b4,0x50088,0x1f, + 0x8cb,0x8d6,0x8ca,0x50085,0x1f,0x8de,0x848,0x84e,0x4006e,0x4dd,0x8df,0x8de, + 0x40072,0x4d,0x8e0,0x8df,0x4003d,0x191,0x8e9,0x1db,0x7005f,0x3e,0x8eb,0x8e9, + 0x8e0,0x2,0x161,0x7004f,0x1f,0x8ec,0x8eb,0x8eb,0x0,0x1,0x50085,0x1f, + 0x8f0,0x8ec,0x1fa,0x6000c,0x6,0x8f1,0x1,0x42,0x8f0,0x50081,0x1f,0x8f8, + 0x848,0x8ec,0x50051,0x6,0x901,0x8f8,0x0,0x500be,0x9c,0x902,0x901,0x127, + 0x300f7,0x907,0x0,0x400fa,0x902,0x903,0x907,0x200f8,0x903,0x500bc,0x9c,0x906, + 0x901,0x128,0x200f9,0x907,0x200f8,0x907,0x700f5,0x9c,0x908,0x902,0x5,0x906, + 0x903,0x300f7,0x913,0x0,0x400fa,0x908,0x909,0x913,0x200f8,0x909,0x50051,0x6, + 0x90b,0x8f8,0x1,0x500be,0x9c,0x90c,0x90b,0x127,0x300f7,0x911,0x0,0x400fa, + 0x90c,0x90d,0x911,0x200f8,0x90d,0x500bc,0x9c,0x910,0x90b,0x128,0x200f9,0x911, + 0x200f8,0x911,0x700f5,0x9c,0x912,0x90c,0x909,0x910,0x90d,0x200f9,0x913,0x200f8, + 0x913,0x700f5,0x9c,0x914,0x908,0x907,0x912,0x911,0x7000c,0x1f,0x939,0x1, + 0x25,0x8de,0x8c4,0x7000c,0x1f,0x93e,0x1,0x28,0x300,0x939,0x50088,0x1f, + 0x933,0x93e,0x8ca,0x4003d,0x191,0x941,0x1c5,0x4003d,0x19c,0x942,0x19e,0x50056, + 0x1a0,0x943,0x941,0x942,0x70058,0x3e,0x945,0x943,0x933,0x2,0x127,0x50051, + 0x6,0x946,0x945,0x0,0x50087,0x4d,0x86c,0x8ac,0x17ef,0x4003d,0x191,0x94d, + 0x1b6,0x50067,0x4d,0x94e,0x94d,0x161,0x4006f,0x1f,0x95a,0x86c,0x50085,0x1f, + 0x95b,0x850,0x95a,0x50083,0x1f,0x95e,0x95a,0x300,0x7000c,0x1f,0x96b,0x1, + 0x25,0x95b,0x95e,0x7000c,0x1f,0x970,0x1,0x28,0x300,0x96b,0x4006f,0x1f, + 0x964,0x94e,0x50088,0x1f,0x965,0x970,0x964,0x4003d,0x191,0x973,0x1b6,0x4003d, + 0x19c,0x974,0x19e,0x50056,0x1a0,0x975,0x973,0x974,0x70058,0x3e,0x977,0x975, + 0x965,0x2,0x127,0x50051,0x6,0x978,0x977,0x0,0x400a8,0x9c,0x876,0x914, + 0x300f7,0x87b,0x0,0x400fa,0x914,0x878,0x87b,0x200f8,0x878,0x50041,0x17d,0x97b, + 0x160,0x189f,0x4003d,0x6,0x97c,0x97b,0x500b4,0x9c,0x87a,0x127,0x97c,0x200f9, + 0x87b,0x200f8,0x87b,0x700f5,0x9c,0x87c,0x876,0x913,0x87a,0x878,0x4003d,0x191, + 0x97f,0x1ef,0x4003d,0x19c,0x980,0x19e,0x50056,0x1a0,0x981,0x97f,0x980,0x70058, + 0x3e,0x983,0x981,0x8cb,0x2,0x127,0x50051,0x6,0x882,0x983,0x0,0x8000c, + 0x6,0x987,0x1,0x2b,0x882,0x127,0x128,0x50051,0x6,0x886,0x983,0x1, + 0x8000c,0x6,0x98b,0x1,0x2b,0x886,0x127,0x128,0x50051,0x6,0x88a,0x983, + 0x2,0x8000c,0x6,0x98f,0x1,0x2b,0x88a,0x127,0x128,0x50051,0x6,0x88e, + 0x983,0x3,0x8000c,0x6,0x993,0x1,0x2b,0x88e,0x127,0x128,0x50085,0x6, + 0x893,0x993,0x757,0x6000c,0x6,0x894,0x1,0x1,0x893,0x500ba,0x9c,0x895, + 0x894,0x128,0x600a9,0x6,0x896,0x895,0x128,0x127,0x50085,0x6,0x899,0x993, + 0x896,0x300f7,0x7f1,0x0,0x400fa,0x914,0x7ed,0x7f1,0x200f8,0x7ed,0x400a8,0x9c, + 0x7f0,0x87c,0x200f9,0x7f1,0x200f8,0x7f1,0x700f5,0x9c,0x7f2,0x914,0x87b,0x7f0, + 0x7ed,0x300f7,0x7f8,0x0,0x400fa,0x7f2,0x7f3,0x7f8,0x200f8,0x7f3,0x50085,0x1f, + 0x9d1,0x8f8,0x847,0x50083,0x1f,0x9d4,0x9d1,0x300,0x6000c,0x1f,0x9d5,0x1, + 0x8,0x9d4,0x50081,0x1f,0x9d7,0x9d5,0x300,0x50083,0x1f,0x9da,0x9d1,0x9d7, + 0x5008e,0x1f,0x9de,0x9da,0x279,0x50083,0x1f,0x9e0,0x17f0,0x9de,0x50085,0x1f, + 0x9e1,0x9da,0x9e0,0x50081,0x1f,0x9e3,0x17f1,0x9e1,0x50085,0x1f,0x9e4,0x9da, + 0x9e3,0x50085,0x1f,0x9e7,0x9da,0x9da,0x5008e,0x1f,0x9e9,0x9da,0x511,0x50081, + 0x1f,0x9eb,0x17f2,0x9e9,0x50085,0x1f,0x9ec,0x9e7,0x9eb,0x50081,0x1f,0x9ee, + 0x17f0,0x9ec,0x50083,0x1f,0x9f4,0x17f3,0x9e9,0x50085,0x1f,0x9f5,0x9da,0x9f4, + 0x50081,0x1f,0x9f7,0x300,0x9f5,0x50085,0x1f,0x9f8,0x9da,0x9f7,0x50081,0x1f, + 0x9ff,0x17f1,0x9de,0x50085,0x1f,0xa00,0x9e7,0x9ff,0x50081,0x1f,0xa03,0x9ee, + 0x9f8,0x50081,0x1f,0xa06,0x9d5,0x17f1,0x50088,0x1f,0xa08,0xa06,0x847,0x50081, + 0x1f,0xa0b,0x9d5,0x17f5,0x50088,0x1f,0xa0d,0xa0b,0x847,0x50088,0x1f,0xa11, + 0x9f8,0xa03,0x50081,0x1f,0xa12,0x9d7,0xa11,0x50088,0x1f,0xa14,0xa12,0x847, + 0x50051,0x6,0xa16,0xa03,0x0,0x50051,0x6,0xa18,0x9e4,0x1,0x50085,0x6, + 0xa19,0xa16,0xa18,0x50051,0x6,0xa1b,0x9e4,0x0,0x50051,0x6,0xa1d,0xa03, + 0x1,0x50085,0x6,0xa1e,0xa1b,0xa1d,0x50085,0x6,0xa23,0xa16,0xa1d,0x50051, + 0x6,0xa25,0xa00,0x0,0x50085,0x6,0xa28,0xa25,0xa1d,0x50051,0x6,0xa2c, + 0xa00,0x1,0x50085,0x6,0xa2d,0xa16,0xa2c,0x50051,0x6,0xa2f,0xa14,0x0, + 0x50051,0x6,0xa31,0xa08,0x1,0x50050,0x1f,0xa32,0xa2f,0xa31,0x4003d,0x191, + 0xa65,0x19a,0x4003d,0x19c,0xa66,0x19e,0x50056,0x1a0,0xa67,0xa65,0xa66,0x70058, + 0x3e,0xa69,0xa67,0xa32,0x2,0x127,0x5008e,0x3e,0xa35,0xa69,0xa19,0x50051, + 0x6,0xa37,0xa08,0x0,0x50051,0x6,0xa39,0xa14,0x1,0x50050,0x1f,0xa3a, + 0xa37,0xa39,0x4003d,0x191,0xa6c,0x19a,0x4003d,0x19c,0xa6d,0x19e,0x50056,0x1a0, + 0xa6e,0xa6c,0xa6d,0x70058,0x3e,0xa70,0xa6e,0xa3a,0x2,0x127,0x5008e,0x3e, + 0xa3d,0xa70,0xa1e,0x50081,0x3e,0xa3e,0xa35,0xa3d,0x4003d,0x191,0xa73,0x19a, + 0x4003d,0x19c,0xa74,0x19e,0x50056,0x1a0,0xa75,0xa73,0xa74,0x70058,0x3e,0xa77, + 0xa75,0xa14,0x2,0x127,0x5008e,0x3e,0xa42,0xa77,0xa23,0x50081,0x3e,0xa43, + 0xa3e,0xa42,0x50051,0x6,0xa45,0xa0d,0x0,0x50050,0x1f,0xa48,0xa45,0xa39, + 0x4003d,0x191,0xa7a,0x19a,0x4003d,0x19c,0xa7b,0x19e,0x50056,0x1a0,0xa7c,0xa7a, + 0xa7b,0x70058,0x3e,0xa7e,0xa7c,0xa48,0x2,0x127,0x5008e,0x3e,0xa4b,0xa7e, + 0xa28,0x50081,0x3e,0xa4c,0xa43,0xa4b,0x50051,0x6,0xa50,0xa0d,0x1,0x50050, + 0x1f,0xa51,0xa2f,0xa50,0x4003d,0x191,0xa81,0x19a,0x4003d,0x19c,0xa82,0x19e, + 0x50056,0x1a0,0xa83,0xa81,0xa82,0x70058,0x3e,0xa85,0xa83,0xa51,0x2,0x127, + 0x5008e,0x3e,0xa54,0xa85,0xa2d,0x50081,0x3e,0xa55,0xa4c,0xa54,0x50081,0x6, + 0xa59,0xa19,0xa1e,0x50081,0x6,0xa5b,0xa59,0xa23,0x50081,0x6,0xa5d,0xa5b, + 0xa28,0x50081,0x6,0xa5f,0xa5d,0xa2d,0x70050,0x3e,0xa60,0xa5f,0xa5f,0xa5f, + 0xa5f,0x50088,0x3e,0xa61,0xa55,0xa60,0x7000c,0x3e,0xa8a,0x1,0x28,0xa61, + 0x59e,0x8004f,0xe,0x99e,0xa8a,0xa8a,0x0,0x1,0x2,0x50041,0x17d,0xa8d, + 0x160,0x18a0,0x4003d,0x6,0xa8e,0xa8d,0x5008e,0xe,0x9a3,0x99e,0xa8e,0x4003d, + 0x191,0xa92,0x1e3,0x7005f,0x3e,0xa93,0xa92,0x1e5,0x2,0x161,0x50051,0x6, + 0xa94,0xa93,0x0,0x500b4,0x9c,0xa96,0xa94,0x127,0x600a9,0x6,0x17fd,0xa96, + 0x128,0xa94,0x5008e,0xe,0x9a8,0x9a3,0x17fd,0x50051,0x6,0xa9e,0x9a8,0x0, + 0x50085,0x6,0xa9f,0x275,0xa9e,0x50051,0x6,0xaa1,0x9a8,0x1,0x50085,0x6, + 0xaa2,0x279,0xaa1,0x50081,0x6,0xaa3,0xa9f,0xaa2,0x50051,0x6,0xaa5,0x9a8, + 0x2,0x50085,0x6,0xaa6,0x275,0xaa5,0x50081,0x6,0xaa7,0xaa3,0xaa6,0x50083, + 0x6,0x17f6,0xa9e,0xaa5,0x50085,0x6,0xaae,0x279,0x17f6,0x50085,0x6,0xab1, + 0x289,0xa9e,0x50081,0x6,0xab5,0xab1,0xaa2,0x50083,0x6,0xab9,0xab5,0xaa6, + 0x60050,0xe,0xaba,0xaa7,0xaae,0xab9,0x50051,0x6,0x9af,0xa8a,0x3,0x200f9, + 0x7f8,0x200f8,0x7f8,0x700f5,0xe,0x1543,0x361,0x7f1,0xaba,0x7f3,0x700f5,0x6, + 0x1541,0x127,0x7f1,0x9af,0x7f3,0x400a8,0x9c,0xad6,0x87c,0x600a9,0x6,0xad7, + 0xad6,0x128,0x127,0x50085,0x6,0xada,0x1541,0xad7,0x8000c,0x6,0xb20,0x1, + 0x2b,0x98f,0x127,0x128,0x7000c,0x6,0xb25,0x1,0x28,0x987,0x98b,0x7000c, + 0x6,0xb2a,0x1,0x28,0xb20,0xb25,0x50085,0x6,0xae8,0xb2a,0x51c,0x50083, + 0x6,0xae9,0xada,0xae8,0x7000c,0x6,0xb2f,0x1,0x28,0x127,0xae9,0x50083, + 0x6,0xaee,0xb2f,0x128,0x8000c,0x6,0xb33,0x1,0x2b,0xaee,0x127,0x128, + 0x8000c,0x6,0xb37,0x1,0x2b,0xb33,0x127,0x128,0x4003d,0x1ce,0xb3a,0x1d0, + 0x50062,0x3e,0xb3c,0xb3a,0x7c1,0x50051,0x6,0xb3d,0xb3c,0x0,0x7000c,0x6, + 0xb42,0x1,0x28,0x127,0x987,0x50083,0x6,0xafc,0x128,0xb42,0x50085,0x6, + 0xafd,0xb3d,0xafc,0x50081,0x6,0xb01,0xb2f,0xafd,0x7000c,0x6,0xb47,0x1, + 0x25,0xb01,0x51c,0x7000c,0x6,0xb4c,0x1,0x28,0x127,0xb47,0x50041,0x17d, + 0xb4f,0x160,0x18a1,0x4003d,0x6,0xb50,0xb4f,0x50088,0x6,0xb06,0x6b7,0xb50, + 0x50083,0x6,0xb08,0x128,0xb2a,0x50085,0x6,0xb09,0xb06,0xb08,0x50083,0x6, + 0xb0d,0xb4c,0xb09,0x7000c,0x6,0xb55,0x1,0x28,0x127,0xb0d,0x50083,0x1f, + 0xb14,0x848,0x8ec,0x50051,0x6,0xb59,0xb14,0x0,0x500be,0x9c,0xb5a,0xb59, + 0x127,0x300f7,0xb5f,0x0,0x400fa,0xb5a,0xb5b,0xb5f,0x200f8,0xb5b,0x500bc,0x9c, + 0xb5e,0xb59,0x128,0x200f9,0xb5f,0x200f8,0xb5f,0x700f5,0x9c,0xb60,0xb5a,0x7f8, + 0xb5e,0xb5b,0x300f7,0xb6b,0x0,0x400fa,0xb60,0xb61,0xb6b,0x200f8,0xb61,0x50051, + 0x6,0xb63,0xb14,0x1,0x500be,0x9c,0xb64,0xb63,0x127,0x300f7,0xb69,0x0, + 0x400fa,0xb64,0xb65,0xb69,0x200f8,0xb65,0x500bc,0x9c,0xb68,0xb63,0x128,0x200f9, + 0xb69,0x200f8,0xb69,0x700f5,0x9c,0xb6a,0xb64,0xb61,0xb68,0xb65,0x200f9,0xb6b, + 0x200f8,0xb6b,0x700f5,0x9c,0xb6c,0xb60,0xb5f,0xb6a,0xb69,0x600a9,0x6,0xb18, + 0xb6c,0x128,0x127,0x50085,0x6,0xb1b,0xb55,0xb18,0x50041,0x17d,0xb86,0x160, + 0x7ce,0x4003d,0x6,0xb87,0xb86,0x50085,0x6,0xb7a,0x8f1,0xb87,0x50085,0x6, + 0xb7b,0xb7a,0x51c,0x7000c,0x6,0xb8c,0x1,0x28,0x127,0xb7b,0x8000c,0x6, + 0xb90,0x1,0x2b,0xb8c,0x127,0x128,0x8000c,0x6,0xb96,0x1,0x2e,0x899, + 0x6d7,0xb90,0x7000c,0x6,0xb9b,0x1,0x25,0x899,0xb96,0x50041,0x172,0xcfb, + 0x160,0x18a2,0x4003d,0x1f,0xcfc,0xcfb,0x50085,0x1f,0xbe4,0x845,0xcfc,0x6000c, + 0x1f,0xbe6,0x1,0x8,0xbe4,0x4006e,0x4d,0xbe7,0xbe6,0x4006f,0x1f,0xbe9, + 0xbe7,0x50081,0x1f,0xbea,0xbe9,0x300,0x50083,0x1f,0xbec,0xbea,0x8a8,0x50083, + 0x1f,0xbef,0xbec,0xbe4,0x50051,0x6,0xbf1,0xbec,0x0,0x50051,0x6,0xbf3, + 0xbe4,0x0,0x500ba,0x9c,0xbf4,0xbf1,0xbf3,0x600a9,0x2b,0xbf5,0xbf4,0x38d, + 0x38e,0x50051,0x6,0xbf8,0xbec,0x1,0x50051,0x6,0xbfa,0xbe4,0x1,0x500ba, + 0x9c,0xbfb,0xbf8,0xbfa,0x600a9,0x2b,0xbfc,0xbfb,0x38d,0x38e,0x50050,0x4d, + 0x18ad,0xbf5,0xbfc,0x4006f,0x1f,0xc09,0x18ad,0x500b4,0x9c,0xc0b,0x899,0x127, + 0x200f9,0xc0c,0x200f8,0xc0c,0x700f5,0x2b,0x1599,0x161,0xb6b,0xc3b,0xc39,0x700f5, + 0x2b,0x16ef,0x161,0xb6b,0x16ee,0xc39,0x500b1,0x9c,0xc0f,0x1599,0x200,0x400f6, + 0xc3c,0xc39,0x0,0x400fa,0xc0f,0xc10,0xc3c,0x200f8,0xc10,0x200f9,0xc11,0x200f8, + 0xc11,0x700f5,0x2b,0x16ee,0x16ef,0xc10,0xc34,0xc35,0x700f5,0x2b,0x16e1,0x161, + 0xc10,0xc37,0xc35,0x500b1,0x9c,0xc14,0x16e1,0x200,0x400f6,0xc38,0xc35,0x0, + 0x400fa,0xc14,0xc15,0xc38,0x200f8,0xc15,0x300f7,0xc1c,0x0,0x400fa,0xbf4,0xc17, + 0xc1a,0x200f8,0xc17,0x50082,0x2b,0xc19,0x200,0x16e1,0x200f9,0xc1c,0x200f8,0xc1a, + 0x200f9,0xc1c,0x200f8,0xc1c,0x700f5,0x2b,0x16e4,0xc19,0xc17,0x16e1,0xc1a,0x300f7, + 0xc24,0x0,0x400fa,0xbfb,0xc1f,0xc22,0x200f8,0xc1f,0x50082,0x2b,0xc21,0x200, + 0x1599,0x200f9,0xc24,0x200f8,0xc22,0x200f9,0xc24,0x200f8,0xc24,0x700f5,0x2b,0x16e8, + 0xc21,0xc1f,0x1599,0xc22,0x50050,0x4d,0xc26,0x16e4,0x16e8,0x50080,0x4d,0xc29, + 0xbe7,0x18ad,0x50080,0x4d,0xc2b,0xc29,0xc26,0x50051,0x2b,0xd14,0x8ac,0x0, + 0x50082,0x2b,0xd15,0xd14,0x206,0x50051,0x2b,0xd17,0xc2b,0x0,0x7000c,0x2b, + 0xd28,0x1,0x27,0xd17,0xd15,0x7000c,0x2b,0xd2d,0x1,0x2a,0x161,0xd28, + 0x50051,0x2b,0xd1c,0x8ac,0x1,0x50082,0x2b,0xd1d,0xd1c,0x206,0x50051,0x2b, + 0xd1f,0xc2b,0x1,0x7000c,0x2b,0xd32,0x1,0x27,0xd1f,0xd1d,0x7000c,0x2b, + 0xd37,0x1,0x2a,0x161,0xd32,0x50050,0x4d,0x18ae,0xd2d,0xd37,0x4003d,0x191, + 0xd4a,0x193,0x7005f,0x3e,0xd4c,0xd4a,0x18ae,0x2,0x161,0x8004f,0xe,0xd4d, + 0xd4c,0xd4c,0x0,0x1,0x2,0x7000c,0xe,0xd52,0x1,0x28,0x361,0xd4d, + 0x4003d,0x191,0xd56,0x1e3,0x7005f,0x3e,0xd57,0xd56,0x1e5,0x2,0x161,0x50051, + 0x6,0xd58,0xd57,0x0,0x500b4,0x9c,0xd5a,0xd58,0x127,0x600a9,0x6,0x17fe, + 0xd5a,0x128,0xd58,0x5008e,0xe,0xd44,0xd52,0x17fe,0x50051,0x6,0xd62,0xd44, + 0x0,0x50085,0x6,0xd63,0x275,0xd62,0x50051,0x6,0xd65,0xd44,0x1,0x50085, + 0x6,0xd66,0x279,0xd65,0x50081,0x6,0xd67,0xd63,0xd66,0x50051,0x6,0xd69, + 0xd44,0x2,0x50085,0x6,0xd6a,0x275,0xd69,0x50081,0x6,0xd6b,0xd67,0xd6a, + 0x50083,0x6,0x17fc,0xd62,0xd69,0x50085,0x6,0xd72,0x279,0x17fc,0x50085,0x6, + 0xd75,0x289,0xd62,0x50081,0x6,0xd79,0xd75,0xd66,0x50083,0x6,0xd7d,0xd79, + 0xd6a,0x60050,0xe,0xd7e,0xd6b,0xd72,0xd7d,0x50041,0xf,0xc32,0xbb1,0x16ee, + 0x3003e,0xc32,0xd7e,0x50080,0x2b,0xc34,0x16ee,0x206,0x200f9,0xc35,0x200f8,0xc35, + 0x50080,0x2b,0xc37,0x16e1,0x206,0x200f9,0xc11,0x200f8,0xc38,0x200f9,0xc39,0x200f8, + 0xc39,0x50080,0x2b,0xc3b,0x1599,0x206,0x200f9,0xc0c,0x200f8,0xc3c,0x300f7,0xc50, + 0x0,0x400fa,0xc0b,0xc3e,0xc50,0x200f8,0xc3e,0x200f9,0xc3f,0x200f8,0xc3f,0x700f5, + 0x2b,0x159b,0x161,0xc3e,0xc4e,0xc43,0x500b1,0x9c,0xc42,0x159b,0x3f4,0x400f6, + 0xc4f,0xc43,0x0,0x400fa,0xc42,0xc43,0xc4f,0x200f8,0xc43,0x50041,0xf,0xc46, + 0xbb1,0x159b,0x4003d,0xe,0xc47,0xc46,0x50051,0x6,0xd84,0xc47,0x0,0x50051, + 0x6,0xd86,0xc47,0x1,0x50081,0x6,0xd87,0xd84,0xd86,0x50051,0x6,0xd89, + 0xc47,0x2,0x50083,0x6,0xd8a,0xd87,0xd89,0x50081,0x6,0xd8f,0xd84,0xd89, + 0x50083,0x6,0xd94,0xd84,0xd86,0x50083,0x6,0xd97,0xd94,0xd89,0x60050,0xe, + 0xd98,0xd8a,0xd8f,0xd97,0x7000c,0x6,0xdb3,0x1,0x28,0x127,0xd8a,0x7000c, + 0x6,0xdb8,0x1,0x28,0xd8f,0xd97,0x7000c,0x6,0xdbd,0x1,0x28,0xdb3, + 0xdb8,0x50081,0x6,0xdac,0xdbd,0x128,0x60050,0xe,0xdad,0xdac,0xdac,0xdac, + 0x50088,0xe,0xdae,0xd98,0xdad,0x50051,0x6,0xdc2,0xdae,0x0,0x50085,0x6, + 0xdc3,0x275,0xdc2,0x50051,0x6,0xdc5,0xdae,0x1,0x50085,0x6,0xdc6,0x279, + 0xdc5,0x50081,0x6,0xdc7,0xdc3,0xdc6,0x50051,0x6,0xdc9,0xdae,0x2,0x50085, + 0x6,0xdca,0x275,0xdc9,0x50081,0x6,0xdcb,0xdc7,0xdca,0x50083,0x6,0x17fb, + 0xdc2,0xdc9,0x50085,0x6,0xdd2,0x279,0x17fb,0x50085,0x6,0xdd5,0x289,0xdc2, + 0x50081,0x6,0xdd9,0xdd5,0xdc6,0x50083,0x6,0xddd,0xdd9,0xdca,0x60050,0xe, + 0xdde,0xdcb,0xdd2,0xddd,0x3003e,0xc46,0xdde,0x50080,0x2b,0xc4e,0x159b,0x206, + 0x200f9,0xc3f,0x200f8,0xc4f,0x200f9,0xc50,0x200f8,0xc50,0x50088,0x1f,0xde7,0x17f0, + 0xcfc,0x50083,0x1f,0xde9,0xde7,0x17f0,0x50051,0x6,0xdea,0xde9,0x0,0x50081, + 0x6,0xdeb,0x128,0xdea,0x7000c,0x6,0xdf6,0x1,0x25,0x359,0xdeb,0x50081, + 0x6,0xc55,0x128,0xdf6,0x50085,0x6,0xc56,0xc55,0x40b,0x7000c,0x6,0xdfb, + 0x1,0x28,0x128,0xc56,0x50085,0x6,0xc59,0x98b,0x279,0x50083,0x6,0xc5a, + 0x128,0xc59,0x50083,0x6,0xc5c,0x128,0x98f,0x50085,0x6,0xc5f,0xb9b,0x418, + 0x8000c,0x6,0xdff,0x1,0x2b,0xc5f,0x127,0x128,0x7000c,0x6,0xe04,0x1, + 0x25,0xc5c,0xdff,0x7000c,0x6,0xe09,0x1,0x25,0xc5a,0xe04,0x8000c,0x6, + 0xe0f,0x1,0x2e,0xdfb,0xdf6,0xe09,0x200f9,0xc67,0x200f8,0xc67,0x700f5,0xe, + 0x15cb,0x361,0xc50,0x16ba,0xcc6,0x700f5,0x6,0x15c9,0x127,0xc50,0x16bd,0xcc6, + 0x700f5,0xe,0x15c2,0x14b1,0xc50,0x16d9,0xcc6,0x700f5,0xe,0x15c1,0x14b1,0xc50, + 0x16d5,0xcc6,0x700f5,0xe,0x15c0,0x14b1,0xc50,0x16d1,0xcc6,0x700f5,0xe,0x15bf, + 0x14b1,0xc50,0x16cd,0xcc6,0x700f5,0x6,0x15be,0x14ae,0xc50,0x16c9,0xcc6,0x700f5, + 0x2b,0x15bd,0x161,0xc50,0xcc8,0xcc6,0x700f5,0x2b,0x16b7,0x161,0xc50,0x16b6, + 0xcc6,0x500b1,0x9c,0xc6a,0x15bd,0x200,0x400f6,0xcc9,0xcc6,0x0,0x400fa,0xc6a, + 0xc6b,0xcc9,0x200f8,0xc6b,0x200f9,0xc6c,0x200f8,0xc6c,0x700f5,0xe,0x16d9,0x15c2, + 0xc6b,0x16de,0xcc2,0x700f5,0xe,0x16d5,0x15c1,0xc6b,0x16dd,0xcc2,0x700f5,0xe, + 0x16d1,0x15c0,0xc6b,0x16dc,0xcc2,0x700f5,0xe,0x16cd,0x15bf,0xc6b,0x16db,0xcc2, + 0x700f5,0x6,0x16c9,0x15be,0xc6b,0x16da,0xcc2,0x700f5,0x6,0x16bd,0x15c9,0xc6b, + 0x17e6,0xcc2,0x700f5,0xe,0x16ba,0x15cb,0xc6b,0x17e4,0xcc2,0x700f5,0x2b,0x16b6, + 0x16b7,0xc6b,0xcc1,0xcc2,0x700f5,0x2b,0x1688,0x161,0xc6b,0xcc4,0xcc2,0x500b1, + 0x9c,0xc6f,0x1688,0x200,0x400f6,0xcc5,0xcc2,0x0,0x400fa,0xc6f,0xc70,0xcc5, + 0x200f8,0xc70,0x300f7,0xc77,0x0,0x400fa,0xbf4,0xc72,0xc75,0x200f8,0xc72,0x50082, + 0x2b,0xc74,0x200,0x1688,0x200f9,0xc77,0x200f8,0xc75,0x200f9,0xc77,0x200f8,0xc77, + 0x700f5,0x2b,0x168f,0xc74,0xc72,0x1688,0xc75,0x300f7,0xc7f,0x0,0x400fa,0xbfb, + 0xc7a,0xc7d,0x200f8,0xc7a,0x50082,0x2b,0xc7c,0x200,0x15bd,0x200f9,0xc7f,0x200f8, + 0xc7d,0x200f9,0xc7f,0x200f8,0xc7f,0x700f5,0x2b,0x1697,0xc7c,0xc7a,0x15bd,0xc7d, + 0x50050,0x4d,0xc81,0x168f,0x1697,0x4006f,0x1f,0xc84,0xc81,0x50081,0x1f,0xc85, + 0xc09,0xc84,0x50081,0x1f,0xc88,0xbef,0xc85,0x50080,0x4d,0xc8b,0xbe7,0x18ad, + 0x50080,0x4d,0xc8d,0xc8b,0xc81,0x4007c,0x314,0xe17,0xc8d,0x4007c,0x314,0xe19, + 0x8ac,0x500b0,0x318,0xe1a,0xe17,0xe19,0x4009b,0x9c,0xe1b,0xe1a,0x600a9,0x6, + 0xc91,0xe1b,0x128,0x127,0x400a8,0x9c,0xc93,0xc0b,0x300f7,0xca8,0x0,0x400fa, + 0xc93,0xc94,0xca8,0x200f8,0xc94,0x50050,0x1f,0xe23,0xe0f,0xe0f,0x50085,0x1f, + 0xe24,0xc88,0xe23,0x50094,0x6,0xe27,0xe24,0xe24,0x7000c,0x6,0xe37,0x1, + 0x25,0xe27,0x333,0x50085,0x6,0xe3d,0x31e,0xe37,0x50083,0x6,0xe3e,0xe3d, + 0x128,0x50085,0x6,0xe40,0x275,0xe37,0x50083,0x6,0xe41,0xe40,0x128,0x50085, + 0x6,0xe43,0x326,0xe3e,0x50085,0x6,0xe45,0xe43,0xe3e,0x50083,0x6,0xe46, + 0xe45,0x32b,0x50085,0x6,0xe49,0xe41,0xe41,0x50085,0x6,0xe4a,0xe46,0xe49, + 0x50085,0x6,0xc99,0xc91,0xe4a,0x50041,0xf,0xc9b,0xbb1,0x16b6,0x4003d,0xe, + 0xc9c,0xc9b,0x5008e,0xe,0xc9e,0xc9c,0xc99,0x50081,0xe,0xca1,0x16ba,0xc9e, + 0x50081,0x6,0xca6,0x16bd,0xc99,0x200f9,0xca8,0x200f8,0xca8,0x700f5,0x6,0x17e6, + 0x16bd,0xc7f,0xca6,0xc94,0x700f5,0xe,0x17e4,0x16ba,0xc7f,0xca1,0xc94,0x50094, + 0x6,0xcab,0xc88,0xc88,0x50085,0x6,0xcad,0x483,0xcab,0x6000c,0x6,0xcae, + 0x1,0x1b,0xcad,0x50085,0x6,0xcb0,0xcae,0xc91,0x500aa,0x9c,0xcb2,0x15bd, + 0x161,0x500aa,0x9c,0xcb4,0x1688,0x161,0x500a7,0x9c,0xcb5,0xcb2,0xcb4,0x50041, + 0xf,0xcb7,0xbb1,0x16b6,0x4003d,0xe,0xcb8,0xcb7,0x300f7,0xe70,0x0,0x400fa, + 0xcb5,0xe53,0xe57,0x200f8,0xe53,0x5008e,0xe,0xe75,0xcb8,0xcb0,0x50085,0xe, + 0xe79,0xcb8,0xe75,0x200f9,0xe70,0x200f8,0xe57,0x7000c,0xe,0xe80,0x1,0x25, + 0x16d1,0xcb8,0x7000c,0xe,0xe85,0x1,0x28,0x16cd,0xcb8,0x5008e,0xe,0xe60, + 0xcb8,0xcb0,0x50081,0xe,0xe64,0x16d9,0xe60,0x50085,0xe,0xe67,0xcb8,0xe60, + 0x50081,0xe,0xe6a,0x16d5,0xe67,0x50081,0x6,0xe6e,0x16c9,0xcb0,0x200f9,0xe70, + 0x200f8,0xe70,0x700f5,0xe,0x16de,0xe75,0xe53,0xe64,0xe57,0x700f5,0xe,0x16dd, + 0xe79,0xe53,0xe6a,0xe57,0x700f5,0xe,0x16dc,0xcb8,0xe53,0xe80,0xe57,0x700f5, + 0xe,0x16db,0xcb8,0xe53,0xe85,0xe57,0x700f5,0x6,0x16da,0xcb0,0xe53,0xe6e, + 0xe57,0x50080,0x2b,0xcc1,0x16b6,0x206,0x200f9,0xcc2,0x200f8,0xcc2,0x50080,0x2b, + 0xcc4,0x1688,0x206,0x200f9,0xc6c,0x200f8,0xcc5,0x200f9,0xcc6,0x200f8,0xcc6,0x50080, + 0x2b,0xcc8,0x15bd,0x206,0x200f9,0xc67,0x200f8,0xcc9,0x6000c,0x6,0xe8b,0x1, + 0x4,0x15be,0x500ba,0x9c,0xe8c,0xe8b,0x233,0x600a9,0x6,0x17ff,0xe8c,0x15be, + 0x128,0x60050,0xe,0xe98,0x17ff,0x17ff,0x17ff,0x50088,0xe,0xe99,0x15c2,0xe98, + 0x50088,0xe,0xea0,0x15c1,0xe98,0x50085,0xe,0xea8,0xe99,0xe99,0x50083,0xe, + 0xea9,0xea0,0xea8,0x6000c,0xe,0xeaa,0x1,0x4,0xea9,0x6000c,0xe,0xeab, + 0x1,0x1f,0xeaa,0x500ba,0x9c,0xcd1,0x15c9,0x2af,0x600a9,0x6,0xcd2,0xcd1, + 0x128,0x127,0x50085,0x6,0xcd5,0x15c9,0xcd2,0x500ba,0x9c,0xcd9,0xcd5,0x2af, + 0x300f7,0xced,0x0,0x400fa,0xcd9,0xcda,0xced,0x200f8,0xcda,0x60050,0xe,0xcdf, + 0xcd5,0xcd5,0xcd5,0x50088,0xe,0xce0,0x15cb,0xcdf,0x50085,0x6,0xce4,0xcd5, + 0x4bb,0x8000c,0xe,0xeb4,0x1,0x2b,0xce0,0x15c0,0x15bf,0x200f9,0xced,0x200f8, + 0xced,0x700f5,0xe,0x15e5,0x15cb,0xcc9,0xeb4,0xcda,0x700f5,0x6,0x15e3,0xcd5, + 0xcc9,0xce4,0xcda,0x300f7,0xcf8,0x0,0x400fa,0xc0b,0xcef,0xcf8,0x200f8,0xcef, + 0x50051,0x6,0xeb9,0xe99,0x0,0x50051,0x6,0xebb,0xe99,0x1,0x50081,0x6, + 0xebc,0xeb9,0xebb,0x50051,0x6,0xebe,0xe99,0x2,0x50083,0x6,0xebf,0xebc, + 0xebe,0x50081,0x6,0xec4,0xeb9,0xebe,0x50083,0x6,0xec9,0xeb9,0xebb,0x50083, + 0x6,0xecc,0xec9,0xebe,0x60050,0xe,0xecd,0xebf,0xec4,0xecc,0x7000c,0x6, + 0xee8,0x1,0x28,0xec4,0xecc,0x7000c,0x6,0xeed,0x1,0x28,0xebf,0xee8, + 0x50083,0x6,0xee0,0x128,0xeed,0x7000c,0x6,0xef2,0x1,0x28,0x2af,0xee0, + 0x60050,0xe,0xee2,0xef2,0xef2,0xef2,0x50088,0xe,0xee3,0xecd,0xee2,0x50051, + 0x6,0xef7,0xee3,0x0,0x50085,0x6,0xef8,0x275,0xef7,0x50051,0x6,0xefa, + 0xee3,0x1,0x50085,0x6,0xefb,0x279,0xefa,0x50081,0x6,0xefc,0xef8,0xefb, + 0x50051,0x6,0xefe,0xee3,0x2,0x50085,0x6,0xeff,0x275,0xefe,0x50081,0x6, + 0xf00,0xefc,0xeff,0x50083,0x6,0x17f7,0xef7,0xefe,0x50085,0x6,0xf07,0x279, + 0x17f7,0x50085,0x6,0xf0a,0x289,0xef7,0x50081,0x6,0xf0e,0xf0a,0xefb,0x50083, + 0x6,0xf12,0xf0e,0xeff,0x60050,0xe,0xf13,0xf00,0xf07,0xf12,0x200f9,0xcf8, + 0x200f8,0xcf8,0x700f5,0xe,0x15e4,0x15e5,0xced,0xf13,0xcef,0x600a9,0x6,0x1800, + 0xc0b,0x128,0x15e3,0x600a9,0x6,0x1801,0xc0b,0x127,0xb9b,0x50085,0x6,0xf3b, + 0x8f1,0x17f8,0x8000c,0x6,0xf7f,0x1,0x2b,0xf3b,0x127,0x128,0x50085,0x6, + 0xf3e,0x978,0x17f8,0x50083,0x6,0xf3f,0x608,0xf3e,0x8000c,0x6,0xf83,0x1, + 0x2b,0xf3f,0x127,0x128,0x50083,0x6,0xf42,0x128,0x899,0x7000c,0x6,0xf88, + 0x1,0x1a,0x987,0x279,0x7000c,0x6,0xf8d,0x1,0x28,0xf88,0x98f,0x7000c, + 0x6,0xf92,0x1,0x28,0xf42,0xf8d,0x7000c,0x6,0xf97,0x1,0x28,0xf83, + 0xf92,0x7000c,0x6,0xf9c,0x1,0x28,0xf7f,0xf97,0x8000c,0x6,0xfa2,0x1, + 0x2e,0x62d,0x128,0xf9c,0x50085,0xe,0xf53,0xeab,0x637,0x5008e,0xe,0xf55, + 0xf53,0xfa2,0x7000c,0xe,0xfa7,0x1,0x28,0xf55,0x63d,0x50083,0xe,0xf5c, + 0x1543,0xe99,0x50088,0xe,0xf5e,0xf5c,0xfa7,0x6000c,0x6,0xf60,0x1,0x42, + 0xf5e,0x500ba,0x9c,0xf61,0xf60,0x128,0x300f7,0xf7b,0x0,0x400fa,0xf61,0xf62, + 0xf7b,0x200f8,0xf62,0x6000c,0xe,0xf64,0x1,0x45,0xf5e,0x50085,0xe,0xf67, + 0xf64,0xf55,0x50081,0xe,0xf6a,0xf67,0xe99,0x7000c,0x6,0xfac,0x1,0x28, + 0x946,0xb37,0x50085,0x6,0xf70,0xfac,0x899,0x50083,0x6,0xf72,0x128,0x98b, + 0x50085,0x6,0xf73,0xf70,0xf72,0x8000c,0x6,0xfb0,0x1,0x2b,0xf73,0x127, + 0x128,0x60050,0xe,0xfb6,0xfb0,0xfb0,0xfb0,0x8000c,0xe,0xfb7,0x1,0x2e, + 0xf6a,0x1543,0xfb6,0x200f9,0xf7b,0x200f8,0xf7b,0x700f5,0xe,0x165b,0x1543,0xcf8, + 0xfb7,0xf62,0x500ba,0x9c,0xfca,0x1801,0x2af,0x600a9,0x6,0xfcb,0xfca,0x128, + 0x127,0x50085,0x6,0xfce,0x1801,0xfcb,0x50081,0x6,0xfd4,0xfce,0x1800,0x7000c, + 0x6,0xffc,0x1,0x28,0x2af,0xfd4,0x50051,0x6,0x1001,0x15e4,0x0,0x50051, + 0x6,0x1003,0x15e4,0x1,0x50081,0x6,0x1004,0x1001,0x1003,0x50051,0x6,0x1006, + 0x15e4,0x2,0x50083,0x6,0x1007,0x1004,0x1006,0x50081,0x6,0x100c,0x1001,0x1006, + 0x50083,0x6,0x1011,0x1001,0x1003,0x50083,0x6,0x1014,0x1011,0x1006,0x60050,0xe, + 0x1015,0x1007,0x100c,0x1014,0x7000c,0x6,0x1030,0x1,0x28,0x127,0x1007,0x7000c, + 0x6,0x1035,0x1,0x28,0x100c,0x1014,0x7000c,0x6,0x103a,0x1,0x28,0x1030, + 0x1035,0x50081,0x6,0x1029,0x103a,0x128,0x60050,0xe,0x102a,0x1029,0x1029,0x1029, + 0x50088,0xe,0x102b,0x1015,0x102a,0x50051,0x6,0x103f,0x102b,0x0,0x50085,0x6, + 0x1040,0x275,0x103f,0x50051,0x6,0x1042,0x102b,0x1,0x50085,0x6,0x1043,0x279, + 0x1042,0x50081,0x6,0x1044,0x1040,0x1043,0x50051,0x6,0x1046,0x102b,0x2,0x50085, + 0x6,0x1047,0x275,0x1046,0x50081,0x6,0x1048,0x1044,0x1047,0x50083,0x6,0x17f9, + 0x103f,0x1046,0x50085,0x6,0x104f,0x279,0x17f9,0x50085,0x6,0x1052,0x289,0x103f, + 0x50081,0x6,0x1056,0x1052,0x1043,0x50083,0x6,0x105a,0x1056,0x1047,0x60050,0xe, + 0x105b,0x1048,0x104f,0x105a,0x50051,0x6,0x1061,0x165b,0x0,0x50051,0x6,0x1063, + 0x165b,0x1,0x50081,0x6,0x1064,0x1061,0x1063,0x50051,0x6,0x1066,0x165b,0x2, + 0x50083,0x6,0x1067,0x1064,0x1066,0x50081,0x6,0x106c,0x1061,0x1066,0x50083,0x6, + 0x1071,0x1061,0x1063,0x50083,0x6,0x1074,0x1071,0x1066,0x60050,0xe,0x1075,0x1067, + 0x106c,0x1074,0x7000c,0x6,0x1090,0x1,0x28,0x127,0x1067,0x7000c,0x6,0x1095, + 0x1,0x28,0x106c,0x1074,0x7000c,0x6,0x109a,0x1,0x28,0x1090,0x1095,0x50081, + 0x6,0x1089,0x109a,0x128,0x60050,0xe,0x108a,0x1089,0x1089,0x1089,0x50088,0xe, + 0x108b,0x1075,0x108a,0x50051,0x6,0x109f,0x108b,0x0,0x50085,0x6,0x10a0,0x275, + 0x109f,0x50051,0x6,0x10a2,0x108b,0x1,0x50085,0x6,0x10a3,0x279,0x10a2,0x50081, + 0x6,0x10a4,0x10a0,0x10a3,0x50051,0x6,0x10a6,0x108b,0x2,0x50085,0x6,0x10a7, + 0x275,0x10a6,0x50081,0x6,0x10a8,0x10a4,0x10a7,0x50083,0x6,0x17fa,0x109f,0x10a6, + 0x50085,0x6,0x10af,0x279,0x17fa,0x50085,0x6,0x10b2,0x289,0x109f,0x50081,0x6, + 0x10b6,0x10b2,0x10a3,0x50083,0x6,0x10ba,0x10b6,0x10a7,0x60050,0xe,0x10bb,0x10a8, + 0x10af,0x10ba,0x50088,0x6,0xfe7,0x1800,0xffc,0x8000c,0x6,0x10c0,0x1,0x2b, + 0xfe7,0x127,0x128,0x60050,0xe,0x10c6,0x10c0,0x10c0,0x10c0,0x8000c,0xe,0x10c7, + 0x1,0x2e,0x10bb,0x105b,0x10c6,0x50051,0x6,0x10cc,0x10c7,0x0,0x50051,0x6, + 0x10ce,0x10c7,0x1,0x50081,0x6,0x10cf,0x10cc,0x10ce,0x50051,0x6,0x10d1,0x10c7, + 0x2,0x50083,0x6,0x10d2,0x10cf,0x10d1,0x50081,0x6,0x10d7,0x10cc,0x10d1,0x50083, + 0x6,0x10dc,0x10cc,0x10ce,0x50083,0x6,0x10df,0x10dc,0x10d1,0x60050,0xe,0x10e0, + 0x10d2,0x10d7,0x10df,0x7000c,0x6,0x10fb,0x1,0x28,0x10d7,0x10df,0x7000c,0x6, + 0x1100,0x1,0x28,0x10d2,0x10fb,0x50083,0x6,0x10f3,0x128,0x1100,0x7000c,0x6, + 0x1105,0x1,0x28,0x2af,0x10f3,0x60050,0xe,0x10f5,0x1105,0x1105,0x1105,0x50088, + 0xe,0x10f6,0x10e0,0x10f5,0x4003d,0x191,0x1109,0x1e3,0x7005f,0x3e,0x110a,0x1109, + 0x1e5,0x2,0x161,0x50051,0x6,0x110b,0x110a,0x0,0x500b4,0x9c,0x110d,0x110b, + 0x127,0x600a9,0x6,0x1802,0x110d,0x128,0x110b,0x60050,0xe,0x810,0x1802,0x1802, + 0x1802,0x50088,0xe,0x811,0x10f6,0x810,0x7000c,0xe,0x1115,0x1,0x28,0x811, + 0x361,0x50051,0x6,0x81b,0x1115,0x0,0x50051,0x6,0x81c,0x1115,0x1,0x50051, + 0x6,0x81d,0x1115,0x2,0x70050,0x3e,0x81e,0x81b,0x81c,0x81d,0xb1b,0x4003d, + 0x1a6,0x1117,0x1a8,0x40063,0x1117,0x7c1,0x81e,0x4003d,0x1ac,0x111b,0x1ae,0x70050, + 0x3e,0x1121,0x81b,0x81c,0x81d,0x128,0x40063,0x111b,0x7c1,0x1121,0x4003d,0x1ce, + 0x1123,0x1d0,0x40063,0x1123,0x7c1,0x59e,0x100fd,0x10038, +}; +static const char *fu1_accumulate_pass_0_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu1_accumulate_pass_0_cb_bind[] = {12}; +static const uint32_t fu1_accumulate_pass_0_cb_count[] = {1}; +static const uint32_t fu1_accumulate_pass_0_cb_space[] = {0}; +static const char *fu1_accumulate_pass_0_srv_tex_names[] = {"r_input_exposure", "r_dilated_reactive_masks", "r_dilated_motion_vectors", "r_internal_upscaled_color", "r_farthest_depth_mip1", "r_luma_instability", "r_input_color_jittered"}; +static const uint32_t fu1_accumulate_pass_0_srv_tex_bind[] = {0, 1, 2, 3, 5, 7, 8}; +static const uint32_t fu1_accumulate_pass_0_srv_tex_count[] = {1, 1, 1, 1, 1, 1, 1}; +static const uint32_t fu1_accumulate_pass_0_srv_tex_space[] = {0, 0, 0, 0, 0, 0, 0}; +static const char *fu1_accumulate_pass_0_uav_tex_names[] = {"rw_internal_upscaled_color", "rw_upscaled_output", "rw_new_locks"}; +static const uint32_t fu1_accumulate_pass_0_uav_tex_bind[] = {9, 10, 11}; +static const uint32_t fu1_accumulate_pass_0_uav_tex_count[] = {1, 1, 1}; +static const uint32_t fu1_accumulate_pass_0_uav_tex_space[] = {0, 0, 0}; +static const char *fu1_accumulate_pass_0_sampler_names[] = {"s_LinearClamp"}; +static const uint32_t fu1_accumulate_pass_0_sampler_bind[] = {1001}; +static const uint32_t fu1_accumulate_pass_0_sampler_count[] = {1}; +static const uint32_t fu1_accumulate_pass_0_sampler_space[] = {0}; + +static const uint32_t fu1_accumulate_pass_1_spv[4731] = { + 0x7230203,0x10500,0x8000b,0x188f,0x0,0x20011,0x1,0x20011,0x16,0x20011,0x31,0x20011, + 0x32,0x6000b,0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0x11000f,0x5, + 0x4,0x6e69616d,0x0,0x15b,0x18e,0x195,0x199,0x1a3,0x1a7,0x1b6,0x1c1,0x1cc, + 0x1d4,0x1e0,0x7a9,0x60010,0x4,0x11,0x8,0x8,0x1,0x30003,0x2,0x1c2, + 0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x0,0x80004, + 0x455f4c47,0x735f5458,0x65646168,0x36315f72,0x5f746962,0x726f7473,0x656761,0xb0004,0x455f4c47,0x735f5458,0x65646168,0x78655f72, + 0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004,0x455f4c47,0x735f5458,0x65646168,0x6d695f72,0x5f656761, + 0x64616f6c,0x726f665f,0x7474616d,0x6465,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f, + 0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x657669,0x40005,0x4, + 0x6e69616d,0x0,0x70005,0x159,0x53466263,0x50553352,0x4c414353,0x745f5245,0x0,0x60006,0x159,0x0, + 0x6e655269,0x53726564,0x657a69,0x70006,0x159,0x1,0x73705569,0x656c6163,0x657a6953,0x0,0x70006,0x159, + 0x2,0x78614d69,0x646e6552,0x69537265,0x657a,0x50006,0x159,0x3,0x74694a66,0x726574,0x80006,0x159, + 0x4,0x776f4466,0x6163736e,0x6146656c,0x726f7463,0x0,0x90006,0x159,0x5,0x74694a66,0x53726574,0x65757165, + 0x4c65636e,0x74676e65,0x68,0x80006,0x159,0x6,0x6c654466,0x72506174,0x70784565,0x7275736f,0x65,0x60006, + 0x159,0x7,0x61724666,0x6e49656d,0x786564,0x70006,0x159,0x8,0x6c655666,0x7469636f,0x63614679,0x726f74, + 0x60005,0x15b,0x53466263,0x70553352,0x6c616373,0x7265,0x80005,0x18e,0x6e695f72,0x5f747570,0x6f6c6f63,0x696a5f72, + 0x72657474,0x6465,0x90005,0x195,0x6e695f72,0x6e726574,0x755f6c61,0x61637370,0x5f64656c,0x6f6c6f63,0x72,0x60005, + 0x199,0x694c5f73,0x7261656e,0x6d616c43,0x70,0x90005,0x1a3,0x695f7772,0x7265746e,0x5f6c616e,0x63737075,0x64656c61, + 0x6c6f635f,0x726f,0x80005,0x1a7,0x61665f72,0x65687472,0x645f7473,0x68747065,0x70696d5f,0x31,0x70005,0x1b6, + 0x756c5f72,0x695f616d,0x6174736e,0x696c6962,0x7974,0x60005,0x1c1,0x6e5f7772,0x6c5f7765,0x736b636f,0x0,0x90005, + 0x1cc,0x69645f72,0x6574616c,0x6f6d5f64,0x6e6f6974,0x6365765f,0x73726f74,0x0,0x70005,0x1d4,0x6e695f72,0x5f747570, + 0x6f707865,0x65727573,0x0,0x90005,0x1e0,0x69645f72,0x6574616c,0x65725f64,0x69746361,0x6d5f6576,0x736b7361,0x0, + 0x80005,0x7a9,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x44,0x30047,0x159,0x2,0x50048, + 0x159,0x0,0x23,0x0,0x50048,0x159,0x1,0x23,0x10,0x50048,0x159,0x2, + 0x23,0x20,0x50048,0x159,0x3,0x23,0x40,0x50048,0x159,0x4,0x23,0x58, + 0x50048,0x159,0x5,0x23,0x6c,0x50048,0x159,0x6,0x23,0x74,0x50048,0x159, + 0x7,0x23,0x7c,0x50048,0x159,0x8,0x23,0x80,0x40047,0x15b,0x21,0xc, + 0x40047,0x15b,0x22,0x0,0x40047,0x18e,0x21,0x8,0x40047,0x18e,0x22,0x0, + 0x40047,0x195,0x21,0x3,0x40047,0x195,0x22,0x0,0x40047,0x199,0x21,0x3e9, + 0x40047,0x199,0x22,0x0,0x30047,0x1a3,0x19,0x40047,0x1a3,0x21,0x9,0x40047, + 0x1a3,0x22,0x0,0x40047,0x1a7,0x21,0x5,0x40047,0x1a7,0x22,0x0,0x40047, + 0x1b6,0x21,0x7,0x40047,0x1b6,0x22,0x0,0x40047,0x1c1,0x21,0xb,0x40047, + 0x1c1,0x22,0x0,0x40047,0x1cc,0x21,0x2,0x40047,0x1cc,0x22,0x0,0x40047, + 0x1d4,0x21,0x0,0x40047,0x1d4,0x22,0x0,0x40047,0x1e0,0x21,0x1,0x40047, + 0x1e0,0x22,0x0,0x40047,0x7a9,0xb,0x1c,0x40047,0x7bd,0xb,0x19,0x20013, + 0x2,0x30021,0x3,0x2,0x30016,0x6,0x20,0x40017,0xe,0x6,0x3,0x40020, + 0xf,0x7,0xe,0x40017,0x1f,0x6,0x2,0x40015,0x2b,0x20,0x1,0x40017, + 0x3e,0x6,0x4,0x40017,0x4d,0x2b,0x2,0x20014,0x97,0x4002b,0x6,0x122, + 0x0,0x4002b,0x6,0x123,0x3f800000,0xb001e,0x159,0x4d,0x4d,0x4d,0x1f,0x1f, + 0x6,0x6,0x6,0x6,0x40020,0x15a,0x2,0x159,0x4003b,0x15a,0x15b,0x2, + 0x4002b,0x2b,0x15c,0x0,0x40020,0x15d,0x2,0x4d,0x4002b,0x2b,0x167,0x2, + 0x40020,0x16d,0x2,0x1f,0x40020,0x178,0x2,0x6,0x90019,0x18c,0x6,0x1, + 0x0,0x0,0x0,0x1,0x0,0x40020,0x18d,0x0,0x18c,0x4003b,0x18d,0x18e, + 0x0,0x4003b,0x18d,0x195,0x0,0x2001a,0x197,0x40020,0x198,0x0,0x197,0x4003b, + 0x198,0x199,0x0,0x3001b,0x19b,0x18c,0x90019,0x1a1,0x6,0x1,0x0,0x0, + 0x0,0x2,0x2,0x40020,0x1a2,0x0,0x1a1,0x4003b,0x1a2,0x1a3,0x0,0x4003b, + 0x18d,0x1a7,0x0,0x40015,0x1b1,0x20,0x0,0x4003b,0x18d,0x1b6,0x0,0x90019, + 0x1bf,0x6,0x1,0x0,0x0,0x0,0x2,0xf,0x40020,0x1c0,0x0,0x1bf, + 0x4003b,0x1c0,0x1c1,0x0,0x4003b,0x18d,0x1cc,0x0,0x4003b,0x18d,0x1d4,0x0, + 0x5002c,0x4d,0x1d6,0x15c,0x15c,0x4003b,0x18d,0x1e0,0x0,0x4002b,0x6,0x1e9, + 0x45700000,0x4002b,0x6,0x1ea,0x45070000,0x5002c,0x1f,0x1eb,0x1e9,0x1ea,0x4002b,0x2b, + 0x1f1,0x3,0x4002b,0x2b,0x1f7,0x1,0x4002b,0x6,0x224,0x800000,0x4002b,0x1b1, + 0x24c,0x1,0x4002b,0x6,0x266,0x3e800000,0x4002b,0x6,0x26a,0x3f000000,0x4002b,0x6, + 0x27a,0xbe800000,0x4002b,0x6,0x2a0,0x387fda40,0x5002c,0x1f,0x2f1,0x26a,0x26a,0x40017, + 0x305,0x1b1,0x2,0x40017,0x309,0x97,0x2,0x4002b,0x6,0x30f,0x3ecccccd,0x4002b, + 0x6,0x317,0x3fc80000,0x4002b,0x6,0x31c,0x3f100000,0x4002b,0x6,0x324,0x40800000,0x4002b, + 0x6,0x34a,0x3ffeb852,0x6002c,0xe,0x352,0x122,0x122,0x122,0x4002b,0x2b,0x37e, + 0xfffffffe,0x4002b,0x2b,0x37f,0xffffffff,0x4002b,0x1b1,0x3cd,0x9,0x4001c,0x3ce,0xe, + 0x3cd,0x40020,0x3cf,0x7,0x3ce,0x4002b,0x2b,0x3e5,0x9,0x4002b,0x6,0x3fc, + 0x3e99999a,0x4002b,0x6,0x409,0x40a00000,0x4002b,0x6,0x474,0xc0133333,0x4002b,0x6,0x4ac, + 0x3d3d70a4,0x40015,0x4cd,0x10,0x1,0x40017,0x4ce,0x4cd,0x2,0x4002b,0x6,0x4f3, + 0xbf000000,0x4002b,0x6,0x501,0xc0200000,0x4002b,0x6,0x502,0x3fc00000,0x4002b,0x6,0x50d, + 0x40000000,0x7002c,0x3e,0x58f,0x122,0x122,0x122,0x122,0x4002b,0x6,0x5f9,0x3f400000, + 0x4002b,0x6,0x61e,0x40400000,0x4002b,0x6,0x627,0x3fd9999a,0x6002c,0xe,0x628,0x627, + 0x123,0x123,0x4002b,0x6,0x62d,0x340018ef,0x6002c,0xe,0x62e,0x62d,0x62d,0x62d, + 0x4002b,0x6,0x6a8,0x3dcccccd,0x4002b,0x6,0x6c8,0x3e19999a,0x4002b,0x6,0x748,0x42c80000, + 0x40017,0x7a7,0x1b1,0x3,0x40020,0x7a8,0x1,0x7a7,0x4003b,0x7a8,0x7a9,0x1, + 0x4002b,0x1b1,0x7bc,0x8,0x6002c,0x7a7,0x7bd,0x7bc,0x7bc,0x24c,0x30001,0x6, + 0x148e,0x30001,0xe,0x1491,0x5002c,0x4d,0x17cf,0x167,0x167,0x5002c,0x1f,0x17d0, + 0x123,0x123,0x5002c,0x1f,0x17d1,0x4f3,0x4f3,0x5002c,0x1f,0x17d2,0x501,0x501, + 0x5002c,0x1f,0x17d3,0x50d,0x50d,0x4002b,0x6,0x17d4,0x40200000,0x5002c,0x1f,0x17d5, + 0x17d4,0x17d4,0x4002b,0x6,0x17d8,0x3d4ccccd,0x4002b,0x1b1,0x187d,0x3,0x4002b,0x1b1, + 0x187e,0x2,0x4002b,0x1b1,0x187f,0x7,0x4002b,0x1b1,0x1880,0x6,0x4002b,0x1b1, + 0x1881,0x5,0x4002b,0x1b1,0x1882,0x4,0x50036,0x2,0x4,0x0,0x3,0x200f8, + 0x5,0x4003b,0x3cf,0xb99,0x7,0x4003d,0x7a7,0x7aa,0x7a9,0x7004f,0x305,0x7ab, + 0x7aa,0x7aa,0x0,0x1,0x4007c,0x4d,0x7ac,0x7ab,0x4006f,0x1f,0x82b,0x7ac, + 0x50081,0x1f,0x82d,0x82b,0x2f1,0x50041,0x15d,0x88b,0x15b,0x24c,0x4003d,0x4d, + 0x88c,0x88b,0x4006f,0x1f,0x82f,0x88c,0x50088,0x1f,0x830,0x82d,0x82f,0x50041, + 0x16d,0x88f,0x15b,0x187d,0x4003d,0x1f,0x890,0x88f,0x50041,0x15d,0x893,0x15b, + 0x15c,0x4003d,0x4d,0x894,0x893,0x4006f,0x1f,0x836,0x894,0x50088,0x1f,0x837, + 0x890,0x836,0x50081,0x1f,0x838,0x830,0x837,0x50041,0x15d,0x89b,0x15b,0x187e, + 0x4003d,0x4d,0x89c,0x89b,0x50085,0x1f,0x8a9,0x838,0x836,0x50083,0x1f,0x8ac, + 0x836,0x2f1,0x7000c,0x1f,0x8b9,0x1,0x25,0x8a9,0x8ac,0x7000c,0x1f,0x8be, + 0x1,0x28,0x2f1,0x8b9,0x4006f,0x1f,0x8b2,0x89c,0x50088,0x1f,0x8b3,0x8be, + 0x8b2,0x50085,0x1f,0x8c6,0x830,0x836,0x4006e,0x4ce,0x8c7,0x8c6,0x40072,0x4d, + 0x8c8,0x8c7,0x4003d,0x18c,0x8d1,0x1cc,0x7005f,0x3e,0x8d3,0x8d1,0x8c8,0x2, + 0x15c,0x7004f,0x1f,0x8d4,0x8d3,0x8d3,0x0,0x1,0x50085,0x1f,0x8d8,0x8d4, + 0x1eb,0x6000c,0x6,0x8d9,0x1,0x42,0x8d8,0x50081,0x1f,0x8e0,0x830,0x8d4, + 0x50051,0x6,0x8e9,0x8e0,0x0,0x500be,0x97,0x8ea,0x8e9,0x122,0x300f7,0x8ef, + 0x0,0x400fa,0x8ea,0x8eb,0x8ef,0x200f8,0x8eb,0x500bc,0x97,0x8ee,0x8e9,0x123, + 0x200f9,0x8ef,0x200f8,0x8ef,0x700f5,0x97,0x8f0,0x8ea,0x5,0x8ee,0x8eb,0x300f7, + 0x8fb,0x0,0x400fa,0x8f0,0x8f1,0x8fb,0x200f8,0x8f1,0x50051,0x6,0x8f3,0x8e0, + 0x1,0x500be,0x97,0x8f4,0x8f3,0x122,0x300f7,0x8f9,0x0,0x400fa,0x8f4,0x8f5, + 0x8f9,0x200f8,0x8f5,0x500bc,0x97,0x8f8,0x8f3,0x123,0x200f9,0x8f9,0x200f8,0x8f9, + 0x700f5,0x97,0x8fa,0x8f4,0x8f1,0x8f8,0x8f5,0x200f9,0x8fb,0x200f8,0x8fb,0x700f5, + 0x97,0x8fc,0x8f0,0x8ef,0x8fa,0x8f9,0x7000c,0x1f,0x921,0x1,0x25,0x8c6, + 0x8ac,0x7000c,0x1f,0x926,0x1,0x28,0x2f1,0x921,0x50088,0x1f,0x91b,0x926, + 0x8b2,0x4003d,0x18c,0x929,0x1b6,0x4003d,0x197,0x92a,0x199,0x50056,0x19b,0x92b, + 0x929,0x92a,0x70058,0x3e,0x92d,0x92b,0x91b,0x2,0x122,0x50051,0x6,0x92e, + 0x92d,0x0,0x50087,0x4d,0x854,0x894,0x17cf,0x4003d,0x18c,0x935,0x1a7,0x50067, + 0x4d,0x936,0x935,0x15c,0x4006f,0x1f,0x942,0x854,0x50085,0x1f,0x943,0x838, + 0x942,0x50083,0x1f,0x946,0x942,0x2f1,0x7000c,0x1f,0x953,0x1,0x25,0x943, + 0x946,0x7000c,0x1f,0x958,0x1,0x28,0x2f1,0x953,0x4006f,0x1f,0x94c,0x936, + 0x50088,0x1f,0x94d,0x958,0x94c,0x4003d,0x18c,0x95b,0x1a7,0x4003d,0x197,0x95c, + 0x199,0x50056,0x19b,0x95d,0x95b,0x95c,0x70058,0x3e,0x95f,0x95d,0x94d,0x2, + 0x122,0x50051,0x6,0x960,0x95f,0x0,0x400a8,0x97,0x85e,0x8fc,0x300f7,0x863, + 0x0,0x400fa,0x8fc,0x860,0x863,0x200f8,0x860,0x50041,0x178,0x963,0x15b,0x187f, + 0x4003d,0x6,0x964,0x963,0x500b4,0x97,0x862,0x122,0x964,0x200f9,0x863,0x200f8, + 0x863,0x700f5,0x97,0x864,0x85e,0x8fb,0x862,0x860,0x4003d,0x18c,0x967,0x1e0, + 0x4003d,0x197,0x968,0x199,0x50056,0x19b,0x969,0x967,0x968,0x70058,0x3e,0x96b, + 0x969,0x8b3,0x2,0x122,0x50051,0x6,0x86a,0x96b,0x0,0x8000c,0x6,0x96f, + 0x1,0x2b,0x86a,0x122,0x123,0x50051,0x6,0x86e,0x96b,0x1,0x8000c,0x6, + 0x973,0x1,0x2b,0x86e,0x122,0x123,0x50051,0x6,0x872,0x96b,0x2,0x8000c, + 0x6,0x977,0x1,0x2b,0x872,0x122,0x123,0x50051,0x6,0x876,0x96b,0x3, + 0x8000c,0x6,0x97b,0x1,0x2b,0x876,0x122,0x123,0x50085,0x6,0x87b,0x97b, + 0x748,0x6000c,0x6,0x87c,0x1,0x1,0x87b,0x500ba,0x97,0x87d,0x87c,0x123, + 0x600a9,0x6,0x87e,0x87d,0x123,0x122,0x50085,0x6,0x881,0x97b,0x87e,0x300f7, + 0x7dd,0x0,0x400fa,0x8fc,0x7d9,0x7dd,0x200f8,0x7d9,0x400a8,0x97,0x7dc,0x864, + 0x200f9,0x7dd,0x200f8,0x7dd,0x700f5,0x97,0x7de,0x8fc,0x863,0x7dc,0x7d9,0x300f7, + 0x7e4,0x0,0x400fa,0x7de,0x7df,0x7e4,0x200f8,0x7df,0x50085,0x1f,0x9b9,0x8e0, + 0x82f,0x50083,0x1f,0x9bc,0x9b9,0x2f1,0x6000c,0x1f,0x9bd,0x1,0x8,0x9bc, + 0x50081,0x1f,0x9bf,0x9bd,0x2f1,0x50083,0x1f,0x9c2,0x9b9,0x9bf,0x5008e,0x1f, + 0x9c6,0x9c2,0x26a,0x50083,0x1f,0x9c8,0x17d0,0x9c6,0x50085,0x1f,0x9c9,0x9c2, + 0x9c8,0x50081,0x1f,0x9cb,0x17d1,0x9c9,0x50085,0x1f,0x9cc,0x9c2,0x9cb,0x50085, + 0x1f,0x9cf,0x9c2,0x9c2,0x5008e,0x1f,0x9d1,0x9c2,0x502,0x50081,0x1f,0x9d3, + 0x17d2,0x9d1,0x50085,0x1f,0x9d4,0x9cf,0x9d3,0x50081,0x1f,0x9d6,0x17d0,0x9d4, + 0x50083,0x1f,0x9dc,0x17d3,0x9d1,0x50085,0x1f,0x9dd,0x9c2,0x9dc,0x50081,0x1f, + 0x9df,0x2f1,0x9dd,0x50085,0x1f,0x9e0,0x9c2,0x9df,0x50081,0x1f,0x9e7,0x17d1, + 0x9c6,0x50085,0x1f,0x9e8,0x9cf,0x9e7,0x50081,0x1f,0x9eb,0x9d6,0x9e0,0x50081, + 0x1f,0x9ee,0x9bd,0x17d1,0x50088,0x1f,0x9f0,0x9ee,0x82f,0x50081,0x1f,0x9f3, + 0x9bd,0x17d5,0x50088,0x1f,0x9f5,0x9f3,0x82f,0x50088,0x1f,0x9f9,0x9e0,0x9eb, + 0x50081,0x1f,0x9fa,0x9bf,0x9f9,0x50088,0x1f,0x9fc,0x9fa,0x82f,0x50051,0x6, + 0x9fe,0x9eb,0x0,0x50051,0x6,0xa00,0x9cc,0x1,0x50085,0x6,0xa01,0x9fe, + 0xa00,0x50051,0x6,0xa03,0x9cc,0x0,0x50051,0x6,0xa05,0x9eb,0x1,0x50085, + 0x6,0xa06,0xa03,0xa05,0x50085,0x6,0xa0b,0x9fe,0xa05,0x50051,0x6,0xa0d, + 0x9e8,0x0,0x50085,0x6,0xa10,0xa0d,0xa05,0x50051,0x6,0xa14,0x9e8,0x1, + 0x50085,0x6,0xa15,0x9fe,0xa14,0x50051,0x6,0xa17,0x9fc,0x0,0x50051,0x6, + 0xa19,0x9f0,0x1,0x50050,0x1f,0xa1a,0xa17,0xa19,0x4003d,0x18c,0xa4d,0x195, + 0x4003d,0x197,0xa4e,0x199,0x50056,0x19b,0xa4f,0xa4d,0xa4e,0x70058,0x3e,0xa51, + 0xa4f,0xa1a,0x2,0x122,0x5008e,0x3e,0xa1d,0xa51,0xa01,0x50051,0x6,0xa1f, + 0x9f0,0x0,0x50051,0x6,0xa21,0x9fc,0x1,0x50050,0x1f,0xa22,0xa1f,0xa21, + 0x4003d,0x18c,0xa54,0x195,0x4003d,0x197,0xa55,0x199,0x50056,0x19b,0xa56,0xa54, + 0xa55,0x70058,0x3e,0xa58,0xa56,0xa22,0x2,0x122,0x5008e,0x3e,0xa25,0xa58, + 0xa06,0x50081,0x3e,0xa26,0xa1d,0xa25,0x4003d,0x18c,0xa5b,0x195,0x4003d,0x197, + 0xa5c,0x199,0x50056,0x19b,0xa5d,0xa5b,0xa5c,0x70058,0x3e,0xa5f,0xa5d,0x9fc, + 0x2,0x122,0x5008e,0x3e,0xa2a,0xa5f,0xa0b,0x50081,0x3e,0xa2b,0xa26,0xa2a, + 0x50051,0x6,0xa2d,0x9f5,0x0,0x50050,0x1f,0xa30,0xa2d,0xa21,0x4003d,0x18c, + 0xa62,0x195,0x4003d,0x197,0xa63,0x199,0x50056,0x19b,0xa64,0xa62,0xa63,0x70058, + 0x3e,0xa66,0xa64,0xa30,0x2,0x122,0x5008e,0x3e,0xa33,0xa66,0xa10,0x50081, + 0x3e,0xa34,0xa2b,0xa33,0x50051,0x6,0xa38,0x9f5,0x1,0x50050,0x1f,0xa39, + 0xa17,0xa38,0x4003d,0x18c,0xa69,0x195,0x4003d,0x197,0xa6a,0x199,0x50056,0x19b, + 0xa6b,0xa69,0xa6a,0x70058,0x3e,0xa6d,0xa6b,0xa39,0x2,0x122,0x5008e,0x3e, + 0xa3c,0xa6d,0xa15,0x50081,0x3e,0xa3d,0xa34,0xa3c,0x50081,0x6,0xa41,0xa01, + 0xa06,0x50081,0x6,0xa43,0xa41,0xa0b,0x50081,0x6,0xa45,0xa43,0xa10,0x50081, + 0x6,0xa47,0xa45,0xa15,0x70050,0x3e,0xa48,0xa47,0xa47,0xa47,0xa47,0x50088, + 0x3e,0xa49,0xa3d,0xa48,0x7000c,0x3e,0xa72,0x1,0x28,0xa49,0x58f,0x8004f, + 0xe,0x986,0xa72,0xa72,0x0,0x1,0x2,0x50041,0x178,0xa75,0x15b,0x1880, + 0x4003d,0x6,0xa76,0xa75,0x5008e,0xe,0x98b,0x986,0xa76,0x4003d,0x18c,0xa7a, + 0x1d4,0x7005f,0x3e,0xa7b,0xa7a,0x1d6,0x2,0x15c,0x50051,0x6,0xa7c,0xa7b, + 0x0,0x500b4,0x97,0xa7e,0xa7c,0x122,0x600a9,0x6,0x17dd,0xa7e,0x123,0xa7c, + 0x5008e,0xe,0x990,0x98b,0x17dd,0x50051,0x6,0xa86,0x990,0x0,0x50085,0x6, + 0xa87,0x266,0xa86,0x50051,0x6,0xa89,0x990,0x1,0x50085,0x6,0xa8a,0x26a, + 0xa89,0x50081,0x6,0xa8b,0xa87,0xa8a,0x50051,0x6,0xa8d,0x990,0x2,0x50085, + 0x6,0xa8e,0x266,0xa8d,0x50081,0x6,0xa8f,0xa8b,0xa8e,0x50083,0x6,0x17d6, + 0xa86,0xa8d,0x50085,0x6,0xa96,0x26a,0x17d6,0x50085,0x6,0xa99,0x27a,0xa86, + 0x50081,0x6,0xa9d,0xa99,0xa8a,0x50083,0x6,0xaa1,0xa9d,0xa8e,0x60050,0xe, + 0xaa2,0xa8f,0xa96,0xaa1,0x50051,0x6,0x997,0xa72,0x3,0x200f9,0x7e4,0x200f8, + 0x7e4,0x700f5,0xe,0x1523,0x352,0x7dd,0xaa2,0x7df,0x700f5,0x6,0x1521,0x122, + 0x7dd,0x997,0x7df,0x400a8,0x97,0xabe,0x864,0x600a9,0x6,0xabf,0xabe,0x123, + 0x122,0x50085,0x6,0xac2,0x1521,0xabf,0x8000c,0x6,0xb08,0x1,0x2b,0x977, + 0x122,0x123,0x7000c,0x6,0xb0d,0x1,0x28,0x96f,0x973,0x7000c,0x6,0xb12, + 0x1,0x28,0xb08,0xb0d,0x50085,0x6,0xad0,0xb12,0x50d,0x50083,0x6,0xad1, + 0xac2,0xad0,0x7000c,0x6,0xb17,0x1,0x28,0x122,0xad1,0x50083,0x6,0xad6, + 0xb17,0x123,0x8000c,0x6,0xb1b,0x1,0x2b,0xad6,0x122,0x123,0x8000c,0x6, + 0xb1f,0x1,0x2b,0xb1b,0x122,0x123,0x4003d,0x1bf,0xb22,0x1c1,0x50062,0x3e, + 0xb24,0xb22,0x7ac,0x50051,0x6,0xb25,0xb24,0x0,0x7000c,0x6,0xb2a,0x1, + 0x28,0x122,0x96f,0x50083,0x6,0xae4,0x123,0xb2a,0x50085,0x6,0xae5,0xb25, + 0xae4,0x50081,0x6,0xae9,0xb17,0xae5,0x7000c,0x6,0xb2f,0x1,0x25,0xae9, + 0x50d,0x7000c,0x6,0xb34,0x1,0x28,0x122,0xb2f,0x50041,0x178,0xb37,0x15b, + 0x1881,0x4003d,0x6,0xb38,0xb37,0x50088,0x6,0xaee,0x6a8,0xb38,0x50083,0x6, + 0xaf0,0x123,0xb12,0x50085,0x6,0xaf1,0xaee,0xaf0,0x50083,0x6,0xaf5,0xb34, + 0xaf1,0x7000c,0x6,0xb3d,0x1,0x28,0x122,0xaf5,0x50083,0x1f,0xafc,0x830, + 0x8d4,0x50051,0x6,0xb41,0xafc,0x0,0x500be,0x97,0xb42,0xb41,0x122,0x300f7, + 0xb47,0x0,0x400fa,0xb42,0xb43,0xb47,0x200f8,0xb43,0x500bc,0x97,0xb46,0xb41, + 0x123,0x200f9,0xb47,0x200f8,0xb47,0x700f5,0x97,0xb48,0xb42,0x7e4,0xb46,0xb43, + 0x300f7,0xb53,0x0,0x400fa,0xb48,0xb49,0xb53,0x200f8,0xb49,0x50051,0x6,0xb4b, + 0xafc,0x1,0x500be,0x97,0xb4c,0xb4b,0x122,0x300f7,0xb51,0x0,0x400fa,0xb4c, + 0xb4d,0xb51,0x200f8,0xb4d,0x500bc,0x97,0xb50,0xb4b,0x123,0x200f9,0xb51,0x200f8, + 0xb51,0x700f5,0x97,0xb52,0xb4c,0xb49,0xb50,0xb4d,0x200f9,0xb53,0x200f8,0xb53, + 0x700f5,0x97,0xb54,0xb48,0xb47,0xb52,0xb51,0x600a9,0x6,0xb00,0xb54,0x123, + 0x122,0x50085,0x6,0xb03,0xb3d,0xb00,0x50041,0x178,0xb6e,0x15b,0x7bc,0x4003d, + 0x6,0xb6f,0xb6e,0x50085,0x6,0xb62,0x8d9,0xb6f,0x50085,0x6,0xb63,0xb62, + 0x50d,0x7000c,0x6,0xb74,0x1,0x28,0x122,0xb63,0x8000c,0x6,0xb78,0x1, + 0x2b,0xb74,0x122,0x123,0x8000c,0x6,0xb7e,0x1,0x2e,0x881,0x6c8,0xb78, + 0x7000c,0x6,0xb83,0x1,0x25,0x881,0xb7e,0x50041,0x16d,0xce3,0x15b,0x1882, + 0x4003d,0x1f,0xce4,0xce3,0x50085,0x1f,0xbcc,0x82d,0xce4,0x6000c,0x1f,0xbce, + 0x1,0x8,0xbcc,0x4006e,0x4d,0xbcf,0xbce,0x4006f,0x1f,0xbd1,0xbcf,0x50081, + 0x1f,0xbd2,0xbd1,0x2f1,0x50083,0x1f,0xbd4,0xbd2,0x890,0x50083,0x1f,0xbd7, + 0xbd4,0xbcc,0x50051,0x6,0xbd9,0xbd4,0x0,0x50051,0x6,0xbdb,0xbcc,0x0, + 0x500ba,0x97,0xbdc,0xbd9,0xbdb,0x600a9,0x2b,0xbdd,0xbdc,0x37e,0x37f,0x50051, + 0x6,0xbe0,0xbd4,0x1,0x50051,0x6,0xbe2,0xbcc,0x1,0x500ba,0x97,0xbe3, + 0xbe0,0xbe2,0x600a9,0x2b,0xbe4,0xbe3,0x37e,0x37f,0x50050,0x4d,0x188d,0xbdd, + 0xbe4,0x4006f,0x1f,0xbf1,0x188d,0x500b4,0x97,0xbf3,0x881,0x122,0x200f9,0xbf4, + 0x200f8,0xbf4,0x700f5,0x2b,0x1579,0x15c,0xb53,0xc23,0xc21,0x700f5,0x2b,0x16cf, + 0x15c,0xb53,0x16ce,0xc21,0x500b1,0x97,0xbf7,0x1579,0x1f1,0x400f6,0xc24,0xc21, + 0x0,0x400fa,0xbf7,0xbf8,0xc24,0x200f8,0xbf8,0x200f9,0xbf9,0x200f8,0xbf9,0x700f5, + 0x2b,0x16ce,0x16cf,0xbf8,0xc1c,0xc1d,0x700f5,0x2b,0x16c1,0x15c,0xbf8,0xc1f, + 0xc1d,0x500b1,0x97,0xbfc,0x16c1,0x1f1,0x400f6,0xc20,0xc1d,0x0,0x400fa,0xbfc, + 0xbfd,0xc20,0x200f8,0xbfd,0x300f7,0xc04,0x0,0x400fa,0xbdc,0xbff,0xc02,0x200f8, + 0xbff,0x50082,0x2b,0xc01,0x1f1,0x16c1,0x200f9,0xc04,0x200f8,0xc02,0x200f9,0xc04, + 0x200f8,0xc04,0x700f5,0x2b,0x16c4,0xc01,0xbff,0x16c1,0xc02,0x300f7,0xc0c,0x0, + 0x400fa,0xbe3,0xc07,0xc0a,0x200f8,0xc07,0x50082,0x2b,0xc09,0x1f1,0x1579,0x200f9, + 0xc0c,0x200f8,0xc0a,0x200f9,0xc0c,0x200f8,0xc0c,0x700f5,0x2b,0x16c8,0xc09,0xc07, + 0x1579,0xc0a,0x50050,0x4d,0xc0e,0x16c4,0x16c8,0x50080,0x4d,0xc11,0xbcf,0x188d, + 0x50080,0x4d,0xc13,0xc11,0xc0e,0x50051,0x2b,0xcfc,0x894,0x0,0x50082,0x2b, + 0xcfd,0xcfc,0x1f7,0x50051,0x2b,0xcff,0xc13,0x0,0x7000c,0x2b,0xd10,0x1, + 0x27,0xcff,0xcfd,0x7000c,0x2b,0xd15,0x1,0x2a,0x15c,0xd10,0x50051,0x2b, + 0xd04,0x894,0x1,0x50082,0x2b,0xd05,0xd04,0x1f7,0x50051,0x2b,0xd07,0xc13, + 0x1,0x7000c,0x2b,0xd1a,0x1,0x27,0xd07,0xd05,0x7000c,0x2b,0xd1f,0x1, + 0x2a,0x15c,0xd1a,0x50050,0x4d,0x188e,0xd15,0xd1f,0x4003d,0x18c,0xd32,0x18e, + 0x7005f,0x3e,0xd34,0xd32,0x188e,0x2,0x15c,0x8004f,0xe,0xd35,0xd34,0xd34, + 0x0,0x1,0x2,0x7000c,0xe,0xd3a,0x1,0x28,0x352,0xd35,0x4003d,0x18c, + 0xd3e,0x1d4,0x7005f,0x3e,0xd3f,0xd3e,0x1d6,0x2,0x15c,0x50051,0x6,0xd40, + 0xd3f,0x0,0x500b4,0x97,0xd42,0xd40,0x122,0x600a9,0x6,0x17de,0xd42,0x123, + 0xd40,0x5008e,0xe,0xd2c,0xd3a,0x17de,0x50051,0x6,0xd4a,0xd2c,0x0,0x50085, + 0x6,0xd4b,0x266,0xd4a,0x50051,0x6,0xd4d,0xd2c,0x1,0x50085,0x6,0xd4e, + 0x26a,0xd4d,0x50081,0x6,0xd4f,0xd4b,0xd4e,0x50051,0x6,0xd51,0xd2c,0x2, + 0x50085,0x6,0xd52,0x266,0xd51,0x50081,0x6,0xd53,0xd4f,0xd52,0x50083,0x6, + 0x17dc,0xd4a,0xd51,0x50085,0x6,0xd5a,0x26a,0x17dc,0x50085,0x6,0xd5d,0x27a, + 0xd4a,0x50081,0x6,0xd61,0xd5d,0xd4e,0x50083,0x6,0xd65,0xd61,0xd52,0x60050, + 0xe,0xd66,0xd53,0xd5a,0xd65,0x50041,0xf,0xc1a,0xb99,0x16ce,0x3003e,0xc1a, + 0xd66,0x50080,0x2b,0xc1c,0x16ce,0x1f7,0x200f9,0xc1d,0x200f8,0xc1d,0x50080,0x2b, + 0xc1f,0x16c1,0x1f7,0x200f9,0xbf9,0x200f8,0xc20,0x200f9,0xc21,0x200f8,0xc21,0x50080, + 0x2b,0xc23,0x1579,0x1f7,0x200f9,0xbf4,0x200f8,0xc24,0x300f7,0xc38,0x0,0x400fa, + 0xbf3,0xc26,0xc38,0x200f8,0xc26,0x200f9,0xc27,0x200f8,0xc27,0x700f5,0x2b,0x157b, + 0x15c,0xc26,0xc36,0xc2b,0x500b1,0x97,0xc2a,0x157b,0x3e5,0x400f6,0xc37,0xc2b, + 0x0,0x400fa,0xc2a,0xc2b,0xc37,0x200f8,0xc2b,0x50041,0xf,0xc2e,0xb99,0x157b, + 0x4003d,0xe,0xc2f,0xc2e,0x50051,0x6,0xd6c,0xc2f,0x0,0x50051,0x6,0xd6e, + 0xc2f,0x1,0x50081,0x6,0xd6f,0xd6c,0xd6e,0x50051,0x6,0xd71,0xc2f,0x2, + 0x50083,0x6,0xd72,0xd6f,0xd71,0x50081,0x6,0xd77,0xd6c,0xd71,0x50083,0x6, + 0xd7c,0xd6c,0xd6e,0x50083,0x6,0xd7f,0xd7c,0xd71,0x60050,0xe,0xd80,0xd72, + 0xd77,0xd7f,0x7000c,0x6,0xd9b,0x1,0x28,0x122,0xd72,0x7000c,0x6,0xda0, + 0x1,0x28,0xd77,0xd7f,0x7000c,0x6,0xda5,0x1,0x28,0xd9b,0xda0,0x50081, + 0x6,0xd94,0xda5,0x123,0x60050,0xe,0xd95,0xd94,0xd94,0xd94,0x50088,0xe, + 0xd96,0xd80,0xd95,0x50051,0x6,0xdaa,0xd96,0x0,0x50085,0x6,0xdab,0x266, + 0xdaa,0x50051,0x6,0xdad,0xd96,0x1,0x50085,0x6,0xdae,0x26a,0xdad,0x50081, + 0x6,0xdaf,0xdab,0xdae,0x50051,0x6,0xdb1,0xd96,0x2,0x50085,0x6,0xdb2, + 0x266,0xdb1,0x50081,0x6,0xdb3,0xdaf,0xdb2,0x50083,0x6,0x17db,0xdaa,0xdb1, + 0x50085,0x6,0xdba,0x26a,0x17db,0x50085,0x6,0xdbd,0x27a,0xdaa,0x50081,0x6, + 0xdc1,0xdbd,0xdae,0x50083,0x6,0xdc5,0xdc1,0xdb2,0x60050,0xe,0xdc6,0xdb3, + 0xdba,0xdc5,0x3003e,0xc2e,0xdc6,0x50080,0x2b,0xc36,0x157b,0x1f7,0x200f9,0xc27, + 0x200f8,0xc37,0x200f9,0xc38,0x200f8,0xc38,0x50088,0x1f,0xdcf,0x17d0,0xce4,0x50083, + 0x1f,0xdd1,0xdcf,0x17d0,0x50051,0x6,0xdd2,0xdd1,0x0,0x50081,0x6,0xdd3, + 0x123,0xdd2,0x7000c,0x6,0xdde,0x1,0x25,0x34a,0xdd3,0x50081,0x6,0xc3d, + 0x123,0xdde,0x50085,0x6,0xc3e,0xc3d,0x3fc,0x7000c,0x6,0xde3,0x1,0x28, + 0x123,0xc3e,0x50085,0x6,0xc41,0x973,0x26a,0x50083,0x6,0xc42,0x123,0xc41, + 0x50083,0x6,0xc44,0x123,0x977,0x50085,0x6,0xc47,0xb83,0x409,0x8000c,0x6, + 0xde7,0x1,0x2b,0xc47,0x122,0x123,0x7000c,0x6,0xdec,0x1,0x25,0xc44, + 0xde7,0x7000c,0x6,0xdf1,0x1,0x25,0xc42,0xdec,0x8000c,0x6,0xdf7,0x1, + 0x2e,0xde3,0xdde,0xdf1,0x200f9,0xc4f,0x200f8,0xc4f,0x700f5,0xe,0x15ab,0x352, + 0xc38,0x169a,0xcae,0x700f5,0x6,0x15a9,0x122,0xc38,0x169d,0xcae,0x700f5,0xe, + 0x15a2,0x1491,0xc38,0x16b9,0xcae,0x700f5,0xe,0x15a1,0x1491,0xc38,0x16b5,0xcae, + 0x700f5,0xe,0x15a0,0x1491,0xc38,0x16b1,0xcae,0x700f5,0xe,0x159f,0x1491,0xc38, + 0x16ad,0xcae,0x700f5,0x6,0x159e,0x148e,0xc38,0x16a9,0xcae,0x700f5,0x2b,0x159d, + 0x15c,0xc38,0xcb0,0xcae,0x700f5,0x2b,0x1697,0x15c,0xc38,0x1696,0xcae,0x500b1, + 0x97,0xc52,0x159d,0x1f1,0x400f6,0xcb1,0xcae,0x0,0x400fa,0xc52,0xc53,0xcb1, + 0x200f8,0xc53,0x200f9,0xc54,0x200f8,0xc54,0x700f5,0xe,0x16b9,0x15a2,0xc53,0x16be, + 0xcaa,0x700f5,0xe,0x16b5,0x15a1,0xc53,0x16bd,0xcaa,0x700f5,0xe,0x16b1,0x15a0, + 0xc53,0x16bc,0xcaa,0x700f5,0xe,0x16ad,0x159f,0xc53,0x16bb,0xcaa,0x700f5,0x6, + 0x16a9,0x159e,0xc53,0x16ba,0xcaa,0x700f5,0x6,0x169d,0x15a9,0xc53,0x17c6,0xcaa, + 0x700f5,0xe,0x169a,0x15ab,0xc53,0x17c4,0xcaa,0x700f5,0x2b,0x1696,0x1697,0xc53, + 0xca9,0xcaa,0x700f5,0x2b,0x1668,0x15c,0xc53,0xcac,0xcaa,0x500b1,0x97,0xc57, + 0x1668,0x1f1,0x400f6,0xcad,0xcaa,0x0,0x400fa,0xc57,0xc58,0xcad,0x200f8,0xc58, + 0x300f7,0xc5f,0x0,0x400fa,0xbdc,0xc5a,0xc5d,0x200f8,0xc5a,0x50082,0x2b,0xc5c, + 0x1f1,0x1668,0x200f9,0xc5f,0x200f8,0xc5d,0x200f9,0xc5f,0x200f8,0xc5f,0x700f5,0x2b, + 0x166f,0xc5c,0xc5a,0x1668,0xc5d,0x300f7,0xc67,0x0,0x400fa,0xbe3,0xc62,0xc65, + 0x200f8,0xc62,0x50082,0x2b,0xc64,0x1f1,0x159d,0x200f9,0xc67,0x200f8,0xc65,0x200f9, + 0xc67,0x200f8,0xc67,0x700f5,0x2b,0x1677,0xc64,0xc62,0x159d,0xc65,0x50050,0x4d, + 0xc69,0x166f,0x1677,0x4006f,0x1f,0xc6c,0xc69,0x50081,0x1f,0xc6d,0xbf1,0xc6c, + 0x50081,0x1f,0xc70,0xbd7,0xc6d,0x50080,0x4d,0xc73,0xbcf,0x188d,0x50080,0x4d, + 0xc75,0xc73,0xc69,0x4007c,0x305,0xdff,0xc75,0x4007c,0x305,0xe01,0x894,0x500b0, + 0x309,0xe02,0xdff,0xe01,0x4009b,0x97,0xe03,0xe02,0x600a9,0x6,0xc79,0xe03, + 0x123,0x122,0x400a8,0x97,0xc7b,0xbf3,0x300f7,0xc90,0x0,0x400fa,0xc7b,0xc7c, + 0xc90,0x200f8,0xc7c,0x50050,0x1f,0xe0b,0xdf7,0xdf7,0x50085,0x1f,0xe0c,0xc70, + 0xe0b,0x50094,0x6,0xe0f,0xe0c,0xe0c,0x7000c,0x6,0xe1f,0x1,0x25,0xe0f, + 0x324,0x50085,0x6,0xe25,0x30f,0xe1f,0x50083,0x6,0xe26,0xe25,0x123,0x50085, + 0x6,0xe28,0x266,0xe1f,0x50083,0x6,0xe29,0xe28,0x123,0x50085,0x6,0xe2b, + 0x317,0xe26,0x50085,0x6,0xe2d,0xe2b,0xe26,0x50083,0x6,0xe2e,0xe2d,0x31c, + 0x50085,0x6,0xe31,0xe29,0xe29,0x50085,0x6,0xe32,0xe2e,0xe31,0x50085,0x6, + 0xc81,0xc79,0xe32,0x50041,0xf,0xc83,0xb99,0x1696,0x4003d,0xe,0xc84,0xc83, + 0x5008e,0xe,0xc86,0xc84,0xc81,0x50081,0xe,0xc89,0x169a,0xc86,0x50081,0x6, + 0xc8e,0x169d,0xc81,0x200f9,0xc90,0x200f8,0xc90,0x700f5,0x6,0x17c6,0x169d,0xc67, + 0xc8e,0xc7c,0x700f5,0xe,0x17c4,0x169a,0xc67,0xc89,0xc7c,0x50094,0x6,0xc93, + 0xc70,0xc70,0x50085,0x6,0xc95,0x474,0xc93,0x6000c,0x6,0xc96,0x1,0x1b, + 0xc95,0x50085,0x6,0xc98,0xc96,0xc79,0x500aa,0x97,0xc9a,0x159d,0x15c,0x500aa, + 0x97,0xc9c,0x1668,0x15c,0x500a7,0x97,0xc9d,0xc9a,0xc9c,0x50041,0xf,0xc9f, + 0xb99,0x1696,0x4003d,0xe,0xca0,0xc9f,0x300f7,0xe58,0x0,0x400fa,0xc9d,0xe3b, + 0xe3f,0x200f8,0xe3b,0x5008e,0xe,0xe5d,0xca0,0xc98,0x50085,0xe,0xe61,0xca0, + 0xe5d,0x200f9,0xe58,0x200f8,0xe3f,0x7000c,0xe,0xe68,0x1,0x25,0x16b1,0xca0, + 0x7000c,0xe,0xe6d,0x1,0x28,0x16ad,0xca0,0x5008e,0xe,0xe48,0xca0,0xc98, + 0x50081,0xe,0xe4c,0x16b9,0xe48,0x50085,0xe,0xe4f,0xca0,0xe48,0x50081,0xe, + 0xe52,0x16b5,0xe4f,0x50081,0x6,0xe56,0x16a9,0xc98,0x200f9,0xe58,0x200f8,0xe58, + 0x700f5,0xe,0x16be,0xe5d,0xe3b,0xe4c,0xe3f,0x700f5,0xe,0x16bd,0xe61,0xe3b, + 0xe52,0xe3f,0x700f5,0xe,0x16bc,0xca0,0xe3b,0xe68,0xe3f,0x700f5,0xe,0x16bb, + 0xca0,0xe3b,0xe6d,0xe3f,0x700f5,0x6,0x16ba,0xc98,0xe3b,0xe56,0xe3f,0x50080, + 0x2b,0xca9,0x1696,0x1f7,0x200f9,0xcaa,0x200f8,0xcaa,0x50080,0x2b,0xcac,0x1668, + 0x1f7,0x200f9,0xc54,0x200f8,0xcad,0x200f9,0xcae,0x200f8,0xcae,0x50080,0x2b,0xcb0, + 0x159d,0x1f7,0x200f9,0xc4f,0x200f8,0xcb1,0x6000c,0x6,0xe73,0x1,0x4,0x159e, + 0x500ba,0x97,0xe74,0xe73,0x224,0x600a9,0x6,0x17df,0xe74,0x159e,0x123,0x60050, + 0xe,0xe80,0x17df,0x17df,0x17df,0x50088,0xe,0xe81,0x15a2,0xe80,0x50088,0xe, + 0xe88,0x15a1,0xe80,0x50085,0xe,0xe90,0xe81,0xe81,0x50083,0xe,0xe91,0xe88, + 0xe90,0x6000c,0xe,0xe92,0x1,0x4,0xe91,0x6000c,0xe,0xe93,0x1,0x1f, + 0xe92,0x500ba,0x97,0xcb9,0x15a9,0x2a0,0x600a9,0x6,0xcba,0xcb9,0x123,0x122, + 0x50085,0x6,0xcbd,0x15a9,0xcba,0x500ba,0x97,0xcc1,0xcbd,0x2a0,0x300f7,0xcd5, + 0x0,0x400fa,0xcc1,0xcc2,0xcd5,0x200f8,0xcc2,0x60050,0xe,0xcc7,0xcbd,0xcbd, + 0xcbd,0x50088,0xe,0xcc8,0x15ab,0xcc7,0x50085,0x6,0xccc,0xcbd,0x4ac,0x8000c, + 0xe,0xe9c,0x1,0x2b,0xcc8,0x15a0,0x159f,0x200f9,0xcd5,0x200f8,0xcd5,0x700f5, + 0xe,0x15c5,0x15ab,0xcb1,0xe9c,0xcc2,0x700f5,0x6,0x15c3,0xcbd,0xcb1,0xccc, + 0xcc2,0x300f7,0xce0,0x0,0x400fa,0xbf3,0xcd7,0xce0,0x200f8,0xcd7,0x50051,0x6, + 0xea1,0xe81,0x0,0x50051,0x6,0xea3,0xe81,0x1,0x50081,0x6,0xea4,0xea1, + 0xea3,0x50051,0x6,0xea6,0xe81,0x2,0x50083,0x6,0xea7,0xea4,0xea6,0x50081, + 0x6,0xeac,0xea1,0xea6,0x50083,0x6,0xeb1,0xea1,0xea3,0x50083,0x6,0xeb4, + 0xeb1,0xea6,0x60050,0xe,0xeb5,0xea7,0xeac,0xeb4,0x7000c,0x6,0xed0,0x1, + 0x28,0xeac,0xeb4,0x7000c,0x6,0xed5,0x1,0x28,0xea7,0xed0,0x50083,0x6, + 0xec8,0x123,0xed5,0x7000c,0x6,0xeda,0x1,0x28,0x2a0,0xec8,0x60050,0xe, + 0xeca,0xeda,0xeda,0xeda,0x50088,0xe,0xecb,0xeb5,0xeca,0x50051,0x6,0xedf, + 0xecb,0x0,0x50085,0x6,0xee0,0x266,0xedf,0x50051,0x6,0xee2,0xecb,0x1, + 0x50085,0x6,0xee3,0x26a,0xee2,0x50081,0x6,0xee4,0xee0,0xee3,0x50051,0x6, + 0xee6,0xecb,0x2,0x50085,0x6,0xee7,0x266,0xee6,0x50081,0x6,0xee8,0xee4, + 0xee7,0x50083,0x6,0x17d7,0xedf,0xee6,0x50085,0x6,0xeef,0x26a,0x17d7,0x50085, + 0x6,0xef2,0x27a,0xedf,0x50081,0x6,0xef6,0xef2,0xee3,0x50083,0x6,0xefa, + 0xef6,0xee7,0x60050,0xe,0xefb,0xee8,0xeef,0xefa,0x200f9,0xce0,0x200f8,0xce0, + 0x700f5,0xe,0x15c4,0x15c5,0xcd5,0xefb,0xcd7,0x600a9,0x6,0x17e0,0xbf3,0x123, + 0x15c3,0x600a9,0x6,0x17e1,0xbf3,0x122,0xb83,0x50085,0x6,0xf23,0x8d9,0x17d8, + 0x8000c,0x6,0xf67,0x1,0x2b,0xf23,0x122,0x123,0x50085,0x6,0xf26,0x960, + 0x17d8,0x50083,0x6,0xf27,0x5f9,0xf26,0x8000c,0x6,0xf6b,0x1,0x2b,0xf27, + 0x122,0x123,0x50083,0x6,0xf2a,0x123,0x881,0x7000c,0x6,0xf70,0x1,0x1a, + 0x96f,0x26a,0x7000c,0x6,0xf75,0x1,0x28,0xf70,0x977,0x7000c,0x6,0xf7a, + 0x1,0x28,0xf2a,0xf75,0x7000c,0x6,0xf7f,0x1,0x28,0xf6b,0xf7a,0x7000c, + 0x6,0xf84,0x1,0x28,0xf67,0xf7f,0x8000c,0x6,0xf8a,0x1,0x2e,0x61e, + 0x123,0xf84,0x50085,0xe,0xf3b,0xe93,0x628,0x5008e,0xe,0xf3d,0xf3b,0xf8a, + 0x7000c,0xe,0xf8f,0x1,0x28,0xf3d,0x62e,0x50083,0xe,0xf44,0x1523,0xe81, + 0x50088,0xe,0xf46,0xf44,0xf8f,0x6000c,0x6,0xf48,0x1,0x42,0xf46,0x500ba, + 0x97,0xf49,0xf48,0x123,0x300f7,0xf63,0x0,0x400fa,0xf49,0xf4a,0xf63,0x200f8, + 0xf4a,0x6000c,0xe,0xf4c,0x1,0x45,0xf46,0x50085,0xe,0xf4f,0xf4c,0xf3d, + 0x50081,0xe,0xf52,0xf4f,0xe81,0x7000c,0x6,0xf94,0x1,0x28,0x92e,0xb1f, + 0x50085,0x6,0xf58,0xf94,0x881,0x50083,0x6,0xf5a,0x123,0x973,0x50085,0x6, + 0xf5b,0xf58,0xf5a,0x8000c,0x6,0xf98,0x1,0x2b,0xf5b,0x122,0x123,0x60050, + 0xe,0xf9e,0xf98,0xf98,0xf98,0x8000c,0xe,0xf9f,0x1,0x2e,0xf52,0x1523, + 0xf9e,0x200f9,0xf63,0x200f8,0xf63,0x700f5,0xe,0x163b,0x1523,0xce0,0xf9f,0xf4a, + 0x500ba,0x97,0xfb2,0x17e1,0x2a0,0x600a9,0x6,0xfb3,0xfb2,0x123,0x122,0x50085, + 0x6,0xfb6,0x17e1,0xfb3,0x50081,0x6,0xfbc,0xfb6,0x17e0,0x7000c,0x6,0xfe4, + 0x1,0x28,0x2a0,0xfbc,0x50051,0x6,0xfe9,0x15c4,0x0,0x50051,0x6,0xfeb, + 0x15c4,0x1,0x50081,0x6,0xfec,0xfe9,0xfeb,0x50051,0x6,0xfee,0x15c4,0x2, + 0x50083,0x6,0xfef,0xfec,0xfee,0x50081,0x6,0xff4,0xfe9,0xfee,0x50083,0x6, + 0xff9,0xfe9,0xfeb,0x50083,0x6,0xffc,0xff9,0xfee,0x60050,0xe,0xffd,0xfef, + 0xff4,0xffc,0x7000c,0x6,0x1018,0x1,0x28,0x122,0xfef,0x7000c,0x6,0x101d, + 0x1,0x28,0xff4,0xffc,0x7000c,0x6,0x1022,0x1,0x28,0x1018,0x101d,0x50081, + 0x6,0x1011,0x1022,0x123,0x60050,0xe,0x1012,0x1011,0x1011,0x1011,0x50088,0xe, + 0x1013,0xffd,0x1012,0x50051,0x6,0x1027,0x1013,0x0,0x50085,0x6,0x1028,0x266, + 0x1027,0x50051,0x6,0x102a,0x1013,0x1,0x50085,0x6,0x102b,0x26a,0x102a,0x50081, + 0x6,0x102c,0x1028,0x102b,0x50051,0x6,0x102e,0x1013,0x2,0x50085,0x6,0x102f, + 0x266,0x102e,0x50081,0x6,0x1030,0x102c,0x102f,0x50083,0x6,0x17d9,0x1027,0x102e, + 0x50085,0x6,0x1037,0x26a,0x17d9,0x50085,0x6,0x103a,0x27a,0x1027,0x50081,0x6, + 0x103e,0x103a,0x102b,0x50083,0x6,0x1042,0x103e,0x102f,0x60050,0xe,0x1043,0x1030, + 0x1037,0x1042,0x50051,0x6,0x1049,0x163b,0x0,0x50051,0x6,0x104b,0x163b,0x1, + 0x50081,0x6,0x104c,0x1049,0x104b,0x50051,0x6,0x104e,0x163b,0x2,0x50083,0x6, + 0x104f,0x104c,0x104e,0x50081,0x6,0x1054,0x1049,0x104e,0x50083,0x6,0x1059,0x1049, + 0x104b,0x50083,0x6,0x105c,0x1059,0x104e,0x60050,0xe,0x105d,0x104f,0x1054,0x105c, + 0x7000c,0x6,0x1078,0x1,0x28,0x122,0x104f,0x7000c,0x6,0x107d,0x1,0x28, + 0x1054,0x105c,0x7000c,0x6,0x1082,0x1,0x28,0x1078,0x107d,0x50081,0x6,0x1071, + 0x1082,0x123,0x60050,0xe,0x1072,0x1071,0x1071,0x1071,0x50088,0xe,0x1073,0x105d, + 0x1072,0x50051,0x6,0x1087,0x1073,0x0,0x50085,0x6,0x1088,0x266,0x1087,0x50051, + 0x6,0x108a,0x1073,0x1,0x50085,0x6,0x108b,0x26a,0x108a,0x50081,0x6,0x108c, + 0x1088,0x108b,0x50051,0x6,0x108e,0x1073,0x2,0x50085,0x6,0x108f,0x266,0x108e, + 0x50081,0x6,0x1090,0x108c,0x108f,0x50083,0x6,0x17da,0x1087,0x108e,0x50085,0x6, + 0x1097,0x26a,0x17da,0x50085,0x6,0x109a,0x27a,0x1087,0x50081,0x6,0x109e,0x109a, + 0x108b,0x50083,0x6,0x10a2,0x109e,0x108f,0x60050,0xe,0x10a3,0x1090,0x1097,0x10a2, + 0x50088,0x6,0xfcf,0x17e0,0xfe4,0x8000c,0x6,0x10a8,0x1,0x2b,0xfcf,0x122, + 0x123,0x60050,0xe,0x10ae,0x10a8,0x10a8,0x10a8,0x8000c,0xe,0x10af,0x1,0x2e, + 0x10a3,0x1043,0x10ae,0x50051,0x6,0x10b4,0x10af,0x0,0x50051,0x6,0x10b6,0x10af, + 0x1,0x50081,0x6,0x10b7,0x10b4,0x10b6,0x50051,0x6,0x10b9,0x10af,0x2,0x50083, + 0x6,0x10ba,0x10b7,0x10b9,0x50081,0x6,0x10bf,0x10b4,0x10b9,0x50083,0x6,0x10c4, + 0x10b4,0x10b6,0x50083,0x6,0x10c7,0x10c4,0x10b9,0x60050,0xe,0x10c8,0x10ba,0x10bf, + 0x10c7,0x7000c,0x6,0x10e3,0x1,0x28,0x10bf,0x10c7,0x7000c,0x6,0x10e8,0x1, + 0x28,0x10ba,0x10e3,0x50083,0x6,0x10db,0x123,0x10e8,0x7000c,0x6,0x10ed,0x1, + 0x28,0x2a0,0x10db,0x60050,0xe,0x10dd,0x10ed,0x10ed,0x10ed,0x50088,0xe,0x10de, + 0x10c8,0x10dd,0x4003d,0x18c,0x10f1,0x1d4,0x7005f,0x3e,0x10f2,0x10f1,0x1d6,0x2, + 0x15c,0x50051,0x6,0x10f3,0x10f2,0x0,0x500b4,0x97,0x10f5,0x10f3,0x122,0x600a9, + 0x6,0x17e2,0x10f5,0x123,0x10f3,0x60050,0xe,0x7fc,0x17e2,0x17e2,0x17e2,0x50088, + 0xe,0x7fd,0x10de,0x7fc,0x7000c,0xe,0x10fd,0x1,0x28,0x7fd,0x352,0x50051, + 0x6,0x807,0x10fd,0x0,0x50051,0x6,0x808,0x10fd,0x1,0x50051,0x6,0x809, + 0x10fd,0x2,0x70050,0x3e,0x80a,0x807,0x808,0x809,0xb03,0x4003d,0x1a1,0x10ff, + 0x1a3,0x40063,0x10ff,0x7ac,0x80a,0x4003d,0x1bf,0x1103,0x1c1,0x40063,0x1103,0x7ac, + 0x58f,0x100fd,0x10038, +}; +static const char *fu1_accumulate_pass_1_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu1_accumulate_pass_1_cb_bind[] = {12}; +static const uint32_t fu1_accumulate_pass_1_cb_count[] = {1}; +static const uint32_t fu1_accumulate_pass_1_cb_space[] = {0}; +static const char *fu1_accumulate_pass_1_srv_tex_names[] = {"r_input_exposure", "r_dilated_reactive_masks", "r_dilated_motion_vectors", "r_internal_upscaled_color", "r_farthest_depth_mip1", "r_luma_instability", "r_input_color_jittered"}; +static const uint32_t fu1_accumulate_pass_1_srv_tex_bind[] = {0, 1, 2, 3, 5, 7, 8}; +static const uint32_t fu1_accumulate_pass_1_srv_tex_count[] = {1, 1, 1, 1, 1, 1, 1}; +static const uint32_t fu1_accumulate_pass_1_srv_tex_space[] = {0, 0, 0, 0, 0, 0, 0}; +static const char *fu1_accumulate_pass_1_uav_tex_names[] = {"rw_internal_upscaled_color", "rw_new_locks"}; +static const uint32_t fu1_accumulate_pass_1_uav_tex_bind[] = {9, 11}; +static const uint32_t fu1_accumulate_pass_1_uav_tex_count[] = {1, 1}; +static const uint32_t fu1_accumulate_pass_1_uav_tex_space[] = {0, 0}; +static const char *fu1_accumulate_pass_1_sampler_names[] = {"s_LinearClamp"}; +static const uint32_t fu1_accumulate_pass_1_sampler_bind[] = {1001}; +static const uint32_t fu1_accumulate_pass_1_sampler_count[] = {1}; +static const uint32_t fu1_accumulate_pass_1_sampler_space[] = {0}; + +static const uint32_t fu1_rcas_pass_0_spv[5063] = { + 0x7230203,0x10500,0x8000b,0x125f,0x0,0x20011,0x1,0x20011,0x16,0x20011,0x38,0x6000b, + 0x1,0x4c534c47,0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0xb000f,0x5,0x4,0x6e69616d, + 0x0,0xd6,0xde,0xe6,0xef,0x329,0x32a,0x60010,0x4,0x11,0x40,0x1, + 0x1,0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572, + 0x74636e75,0x736e6f69,0x0,0x80004,0x455f4c47,0x735f5458,0x65646168,0x36315f72,0x5f746962,0x726f7473,0x656761,0xb0004, + 0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004,0x455f4c47, + 0x735f5458,0x65646168,0x6d695f72,0x5f656761,0x64616f6c,0x726f665f,0x7474616d,0x6465,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45, + 0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65, + 0x74636572,0x657669,0x40005,0x4,0x6e69616d,0x0,0x50005,0xd4,0x43526263,0x745f5341,0x0,0x60006, + 0xd4,0x0,0x73616372,0x666e6f43,0x6769,0x40005,0xd6,0x43526263,0x5341,0x60005,0xde,0x63725f72, + 0x695f7361,0x7475706e,0x0,0x70005,0xe6,0x755f7772,0x61637370,0x5f64656c,0x7074756f,0x7475,0x70005,0xef, + 0x6e695f72,0x5f747570,0x6f707865,0x65727573,0x0,0x80005,0x329,0x4c5f6c67,0x6c61636f,0x6f766e49,0x69746163,0x44496e6f, + 0x0,0x60005,0x32a,0x575f6c67,0x476b726f,0x70756f72,0x4449,0x30047,0xd4,0x2,0x50048,0xd4, + 0x0,0x23,0x0,0x40047,0xd6,0x21,0x4,0x40047,0xd6,0x22,0x0,0x40047, + 0xde,0x21,0x1,0x40047,0xde,0x22,0x0,0x30047,0xe6,0x19,0x40047,0xe6, + 0x21,0x2,0x40047,0xe6,0x22,0x0,0x40047,0xef,0x21,0x0,0x40047,0xef, + 0x22,0x0,0x40047,0x329,0xb,0x1b,0x40047,0x32a,0xb,0x1a,0x40047,0x347, + 0xb,0x19,0x20013,0x2,0x30021,0x3,0x2,0x40015,0x6,0x20,0x0,0x30016, + 0x8,0x20,0x40017,0x37,0x6,0x2,0x40017,0x3c,0x6,0x4,0x40015,0x40, + 0x20,0x1,0x40017,0x41,0x40,0x2,0x40017,0x43,0x8,0x4,0x40017,0x48, + 0x8,0x3,0x40015,0x52,0x10,0x0,0x40017,0x53,0x52,0x2,0x40017,0x71, + 0x6,0x3,0x4002b,0x40,0x8b,0x0,0x4002b,0x8,0x9f,0x3f800000,0x4002b,0x8, + 0xa5,0x0,0x4002b,0x6,0xaf,0x7ef19fff,0x4002b,0x8,0xbb,0x40000000,0x4002b,0x6, + 0xc0,0x1,0x3001e,0xd4,0x3c,0x40020,0xd5,0x2,0xd4,0x4003b,0xd5,0xd6, + 0x2,0x40020,0xd7,0x2,0x3c,0x90019,0xdc,0x8,0x1,0x0,0x0,0x0, + 0x1,0x0,0x40020,0xdd,0x0,0xdc,0x4003b,0xdd,0xde,0x0,0x90019,0xe4, + 0x8,0x1,0x0,0x0,0x0,0x2,0x0,0x40020,0xe5,0x0,0xe4,0x4003b, + 0xe5,0xe6,0x0,0x4003b,0xdd,0xef,0x0,0x5002c,0x41,0xf1,0x8b,0x8b, + 0x20014,0xf6,0x40015,0xfe,0x10,0x1,0x40017,0xff,0xfe,0x2,0x4002b,0x40, + 0x11e,0xffffffff,0x5002c,0x41,0x11f,0x8b,0x11e,0x5002c,0x41,0x126,0x11e,0x8b, + 0x4002b,0x40,0x132,0x1,0x5002c,0x41,0x133,0x132,0x8b,0x5002c,0x41,0x13a, + 0x8b,0x132,0x4002b,0x8,0x1a0,0x3f000000,0x4002b,0x8,0x1c8,0x3e800000,0x4002b,0x8, + 0x1f8,0xbf000000,0x4002b,0x8,0x241,0xc0800000,0x4002b,0x8,0x245,0x40800000,0x4002b,0x8, + 0x290,0xbe400000,0x4002b,0x6,0x304,0x4,0x4002b,0x6,0x30f,0x8,0x40020,0x328, + 0x1,0x71,0x4003b,0x328,0x329,0x1,0x4003b,0x328,0x32a,0x1,0x4002b,0x40, + 0x344,0x3,0x4002b,0x6,0x346,0x40,0x6002c,0x71,0x347,0x346,0xc0,0xc0, + 0x50036,0x2,0x4,0x0,0x3,0x200f8,0x5,0x4003d,0x71,0x32d,0x329,0x4003d, + 0x71,0x32f,0x32a,0x50051,0x6,0x350,0x32d,0x0,0x600cb,0x6,0x38b,0x350, + 0x132,0x344,0x600cb,0x6,0x393,0x350,0x344,0x344,0x700c9,0x6,0x39a,0x393, + 0x350,0x8b,0x132,0x50050,0x37,0x383,0x38b,0x39a,0x50051,0x6,0x353,0x32f, + 0x0,0x500c4,0x6,0x354,0x353,0x304,0x50051,0x6,0x356,0x32f,0x1,0x500c4, + 0x6,0x357,0x356,0x304,0x50050,0x37,0x358,0x354,0x357,0x50080,0x37,0x359, + 0x383,0x358,0x40071,0x53,0x35b,0x359,0x40071,0x37,0x3a5,0x35b,0x50041,0xd7, + 0x3b7,0xd6,0x8b,0x4003d,0x3c,0x3b8,0x3b7,0x4007c,0x41,0x42f,0x3a5,0x50080, + 0x41,0x431,0x42f,0x11f,0x4003d,0xdc,0x588,0xde,0x7005f,0x43,0x58a,0x588, + 0x431,0x2,0x8b,0x4003d,0xdc,0x58e,0xef,0x7005f,0x43,0x58f,0x58e,0xf1, + 0x2,0x8b,0x50051,0x8,0x590,0x58f,0x0,0x500b4,0xf6,0x592,0x590,0xa5, + 0x600a9,0x8,0x114b,0x592,0x9f,0x590,0x8004f,0x48,0x57d,0x58a,0x58a,0x0, + 0x1,0x2,0x5008e,0x48,0x57e,0x57d,0x114b,0x50051,0x8,0x580,0x57e,0x0, + 0x50051,0x8,0x582,0x57e,0x1,0x50051,0x8,0x584,0x57e,0x2,0x50080,0x41, + 0x435,0x42f,0x126,0x4003d,0xdc,0x5a9,0xde,0x7005f,0x43,0x5ab,0x5a9,0x435, + 0x2,0x8b,0x4003d,0xdc,0x5af,0xef,0x7005f,0x43,0x5b0,0x5af,0xf1,0x2, + 0x8b,0x50051,0x8,0x5b1,0x5b0,0x0,0x500b4,0xf6,0x5b3,0x5b1,0xa5,0x600a9, + 0x8,0x114c,0x5b3,0x9f,0x5b1,0x8004f,0x48,0x59e,0x5ab,0x5ab,0x0,0x1, + 0x2,0x5008e,0x48,0x59f,0x59e,0x114c,0x50051,0x8,0x5a1,0x59f,0x0,0x50051, + 0x8,0x5a3,0x59f,0x1,0x50051,0x8,0x5a5,0x59f,0x2,0x4003d,0xdc,0x5ca, + 0xde,0x7005f,0x43,0x5cc,0x5ca,0x42f,0x2,0x8b,0x4003d,0xdc,0x5d0,0xef, + 0x7005f,0x43,0x5d1,0x5d0,0xf1,0x2,0x8b,0x50051,0x8,0x5d2,0x5d1,0x0, + 0x500b4,0xf6,0x5d4,0x5d2,0xa5,0x600a9,0x8,0x114d,0x5d4,0x9f,0x5d2,0x8004f, + 0x48,0x5bf,0x5cc,0x5cc,0x0,0x1,0x2,0x5008e,0x48,0x5c0,0x5bf,0x114d, + 0x50051,0x8,0x5c2,0x5c0,0x0,0x50051,0x8,0x5c4,0x5c0,0x1,0x50051,0x8, + 0x5c6,0x5c0,0x2,0x50080,0x41,0x43c,0x42f,0x133,0x4003d,0xdc,0x5eb,0xde, + 0x7005f,0x43,0x5ed,0x5eb,0x43c,0x2,0x8b,0x4003d,0xdc,0x5f1,0xef,0x7005f, + 0x43,0x5f2,0x5f1,0xf1,0x2,0x8b,0x50051,0x8,0x5f3,0x5f2,0x0,0x500b4, + 0xf6,0x5f5,0x5f3,0xa5,0x600a9,0x8,0x114e,0x5f5,0x9f,0x5f3,0x8004f,0x48, + 0x5e0,0x5ed,0x5ed,0x0,0x1,0x2,0x5008e,0x48,0x5e1,0x5e0,0x114e,0x50051, + 0x8,0x5e3,0x5e1,0x0,0x50051,0x8,0x5e5,0x5e1,0x1,0x50051,0x8,0x5e7, + 0x5e1,0x2,0x50080,0x41,0x440,0x42f,0x13a,0x4003d,0xdc,0x60c,0xde,0x7005f, + 0x43,0x60e,0x60c,0x440,0x2,0x8b,0x4003d,0xdc,0x612,0xef,0x7005f,0x43, + 0x613,0x612,0xf1,0x2,0x8b,0x50051,0x8,0x614,0x613,0x0,0x500b4,0xf6, + 0x616,0x614,0xa5,0x600a9,0x8,0x114f,0x616,0x9f,0x614,0x8004f,0x48,0x601, + 0x60e,0x60e,0x0,0x1,0x2,0x5008e,0x48,0x602,0x601,0x114f,0x50051,0x8, + 0x604,0x602,0x0,0x50051,0x8,0x606,0x602,0x1,0x50051,0x8,0x608,0x602, + 0x2,0x50085,0x8,0x485,0x584,0x1a0,0x50085,0x8,0x487,0x580,0x1a0,0x50081, + 0x8,0x489,0x487,0x582,0x50081,0x8,0x48a,0x485,0x489,0x50085,0x8,0x48c, + 0x5a5,0x1a0,0x50085,0x8,0x48e,0x5a1,0x1a0,0x50081,0x8,0x490,0x48e,0x5a3, + 0x50081,0x8,0x491,0x48c,0x490,0x50085,0x8,0x493,0x5c6,0x1a0,0x50085,0x8, + 0x495,0x5c2,0x1a0,0x50081,0x8,0x497,0x495,0x5c4,0x50081,0x8,0x498,0x493, + 0x497,0x50085,0x8,0x49a,0x5e7,0x1a0,0x50085,0x8,0x49c,0x5e3,0x1a0,0x50081, + 0x8,0x49e,0x49c,0x5e5,0x50081,0x8,0x49f,0x49a,0x49e,0x50085,0x8,0x4a1, + 0x608,0x1a0,0x50085,0x8,0x4a3,0x604,0x1a0,0x50081,0x8,0x4a5,0x4a3,0x606, + 0x50081,0x8,0x4a6,0x4a1,0x4a5,0x50081,0x8,0x111b,0x48a,0x491,0x50081,0x8, + 0x111c,0x111b,0x49f,0x50081,0x8,0x111d,0x111c,0x4a6,0x50085,0x8,0x4b1,0x1c8, + 0x111d,0x50083,0x8,0x4b3,0x4b1,0x498,0x6000c,0x8,0x4b5,0x1,0x4,0x4b3, + 0x7000c,0x8,0x624,0x1,0x28,0x491,0x498,0x7000c,0x8,0x625,0x1,0x28, + 0x48a,0x624,0x7000c,0x8,0x62b,0x1,0x28,0x49f,0x4a6,0x7000c,0x8,0x62c, + 0x1,0x28,0x625,0x62b,0x7000c,0x8,0x632,0x1,0x25,0x491,0x498,0x7000c, + 0x8,0x633,0x1,0x25,0x48a,0x632,0x7000c,0x8,0x639,0x1,0x25,0x49f, + 0x4a6,0x7000c,0x8,0x63a,0x1,0x25,0x633,0x639,0x50083,0x8,0x4c4,0x62c, + 0x63a,0x4007c,0x6,0x64e,0x4c4,0x50082,0x6,0x642,0xaf,0x64e,0x4007c,0x8, + 0x652,0x642,0x4007f,0x8,0x646,0x652,0x50085,0x8,0x648,0x646,0x4c4,0x50081, + 0x8,0x649,0x648,0xbb,0x50085,0x8,0x64a,0x652,0x649,0x50085,0x8,0x4c6, + 0x4b5,0x64a,0x8000c,0x8,0x656,0x1,0x2b,0x4c6,0xa5,0x9f,0x50085,0x8, + 0x4c9,0x1f8,0x656,0x50081,0x8,0x4ca,0x4c9,0x9f,0x7000c,0x8,0x65c,0x1, + 0x25,0x5a1,0x5e3,0x7000c,0x8,0x65d,0x1,0x25,0x580,0x65c,0x7000c,0x8, + 0x662,0x1,0x25,0x65d,0x604,0x7000c,0x8,0x668,0x1,0x25,0x5a3,0x5e5, + 0x7000c,0x8,0x669,0x1,0x25,0x582,0x668,0x7000c,0x8,0x66e,0x1,0x25, + 0x669,0x606,0x7000c,0x8,0x674,0x1,0x25,0x5a5,0x5e7,0x7000c,0x8,0x675, + 0x1,0x25,0x584,0x674,0x7000c,0x8,0x67a,0x1,0x25,0x675,0x608,0x7000c, + 0x8,0x680,0x1,0x28,0x5a1,0x5e3,0x7000c,0x8,0x681,0x1,0x28,0x580, + 0x680,0x7000c,0x8,0x4e2,0x1,0x28,0x681,0x604,0x7000c,0x8,0x687,0x1, + 0x28,0x5a3,0x5e5,0x7000c,0x8,0x688,0x1,0x28,0x582,0x687,0x7000c,0x8, + 0x4e8,0x1,0x28,0x688,0x606,0x7000c,0x8,0x68e,0x1,0x28,0x5a5,0x5e7, + 0x7000c,0x8,0x68f,0x1,0x28,0x584,0x68e,0x7000c,0x8,0x4ee,0x1,0x28, + 0x68f,0x608,0x50088,0x8,0x693,0x1c8,0x4e2,0x50085,0x8,0x4f3,0x662,0x693, + 0x50088,0x8,0x697,0x1c8,0x4e8,0x50085,0x8,0x4f8,0x66e,0x697,0x50088,0x8, + 0x69b,0x1c8,0x4ee,0x50085,0x8,0x4fd,0x67a,0x69b,0x50083,0x8,0x501,0x9f, + 0x4e2,0x50085,0x8,0x503,0x245,0x662,0x50081,0x8,0x506,0x503,0x241,0x50088, + 0x8,0x69f,0x9f,0x506,0x50085,0x8,0x508,0x501,0x69f,0x50083,0x8,0x50c, + 0x9f,0x4e8,0x50085,0x8,0x50e,0x245,0x66e,0x50081,0x8,0x511,0x50e,0x241, + 0x50088,0x8,0x6a3,0x9f,0x511,0x50085,0x8,0x513,0x50c,0x6a3,0x50083,0x8, + 0x517,0x9f,0x4ee,0x50085,0x8,0x519,0x245,0x67a,0x50081,0x8,0x51c,0x519, + 0x241,0x50088,0x8,0x6a7,0x9f,0x51c,0x50085,0x8,0x51e,0x517,0x6a7,0x4007f, + 0x8,0x520,0x4f3,0x7000c,0x8,0x522,0x1,0x28,0x520,0x508,0x4007f,0x8, + 0x524,0x4f8,0x7000c,0x8,0x526,0x1,0x28,0x524,0x513,0x4007f,0x8,0x528, + 0x4fd,0x7000c,0x8,0x52a,0x1,0x28,0x528,0x51e,0x7000c,0x8,0x6ad,0x1, + 0x28,0x526,0x52a,0x7000c,0x8,0x6ae,0x1,0x28,0x522,0x6ad,0x7000c,0x8, + 0x6b3,0x1,0x25,0x6ae,0xa5,0x7000c,0x8,0x530,0x1,0x28,0x290,0x6b3, + 0x50051,0x6,0x532,0x3b8,0x0,0x4007c,0x8,0x6b7,0x532,0x50085,0x8,0x534, + 0x530,0x6b7,0x50085,0x8,0x537,0x534,0x4ca,0x50085,0x8,0x539,0x245,0x537, + 0x50081,0x8,0x53a,0x539,0x9f,0x4007c,0x6,0x6cb,0x53a,0x50082,0x6,0x6bf, + 0xaf,0x6cb,0x4007c,0x8,0x6cf,0x6bf,0x4007f,0x8,0x6c3,0x6cf,0x50085,0x8, + 0x6c5,0x6c3,0x53a,0x50081,0x8,0x6c6,0x6c5,0xbb,0x50085,0x8,0x6c7,0x6cf, + 0x6c6,0x50081,0x8,0x111e,0x580,0x5a1,0x50081,0x8,0x111f,0x111e,0x604,0x50081, + 0x8,0x1120,0x111f,0x5e3,0x50085,0x8,0x54a,0x537,0x1120,0x50081,0x8,0x54c, + 0x54a,0x5c2,0x50085,0x8,0x54e,0x54c,0x6c7,0x50081,0x8,0x1121,0x582,0x5a3, + 0x50081,0x8,0x1122,0x1121,0x606,0x50081,0x8,0x1123,0x1122,0x5e5,0x50085,0x8, + 0x55d,0x537,0x1123,0x50081,0x8,0x55f,0x55d,0x5c4,0x50085,0x8,0x561,0x55f, + 0x6c7,0x50081,0x8,0x1124,0x584,0x5a5,0x50081,0x8,0x1125,0x1124,0x608,0x50081, + 0x8,0x1126,0x1125,0x5e7,0x50085,0x8,0x570,0x537,0x1126,0x50081,0x8,0x572, + 0x570,0x5c6,0x50085,0x8,0x574,0x572,0x6c7,0x60050,0x48,0x1259,0x54e,0x561, + 0x574,0x4003d,0xdc,0x6d3,0xef,0x7005f,0x43,0x6d4,0x6d3,0xf1,0x2,0x8b, + 0x50051,0x8,0x6d5,0x6d4,0x0,0x500b4,0xf6,0x6d7,0x6d5,0xa5,0x600a9,0x8, + 0x1150,0x6d7,0x9f,0x6d5,0x60050,0x48,0x3b0,0x1150,0x1150,0x1150,0x50088,0x48, + 0x3b1,0x1259,0x3b0,0x4007c,0xff,0x6df,0x35b,0x40072,0x41,0x6e0,0x6df,0x4003d, + 0xe4,0x6e4,0xe6,0x50051,0x8,0x6e7,0x3b1,0x0,0x50051,0x8,0x6e8,0x3b1, + 0x1,0x50051,0x8,0x6e9,0x3b1,0x2,0x70050,0x43,0x6ea,0x6e7,0x6e8,0x6e9, + 0x9f,0x40063,0x6e4,0x6e0,0x6ea,0x50051,0x6,0x35e,0x359,0x0,0x50080,0x6, + 0x35f,0x35e,0x30f,0x60052,0x37,0x11a2,0x35f,0x359,0x0,0x40071,0x53,0x362, + 0x11a2,0x40071,0x37,0x6f5,0x362,0x4007c,0x41,0x77f,0x6f5,0x50080,0x41,0x781, + 0x77f,0x11f,0x4003d,0xdc,0x8d8,0xde,0x7005f,0x43,0x8da,0x8d8,0x781,0x2, + 0x8b,0x4003d,0xdc,0x8de,0xef,0x7005f,0x43,0x8df,0x8de,0xf1,0x2,0x8b, + 0x50051,0x8,0x8e0,0x8df,0x0,0x500b4,0xf6,0x8e2,0x8e0,0xa5,0x600a9,0x8, + 0x1151,0x8e2,0x9f,0x8e0,0x8004f,0x48,0x8cd,0x8da,0x8da,0x0,0x1,0x2, + 0x5008e,0x48,0x8ce,0x8cd,0x1151,0x50051,0x8,0x8d0,0x8ce,0x0,0x50051,0x8, + 0x8d2,0x8ce,0x1,0x50051,0x8,0x8d4,0x8ce,0x2,0x50080,0x41,0x785,0x77f, + 0x126,0x4003d,0xdc,0x8f9,0xde,0x7005f,0x43,0x8fb,0x8f9,0x785,0x2,0x8b, + 0x4003d,0xdc,0x8ff,0xef,0x7005f,0x43,0x900,0x8ff,0xf1,0x2,0x8b,0x50051, + 0x8,0x901,0x900,0x0,0x500b4,0xf6,0x903,0x901,0xa5,0x600a9,0x8,0x1152, + 0x903,0x9f,0x901,0x8004f,0x48,0x8ee,0x8fb,0x8fb,0x0,0x1,0x2,0x5008e, + 0x48,0x8ef,0x8ee,0x1152,0x50051,0x8,0x8f1,0x8ef,0x0,0x50051,0x8,0x8f3, + 0x8ef,0x1,0x50051,0x8,0x8f5,0x8ef,0x2,0x4003d,0xdc,0x91a,0xde,0x7005f, + 0x43,0x91c,0x91a,0x77f,0x2,0x8b,0x4003d,0xdc,0x920,0xef,0x7005f,0x43, + 0x921,0x920,0xf1,0x2,0x8b,0x50051,0x8,0x922,0x921,0x0,0x500b4,0xf6, + 0x924,0x922,0xa5,0x600a9,0x8,0x1153,0x924,0x9f,0x922,0x8004f,0x48,0x90f, + 0x91c,0x91c,0x0,0x1,0x2,0x5008e,0x48,0x910,0x90f,0x1153,0x50051,0x8, + 0x912,0x910,0x0,0x50051,0x8,0x914,0x910,0x1,0x50051,0x8,0x916,0x910, + 0x2,0x50080,0x41,0x78c,0x77f,0x133,0x4003d,0xdc,0x93b,0xde,0x7005f,0x43, + 0x93d,0x93b,0x78c,0x2,0x8b,0x4003d,0xdc,0x941,0xef,0x7005f,0x43,0x942, + 0x941,0xf1,0x2,0x8b,0x50051,0x8,0x943,0x942,0x0,0x500b4,0xf6,0x945, + 0x943,0xa5,0x600a9,0x8,0x1154,0x945,0x9f,0x943,0x8004f,0x48,0x930,0x93d, + 0x93d,0x0,0x1,0x2,0x5008e,0x48,0x931,0x930,0x1154,0x50051,0x8,0x933, + 0x931,0x0,0x50051,0x8,0x935,0x931,0x1,0x50051,0x8,0x937,0x931,0x2, + 0x50080,0x41,0x790,0x77f,0x13a,0x4003d,0xdc,0x95c,0xde,0x7005f,0x43,0x95e, + 0x95c,0x790,0x2,0x8b,0x4003d,0xdc,0x962,0xef,0x7005f,0x43,0x963,0x962, + 0xf1,0x2,0x8b,0x50051,0x8,0x964,0x963,0x0,0x500b4,0xf6,0x966,0x964, + 0xa5,0x600a9,0x8,0x1155,0x966,0x9f,0x964,0x8004f,0x48,0x951,0x95e,0x95e, + 0x0,0x1,0x2,0x5008e,0x48,0x952,0x951,0x1155,0x50051,0x8,0x954,0x952, + 0x0,0x50051,0x8,0x956,0x952,0x1,0x50051,0x8,0x958,0x952,0x2,0x50085, + 0x8,0x7d5,0x8d4,0x1a0,0x50085,0x8,0x7d7,0x8d0,0x1a0,0x50081,0x8,0x7d9, + 0x7d7,0x8d2,0x50081,0x8,0x7da,0x7d5,0x7d9,0x50085,0x8,0x7dc,0x8f5,0x1a0, + 0x50085,0x8,0x7de,0x8f1,0x1a0,0x50081,0x8,0x7e0,0x7de,0x8f3,0x50081,0x8, + 0x7e1,0x7dc,0x7e0,0x50085,0x8,0x7e3,0x916,0x1a0,0x50085,0x8,0x7e5,0x912, + 0x1a0,0x50081,0x8,0x7e7,0x7e5,0x914,0x50081,0x8,0x7e8,0x7e3,0x7e7,0x50085, + 0x8,0x7ea,0x937,0x1a0,0x50085,0x8,0x7ec,0x933,0x1a0,0x50081,0x8,0x7ee, + 0x7ec,0x935,0x50081,0x8,0x7ef,0x7ea,0x7ee,0x50085,0x8,0x7f1,0x958,0x1a0, + 0x50085,0x8,0x7f3,0x954,0x1a0,0x50081,0x8,0x7f5,0x7f3,0x956,0x50081,0x8, + 0x7f6,0x7f1,0x7f5,0x50081,0x8,0x1127,0x7da,0x7e1,0x50081,0x8,0x1128,0x1127, + 0x7ef,0x50081,0x8,0x1129,0x1128,0x7f6,0x50085,0x8,0x801,0x1c8,0x1129,0x50083, + 0x8,0x803,0x801,0x7e8,0x6000c,0x8,0x805,0x1,0x4,0x803,0x7000c,0x8, + 0x974,0x1,0x28,0x7e1,0x7e8,0x7000c,0x8,0x975,0x1,0x28,0x7da,0x974, + 0x7000c,0x8,0x97b,0x1,0x28,0x7ef,0x7f6,0x7000c,0x8,0x97c,0x1,0x28, + 0x975,0x97b,0x7000c,0x8,0x982,0x1,0x25,0x7e1,0x7e8,0x7000c,0x8,0x983, + 0x1,0x25,0x7da,0x982,0x7000c,0x8,0x989,0x1,0x25,0x7ef,0x7f6,0x7000c, + 0x8,0x98a,0x1,0x25,0x983,0x989,0x50083,0x8,0x814,0x97c,0x98a,0x4007c, + 0x6,0x99e,0x814,0x50082,0x6,0x992,0xaf,0x99e,0x4007c,0x8,0x9a2,0x992, + 0x4007f,0x8,0x996,0x9a2,0x50085,0x8,0x998,0x996,0x814,0x50081,0x8,0x999, + 0x998,0xbb,0x50085,0x8,0x99a,0x9a2,0x999,0x50085,0x8,0x816,0x805,0x99a, + 0x8000c,0x8,0x9a6,0x1,0x2b,0x816,0xa5,0x9f,0x50085,0x8,0x819,0x1f8, + 0x9a6,0x50081,0x8,0x81a,0x819,0x9f,0x7000c,0x8,0x9ac,0x1,0x25,0x8f1, + 0x933,0x7000c,0x8,0x9ad,0x1,0x25,0x8d0,0x9ac,0x7000c,0x8,0x9b2,0x1, + 0x25,0x9ad,0x954,0x7000c,0x8,0x9b8,0x1,0x25,0x8f3,0x935,0x7000c,0x8, + 0x9b9,0x1,0x25,0x8d2,0x9b8,0x7000c,0x8,0x9be,0x1,0x25,0x9b9,0x956, + 0x7000c,0x8,0x9c4,0x1,0x25,0x8f5,0x937,0x7000c,0x8,0x9c5,0x1,0x25, + 0x8d4,0x9c4,0x7000c,0x8,0x9ca,0x1,0x25,0x9c5,0x958,0x7000c,0x8,0x9d0, + 0x1,0x28,0x8f1,0x933,0x7000c,0x8,0x9d1,0x1,0x28,0x8d0,0x9d0,0x7000c, + 0x8,0x832,0x1,0x28,0x9d1,0x954,0x7000c,0x8,0x9d7,0x1,0x28,0x8f3, + 0x935,0x7000c,0x8,0x9d8,0x1,0x28,0x8d2,0x9d7,0x7000c,0x8,0x838,0x1, + 0x28,0x9d8,0x956,0x7000c,0x8,0x9de,0x1,0x28,0x8f5,0x937,0x7000c,0x8, + 0x9df,0x1,0x28,0x8d4,0x9de,0x7000c,0x8,0x83e,0x1,0x28,0x9df,0x958, + 0x50088,0x8,0x9e3,0x1c8,0x832,0x50085,0x8,0x843,0x9b2,0x9e3,0x50088,0x8, + 0x9e7,0x1c8,0x838,0x50085,0x8,0x848,0x9be,0x9e7,0x50088,0x8,0x9eb,0x1c8, + 0x83e,0x50085,0x8,0x84d,0x9ca,0x9eb,0x50083,0x8,0x851,0x9f,0x832,0x50085, + 0x8,0x853,0x245,0x9b2,0x50081,0x8,0x856,0x853,0x241,0x50088,0x8,0x9ef, + 0x9f,0x856,0x50085,0x8,0x858,0x851,0x9ef,0x50083,0x8,0x85c,0x9f,0x838, + 0x50085,0x8,0x85e,0x245,0x9be,0x50081,0x8,0x861,0x85e,0x241,0x50088,0x8, + 0x9f3,0x9f,0x861,0x50085,0x8,0x863,0x85c,0x9f3,0x50083,0x8,0x867,0x9f, + 0x83e,0x50085,0x8,0x869,0x245,0x9ca,0x50081,0x8,0x86c,0x869,0x241,0x50088, + 0x8,0x9f7,0x9f,0x86c,0x50085,0x8,0x86e,0x867,0x9f7,0x4007f,0x8,0x870, + 0x843,0x7000c,0x8,0x872,0x1,0x28,0x870,0x858,0x4007f,0x8,0x874,0x848, + 0x7000c,0x8,0x876,0x1,0x28,0x874,0x863,0x4007f,0x8,0x878,0x84d,0x7000c, + 0x8,0x87a,0x1,0x28,0x878,0x86e,0x7000c,0x8,0x9fd,0x1,0x28,0x876, + 0x87a,0x7000c,0x8,0x9fe,0x1,0x28,0x872,0x9fd,0x7000c,0x8,0xa03,0x1, + 0x25,0x9fe,0xa5,0x7000c,0x8,0x880,0x1,0x28,0x290,0xa03,0x50085,0x8, + 0x884,0x880,0x6b7,0x50085,0x8,0x887,0x884,0x81a,0x50085,0x8,0x889,0x245, + 0x887,0x50081,0x8,0x88a,0x889,0x9f,0x4007c,0x6,0xa1b,0x88a,0x50082,0x6, + 0xa0f,0xaf,0xa1b,0x4007c,0x8,0xa1f,0xa0f,0x4007f,0x8,0xa13,0xa1f,0x50085, + 0x8,0xa15,0xa13,0x88a,0x50081,0x8,0xa16,0xa15,0xbb,0x50085,0x8,0xa17, + 0xa1f,0xa16,0x50081,0x8,0x112a,0x8d0,0x8f1,0x50081,0x8,0x112b,0x112a,0x954, + 0x50081,0x8,0x112c,0x112b,0x933,0x50085,0x8,0x89a,0x887,0x112c,0x50081,0x8, + 0x89c,0x89a,0x912,0x50085,0x8,0x89e,0x89c,0xa17,0x50081,0x8,0x112d,0x8d2, + 0x8f3,0x50081,0x8,0x112e,0x112d,0x956,0x50081,0x8,0x112f,0x112e,0x935,0x50085, + 0x8,0x8ad,0x887,0x112f,0x50081,0x8,0x8af,0x8ad,0x914,0x50085,0x8,0x8b1, + 0x8af,0xa17,0x50081,0x8,0x1130,0x8d4,0x8f5,0x50081,0x8,0x1131,0x1130,0x958, + 0x50081,0x8,0x1132,0x1131,0x937,0x50085,0x8,0x8c0,0x887,0x1132,0x50081,0x8, + 0x8c2,0x8c0,0x916,0x50085,0x8,0x8c4,0x8c2,0xa17,0x60050,0x48,0x125a,0x89e, + 0x8b1,0x8c4,0x4003d,0xdc,0xa23,0xef,0x7005f,0x43,0xa24,0xa23,0xf1,0x2, + 0x8b,0x50051,0x8,0xa25,0xa24,0x0,0x500b4,0xf6,0xa27,0xa25,0xa5,0x600a9, + 0x8,0x1156,0xa27,0x9f,0xa25,0x60050,0x48,0x700,0x1156,0x1156,0x1156,0x50088, + 0x48,0x701,0x125a,0x700,0x4007c,0xff,0xa2f,0x362,0x40072,0x41,0xa30,0xa2f, + 0x4003d,0xe4,0xa34,0xe6,0x50051,0x8,0xa37,0x701,0x0,0x50051,0x8,0xa38, + 0x701,0x1,0x50051,0x8,0xa39,0x701,0x2,0x70050,0x43,0xa3a,0xa37,0xa38, + 0xa39,0x9f,0x40063,0xa34,0xa30,0xa3a,0x50051,0x6,0x365,0x359,0x1,0x50080, + 0x6,0x366,0x365,0x30f,0x50050,0x37,0x125b,0x35f,0x366,0x40071,0x53,0x369, + 0x125b,0x40071,0x37,0xa45,0x369,0x4007c,0x41,0xacf,0xa45,0x50080,0x41,0xad1, + 0xacf,0x11f,0x4003d,0xdc,0xc28,0xde,0x7005f,0x43,0xc2a,0xc28,0xad1,0x2, + 0x8b,0x4003d,0xdc,0xc2e,0xef,0x7005f,0x43,0xc2f,0xc2e,0xf1,0x2,0x8b, + 0x50051,0x8,0xc30,0xc2f,0x0,0x500b4,0xf6,0xc32,0xc30,0xa5,0x600a9,0x8, + 0x1157,0xc32,0x9f,0xc30,0x8004f,0x48,0xc1d,0xc2a,0xc2a,0x0,0x1,0x2, + 0x5008e,0x48,0xc1e,0xc1d,0x1157,0x50051,0x8,0xc20,0xc1e,0x0,0x50051,0x8, + 0xc22,0xc1e,0x1,0x50051,0x8,0xc24,0xc1e,0x2,0x50080,0x41,0xad5,0xacf, + 0x126,0x4003d,0xdc,0xc49,0xde,0x7005f,0x43,0xc4b,0xc49,0xad5,0x2,0x8b, + 0x4003d,0xdc,0xc4f,0xef,0x7005f,0x43,0xc50,0xc4f,0xf1,0x2,0x8b,0x50051, + 0x8,0xc51,0xc50,0x0,0x500b4,0xf6,0xc53,0xc51,0xa5,0x600a9,0x8,0x1158, + 0xc53,0x9f,0xc51,0x8004f,0x48,0xc3e,0xc4b,0xc4b,0x0,0x1,0x2,0x5008e, + 0x48,0xc3f,0xc3e,0x1158,0x50051,0x8,0xc41,0xc3f,0x0,0x50051,0x8,0xc43, + 0xc3f,0x1,0x50051,0x8,0xc45,0xc3f,0x2,0x4003d,0xdc,0xc6a,0xde,0x7005f, + 0x43,0xc6c,0xc6a,0xacf,0x2,0x8b,0x4003d,0xdc,0xc70,0xef,0x7005f,0x43, + 0xc71,0xc70,0xf1,0x2,0x8b,0x50051,0x8,0xc72,0xc71,0x0,0x500b4,0xf6, + 0xc74,0xc72,0xa5,0x600a9,0x8,0x1159,0xc74,0x9f,0xc72,0x8004f,0x48,0xc5f, + 0xc6c,0xc6c,0x0,0x1,0x2,0x5008e,0x48,0xc60,0xc5f,0x1159,0x50051,0x8, + 0xc62,0xc60,0x0,0x50051,0x8,0xc64,0xc60,0x1,0x50051,0x8,0xc66,0xc60, + 0x2,0x50080,0x41,0xadc,0xacf,0x133,0x4003d,0xdc,0xc8b,0xde,0x7005f,0x43, + 0xc8d,0xc8b,0xadc,0x2,0x8b,0x4003d,0xdc,0xc91,0xef,0x7005f,0x43,0xc92, + 0xc91,0xf1,0x2,0x8b,0x50051,0x8,0xc93,0xc92,0x0,0x500b4,0xf6,0xc95, + 0xc93,0xa5,0x600a9,0x8,0x115a,0xc95,0x9f,0xc93,0x8004f,0x48,0xc80,0xc8d, + 0xc8d,0x0,0x1,0x2,0x5008e,0x48,0xc81,0xc80,0x115a,0x50051,0x8,0xc83, + 0xc81,0x0,0x50051,0x8,0xc85,0xc81,0x1,0x50051,0x8,0xc87,0xc81,0x2, + 0x50080,0x41,0xae0,0xacf,0x13a,0x4003d,0xdc,0xcac,0xde,0x7005f,0x43,0xcae, + 0xcac,0xae0,0x2,0x8b,0x4003d,0xdc,0xcb2,0xef,0x7005f,0x43,0xcb3,0xcb2, + 0xf1,0x2,0x8b,0x50051,0x8,0xcb4,0xcb3,0x0,0x500b4,0xf6,0xcb6,0xcb4, + 0xa5,0x600a9,0x8,0x115b,0xcb6,0x9f,0xcb4,0x8004f,0x48,0xca1,0xcae,0xcae, + 0x0,0x1,0x2,0x5008e,0x48,0xca2,0xca1,0x115b,0x50051,0x8,0xca4,0xca2, + 0x0,0x50051,0x8,0xca6,0xca2,0x1,0x50051,0x8,0xca8,0xca2,0x2,0x50085, + 0x8,0xb25,0xc24,0x1a0,0x50085,0x8,0xb27,0xc20,0x1a0,0x50081,0x8,0xb29, + 0xb27,0xc22,0x50081,0x8,0xb2a,0xb25,0xb29,0x50085,0x8,0xb2c,0xc45,0x1a0, + 0x50085,0x8,0xb2e,0xc41,0x1a0,0x50081,0x8,0xb30,0xb2e,0xc43,0x50081,0x8, + 0xb31,0xb2c,0xb30,0x50085,0x8,0xb33,0xc66,0x1a0,0x50085,0x8,0xb35,0xc62, + 0x1a0,0x50081,0x8,0xb37,0xb35,0xc64,0x50081,0x8,0xb38,0xb33,0xb37,0x50085, + 0x8,0xb3a,0xc87,0x1a0,0x50085,0x8,0xb3c,0xc83,0x1a0,0x50081,0x8,0xb3e, + 0xb3c,0xc85,0x50081,0x8,0xb3f,0xb3a,0xb3e,0x50085,0x8,0xb41,0xca8,0x1a0, + 0x50085,0x8,0xb43,0xca4,0x1a0,0x50081,0x8,0xb45,0xb43,0xca6,0x50081,0x8, + 0xb46,0xb41,0xb45,0x50081,0x8,0x1133,0xb2a,0xb31,0x50081,0x8,0x1134,0x1133, + 0xb3f,0x50081,0x8,0x1135,0x1134,0xb46,0x50085,0x8,0xb51,0x1c8,0x1135,0x50083, + 0x8,0xb53,0xb51,0xb38,0x6000c,0x8,0xb55,0x1,0x4,0xb53,0x7000c,0x8, + 0xcc4,0x1,0x28,0xb31,0xb38,0x7000c,0x8,0xcc5,0x1,0x28,0xb2a,0xcc4, + 0x7000c,0x8,0xccb,0x1,0x28,0xb3f,0xb46,0x7000c,0x8,0xccc,0x1,0x28, + 0xcc5,0xccb,0x7000c,0x8,0xcd2,0x1,0x25,0xb31,0xb38,0x7000c,0x8,0xcd3, + 0x1,0x25,0xb2a,0xcd2,0x7000c,0x8,0xcd9,0x1,0x25,0xb3f,0xb46,0x7000c, + 0x8,0xcda,0x1,0x25,0xcd3,0xcd9,0x50083,0x8,0xb64,0xccc,0xcda,0x4007c, + 0x6,0xcee,0xb64,0x50082,0x6,0xce2,0xaf,0xcee,0x4007c,0x8,0xcf2,0xce2, + 0x4007f,0x8,0xce6,0xcf2,0x50085,0x8,0xce8,0xce6,0xb64,0x50081,0x8,0xce9, + 0xce8,0xbb,0x50085,0x8,0xcea,0xcf2,0xce9,0x50085,0x8,0xb66,0xb55,0xcea, + 0x8000c,0x8,0xcf6,0x1,0x2b,0xb66,0xa5,0x9f,0x50085,0x8,0xb69,0x1f8, + 0xcf6,0x50081,0x8,0xb6a,0xb69,0x9f,0x7000c,0x8,0xcfc,0x1,0x25,0xc41, + 0xc83,0x7000c,0x8,0xcfd,0x1,0x25,0xc20,0xcfc,0x7000c,0x8,0xd02,0x1, + 0x25,0xcfd,0xca4,0x7000c,0x8,0xd08,0x1,0x25,0xc43,0xc85,0x7000c,0x8, + 0xd09,0x1,0x25,0xc22,0xd08,0x7000c,0x8,0xd0e,0x1,0x25,0xd09,0xca6, + 0x7000c,0x8,0xd14,0x1,0x25,0xc45,0xc87,0x7000c,0x8,0xd15,0x1,0x25, + 0xc24,0xd14,0x7000c,0x8,0xd1a,0x1,0x25,0xd15,0xca8,0x7000c,0x8,0xd20, + 0x1,0x28,0xc41,0xc83,0x7000c,0x8,0xd21,0x1,0x28,0xc20,0xd20,0x7000c, + 0x8,0xb82,0x1,0x28,0xd21,0xca4,0x7000c,0x8,0xd27,0x1,0x28,0xc43, + 0xc85,0x7000c,0x8,0xd28,0x1,0x28,0xc22,0xd27,0x7000c,0x8,0xb88,0x1, + 0x28,0xd28,0xca6,0x7000c,0x8,0xd2e,0x1,0x28,0xc45,0xc87,0x7000c,0x8, + 0xd2f,0x1,0x28,0xc24,0xd2e,0x7000c,0x8,0xb8e,0x1,0x28,0xd2f,0xca8, + 0x50088,0x8,0xd33,0x1c8,0xb82,0x50085,0x8,0xb93,0xd02,0xd33,0x50088,0x8, + 0xd37,0x1c8,0xb88,0x50085,0x8,0xb98,0xd0e,0xd37,0x50088,0x8,0xd3b,0x1c8, + 0xb8e,0x50085,0x8,0xb9d,0xd1a,0xd3b,0x50083,0x8,0xba1,0x9f,0xb82,0x50085, + 0x8,0xba3,0x245,0xd02,0x50081,0x8,0xba6,0xba3,0x241,0x50088,0x8,0xd3f, + 0x9f,0xba6,0x50085,0x8,0xba8,0xba1,0xd3f,0x50083,0x8,0xbac,0x9f,0xb88, + 0x50085,0x8,0xbae,0x245,0xd0e,0x50081,0x8,0xbb1,0xbae,0x241,0x50088,0x8, + 0xd43,0x9f,0xbb1,0x50085,0x8,0xbb3,0xbac,0xd43,0x50083,0x8,0xbb7,0x9f, + 0xb8e,0x50085,0x8,0xbb9,0x245,0xd1a,0x50081,0x8,0xbbc,0xbb9,0x241,0x50088, + 0x8,0xd47,0x9f,0xbbc,0x50085,0x8,0xbbe,0xbb7,0xd47,0x4007f,0x8,0xbc0, + 0xb93,0x7000c,0x8,0xbc2,0x1,0x28,0xbc0,0xba8,0x4007f,0x8,0xbc4,0xb98, + 0x7000c,0x8,0xbc6,0x1,0x28,0xbc4,0xbb3,0x4007f,0x8,0xbc8,0xb9d,0x7000c, + 0x8,0xbca,0x1,0x28,0xbc8,0xbbe,0x7000c,0x8,0xd4d,0x1,0x28,0xbc6, + 0xbca,0x7000c,0x8,0xd4e,0x1,0x28,0xbc2,0xd4d,0x7000c,0x8,0xd53,0x1, + 0x25,0xd4e,0xa5,0x7000c,0x8,0xbd0,0x1,0x28,0x290,0xd53,0x50085,0x8, + 0xbd4,0xbd0,0x6b7,0x50085,0x8,0xbd7,0xbd4,0xb6a,0x50085,0x8,0xbd9,0x245, + 0xbd7,0x50081,0x8,0xbda,0xbd9,0x9f,0x4007c,0x6,0xd6b,0xbda,0x50082,0x6, + 0xd5f,0xaf,0xd6b,0x4007c,0x8,0xd6f,0xd5f,0x4007f,0x8,0xd63,0xd6f,0x50085, + 0x8,0xd65,0xd63,0xbda,0x50081,0x8,0xd66,0xd65,0xbb,0x50085,0x8,0xd67, + 0xd6f,0xd66,0x50081,0x8,0x1136,0xc20,0xc41,0x50081,0x8,0x1137,0x1136,0xca4, + 0x50081,0x8,0x1138,0x1137,0xc83,0x50085,0x8,0xbea,0xbd7,0x1138,0x50081,0x8, + 0xbec,0xbea,0xc62,0x50085,0x8,0xbee,0xbec,0xd67,0x50081,0x8,0x1139,0xc22, + 0xc43,0x50081,0x8,0x113a,0x1139,0xca6,0x50081,0x8,0x113b,0x113a,0xc85,0x50085, + 0x8,0xbfd,0xbd7,0x113b,0x50081,0x8,0xbff,0xbfd,0xc64,0x50085,0x8,0xc01, + 0xbff,0xd67,0x50081,0x8,0x113c,0xc24,0xc45,0x50081,0x8,0x113d,0x113c,0xca8, + 0x50081,0x8,0x113e,0x113d,0xc87,0x50085,0x8,0xc10,0xbd7,0x113e,0x50081,0x8, + 0xc12,0xc10,0xc66,0x50085,0x8,0xc14,0xc12,0xd67,0x60050,0x48,0x125c,0xbee, + 0xc01,0xc14,0x4003d,0xdc,0xd73,0xef,0x7005f,0x43,0xd74,0xd73,0xf1,0x2, + 0x8b,0x50051,0x8,0xd75,0xd74,0x0,0x500b4,0xf6,0xd77,0xd75,0xa5,0x600a9, + 0x8,0x115c,0xd77,0x9f,0xd75,0x60050,0x48,0xa50,0x115c,0x115c,0x115c,0x50088, + 0x48,0xa51,0x125c,0xa50,0x4007c,0xff,0xd7f,0x369,0x40072,0x41,0xd80,0xd7f, + 0x4003d,0xe4,0xd84,0xe6,0x50051,0x8,0xd87,0xa51,0x0,0x50051,0x8,0xd88, + 0xa51,0x1,0x50051,0x8,0xd89,0xa51,0x2,0x70050,0x43,0xd8a,0xd87,0xd88, + 0xd89,0x9f,0x40063,0xd84,0xd80,0xd8a,0x60052,0x37,0x121c,0x35e,0x125b,0x0, + 0x40071,0x53,0x370,0x121c,0x40071,0x37,0xd95,0x370,0x4007c,0x41,0xe1f,0xd95, + 0x50080,0x41,0xe21,0xe1f,0x11f,0x4003d,0xdc,0xf78,0xde,0x7005f,0x43,0xf7a, + 0xf78,0xe21,0x2,0x8b,0x4003d,0xdc,0xf7e,0xef,0x7005f,0x43,0xf7f,0xf7e, + 0xf1,0x2,0x8b,0x50051,0x8,0xf80,0xf7f,0x0,0x500b4,0xf6,0xf82,0xf80, + 0xa5,0x600a9,0x8,0x115d,0xf82,0x9f,0xf80,0x8004f,0x48,0xf6d,0xf7a,0xf7a, + 0x0,0x1,0x2,0x5008e,0x48,0xf6e,0xf6d,0x115d,0x50051,0x8,0xf70,0xf6e, + 0x0,0x50051,0x8,0xf72,0xf6e,0x1,0x50051,0x8,0xf74,0xf6e,0x2,0x50080, + 0x41,0xe25,0xe1f,0x126,0x4003d,0xdc,0xf99,0xde,0x7005f,0x43,0xf9b,0xf99, + 0xe25,0x2,0x8b,0x4003d,0xdc,0xf9f,0xef,0x7005f,0x43,0xfa0,0xf9f,0xf1, + 0x2,0x8b,0x50051,0x8,0xfa1,0xfa0,0x0,0x500b4,0xf6,0xfa3,0xfa1,0xa5, + 0x600a9,0x8,0x115e,0xfa3,0x9f,0xfa1,0x8004f,0x48,0xf8e,0xf9b,0xf9b,0x0, + 0x1,0x2,0x5008e,0x48,0xf8f,0xf8e,0x115e,0x50051,0x8,0xf91,0xf8f,0x0, + 0x50051,0x8,0xf93,0xf8f,0x1,0x50051,0x8,0xf95,0xf8f,0x2,0x4003d,0xdc, + 0xfba,0xde,0x7005f,0x43,0xfbc,0xfba,0xe1f,0x2,0x8b,0x4003d,0xdc,0xfc0, + 0xef,0x7005f,0x43,0xfc1,0xfc0,0xf1,0x2,0x8b,0x50051,0x8,0xfc2,0xfc1, + 0x0,0x500b4,0xf6,0xfc4,0xfc2,0xa5,0x600a9,0x8,0x115f,0xfc4,0x9f,0xfc2, + 0x8004f,0x48,0xfaf,0xfbc,0xfbc,0x0,0x1,0x2,0x5008e,0x48,0xfb0,0xfaf, + 0x115f,0x50051,0x8,0xfb2,0xfb0,0x0,0x50051,0x8,0xfb4,0xfb0,0x1,0x50051, + 0x8,0xfb6,0xfb0,0x2,0x50080,0x41,0xe2c,0xe1f,0x133,0x4003d,0xdc,0xfdb, + 0xde,0x7005f,0x43,0xfdd,0xfdb,0xe2c,0x2,0x8b,0x4003d,0xdc,0xfe1,0xef, + 0x7005f,0x43,0xfe2,0xfe1,0xf1,0x2,0x8b,0x50051,0x8,0xfe3,0xfe2,0x0, + 0x500b4,0xf6,0xfe5,0xfe3,0xa5,0x600a9,0x8,0x1160,0xfe5,0x9f,0xfe3,0x8004f, + 0x48,0xfd0,0xfdd,0xfdd,0x0,0x1,0x2,0x5008e,0x48,0xfd1,0xfd0,0x1160, + 0x50051,0x8,0xfd3,0xfd1,0x0,0x50051,0x8,0xfd5,0xfd1,0x1,0x50051,0x8, + 0xfd7,0xfd1,0x2,0x50080,0x41,0xe30,0xe1f,0x13a,0x4003d,0xdc,0xffc,0xde, + 0x7005f,0x43,0xffe,0xffc,0xe30,0x2,0x8b,0x4003d,0xdc,0x1002,0xef,0x7005f, + 0x43,0x1003,0x1002,0xf1,0x2,0x8b,0x50051,0x8,0x1004,0x1003,0x0,0x500b4, + 0xf6,0x1006,0x1004,0xa5,0x600a9,0x8,0x1161,0x1006,0x9f,0x1004,0x8004f,0x48, + 0xff1,0xffe,0xffe,0x0,0x1,0x2,0x5008e,0x48,0xff2,0xff1,0x1161,0x50051, + 0x8,0xff4,0xff2,0x0,0x50051,0x8,0xff6,0xff2,0x1,0x50051,0x8,0xff8, + 0xff2,0x2,0x50085,0x8,0xe75,0xf74,0x1a0,0x50085,0x8,0xe77,0xf70,0x1a0, + 0x50081,0x8,0xe79,0xe77,0xf72,0x50081,0x8,0xe7a,0xe75,0xe79,0x50085,0x8, + 0xe7c,0xf95,0x1a0,0x50085,0x8,0xe7e,0xf91,0x1a0,0x50081,0x8,0xe80,0xe7e, + 0xf93,0x50081,0x8,0xe81,0xe7c,0xe80,0x50085,0x8,0xe83,0xfb6,0x1a0,0x50085, + 0x8,0xe85,0xfb2,0x1a0,0x50081,0x8,0xe87,0xe85,0xfb4,0x50081,0x8,0xe88, + 0xe83,0xe87,0x50085,0x8,0xe8a,0xfd7,0x1a0,0x50085,0x8,0xe8c,0xfd3,0x1a0, + 0x50081,0x8,0xe8e,0xe8c,0xfd5,0x50081,0x8,0xe8f,0xe8a,0xe8e,0x50085,0x8, + 0xe91,0xff8,0x1a0,0x50085,0x8,0xe93,0xff4,0x1a0,0x50081,0x8,0xe95,0xe93, + 0xff6,0x50081,0x8,0xe96,0xe91,0xe95,0x50081,0x8,0x113f,0xe7a,0xe81,0x50081, + 0x8,0x1140,0x113f,0xe8f,0x50081,0x8,0x1141,0x1140,0xe96,0x50085,0x8,0xea1, + 0x1c8,0x1141,0x50083,0x8,0xea3,0xea1,0xe88,0x6000c,0x8,0xea5,0x1,0x4, + 0xea3,0x7000c,0x8,0x1014,0x1,0x28,0xe81,0xe88,0x7000c,0x8,0x1015,0x1, + 0x28,0xe7a,0x1014,0x7000c,0x8,0x101b,0x1,0x28,0xe8f,0xe96,0x7000c,0x8, + 0x101c,0x1,0x28,0x1015,0x101b,0x7000c,0x8,0x1022,0x1,0x25,0xe81,0xe88, + 0x7000c,0x8,0x1023,0x1,0x25,0xe7a,0x1022,0x7000c,0x8,0x1029,0x1,0x25, + 0xe8f,0xe96,0x7000c,0x8,0x102a,0x1,0x25,0x1023,0x1029,0x50083,0x8,0xeb4, + 0x101c,0x102a,0x4007c,0x6,0x103e,0xeb4,0x50082,0x6,0x1032,0xaf,0x103e,0x4007c, + 0x8,0x1042,0x1032,0x4007f,0x8,0x1036,0x1042,0x50085,0x8,0x1038,0x1036,0xeb4, + 0x50081,0x8,0x1039,0x1038,0xbb,0x50085,0x8,0x103a,0x1042,0x1039,0x50085,0x8, + 0xeb6,0xea5,0x103a,0x8000c,0x8,0x1046,0x1,0x2b,0xeb6,0xa5,0x9f,0x50085, + 0x8,0xeb9,0x1f8,0x1046,0x50081,0x8,0xeba,0xeb9,0x9f,0x7000c,0x8,0x104c, + 0x1,0x25,0xf91,0xfd3,0x7000c,0x8,0x104d,0x1,0x25,0xf70,0x104c,0x7000c, + 0x8,0x1052,0x1,0x25,0x104d,0xff4,0x7000c,0x8,0x1058,0x1,0x25,0xf93, + 0xfd5,0x7000c,0x8,0x1059,0x1,0x25,0xf72,0x1058,0x7000c,0x8,0x105e,0x1, + 0x25,0x1059,0xff6,0x7000c,0x8,0x1064,0x1,0x25,0xf95,0xfd7,0x7000c,0x8, + 0x1065,0x1,0x25,0xf74,0x1064,0x7000c,0x8,0x106a,0x1,0x25,0x1065,0xff8, + 0x7000c,0x8,0x1070,0x1,0x28,0xf91,0xfd3,0x7000c,0x8,0x1071,0x1,0x28, + 0xf70,0x1070,0x7000c,0x8,0xed2,0x1,0x28,0x1071,0xff4,0x7000c,0x8,0x1077, + 0x1,0x28,0xf93,0xfd5,0x7000c,0x8,0x1078,0x1,0x28,0xf72,0x1077,0x7000c, + 0x8,0xed8,0x1,0x28,0x1078,0xff6,0x7000c,0x8,0x107e,0x1,0x28,0xf95, + 0xfd7,0x7000c,0x8,0x107f,0x1,0x28,0xf74,0x107e,0x7000c,0x8,0xede,0x1, + 0x28,0x107f,0xff8,0x50088,0x8,0x1083,0x1c8,0xed2,0x50085,0x8,0xee3,0x1052, + 0x1083,0x50088,0x8,0x1087,0x1c8,0xed8,0x50085,0x8,0xee8,0x105e,0x1087,0x50088, + 0x8,0x108b,0x1c8,0xede,0x50085,0x8,0xeed,0x106a,0x108b,0x50083,0x8,0xef1, + 0x9f,0xed2,0x50085,0x8,0xef3,0x245,0x1052,0x50081,0x8,0xef6,0xef3,0x241, + 0x50088,0x8,0x108f,0x9f,0xef6,0x50085,0x8,0xef8,0xef1,0x108f,0x50083,0x8, + 0xefc,0x9f,0xed8,0x50085,0x8,0xefe,0x245,0x105e,0x50081,0x8,0xf01,0xefe, + 0x241,0x50088,0x8,0x1093,0x9f,0xf01,0x50085,0x8,0xf03,0xefc,0x1093,0x50083, + 0x8,0xf07,0x9f,0xede,0x50085,0x8,0xf09,0x245,0x106a,0x50081,0x8,0xf0c, + 0xf09,0x241,0x50088,0x8,0x1097,0x9f,0xf0c,0x50085,0x8,0xf0e,0xf07,0x1097, + 0x4007f,0x8,0xf10,0xee3,0x7000c,0x8,0xf12,0x1,0x28,0xf10,0xef8,0x4007f, + 0x8,0xf14,0xee8,0x7000c,0x8,0xf16,0x1,0x28,0xf14,0xf03,0x4007f,0x8, + 0xf18,0xeed,0x7000c,0x8,0xf1a,0x1,0x28,0xf18,0xf0e,0x7000c,0x8,0x109d, + 0x1,0x28,0xf16,0xf1a,0x7000c,0x8,0x109e,0x1,0x28,0xf12,0x109d,0x7000c, + 0x8,0x10a3,0x1,0x25,0x109e,0xa5,0x7000c,0x8,0xf20,0x1,0x28,0x290, + 0x10a3,0x50085,0x8,0xf24,0xf20,0x6b7,0x50085,0x8,0xf27,0xf24,0xeba,0x50085, + 0x8,0xf29,0x245,0xf27,0x50081,0x8,0xf2a,0xf29,0x9f,0x4007c,0x6,0x10bb, + 0xf2a,0x50082,0x6,0x10af,0xaf,0x10bb,0x4007c,0x8,0x10bf,0x10af,0x4007f,0x8, + 0x10b3,0x10bf,0x50085,0x8,0x10b5,0x10b3,0xf2a,0x50081,0x8,0x10b6,0x10b5,0xbb, + 0x50085,0x8,0x10b7,0x10bf,0x10b6,0x50081,0x8,0x1142,0xf70,0xf91,0x50081,0x8, + 0x1143,0x1142,0xff4,0x50081,0x8,0x1144,0x1143,0xfd3,0x50085,0x8,0xf3a,0xf27, + 0x1144,0x50081,0x8,0xf3c,0xf3a,0xfb2,0x50085,0x8,0xf3e,0xf3c,0x10b7,0x50081, + 0x8,0x1145,0xf72,0xf93,0x50081,0x8,0x1146,0x1145,0xff6,0x50081,0x8,0x1147, + 0x1146,0xfd5,0x50085,0x8,0xf4d,0xf27,0x1147,0x50081,0x8,0xf4f,0xf4d,0xfb4, + 0x50085,0x8,0xf51,0xf4f,0x10b7,0x50081,0x8,0x1148,0xf74,0xf95,0x50081,0x8, + 0x1149,0x1148,0xff8,0x50081,0x8,0x114a,0x1149,0xfd7,0x50085,0x8,0xf60,0xf27, + 0x114a,0x50081,0x8,0xf62,0xf60,0xfb6,0x50085,0x8,0xf64,0xf62,0x10b7,0x60050, + 0x48,0x125e,0xf3e,0xf51,0xf64,0x4003d,0xdc,0x10c3,0xef,0x7005f,0x43,0x10c4, + 0x10c3,0xf1,0x2,0x8b,0x50051,0x8,0x10c5,0x10c4,0x0,0x500b4,0xf6,0x10c7, + 0x10c5,0xa5,0x600a9,0x8,0x1162,0x10c7,0x9f,0x10c5,0x60050,0x48,0xda0,0x1162, + 0x1162,0x1162,0x50088,0x48,0xda1,0x125e,0xda0,0x4007c,0xff,0x10cf,0x370,0x40072, + 0x41,0x10d0,0x10cf,0x4003d,0xe4,0x10d4,0xe6,0x50051,0x8,0x10d7,0xda1,0x0, + 0x50051,0x8,0x10d8,0xda1,0x1,0x50051,0x8,0x10d9,0xda1,0x2,0x70050,0x43, + 0x10da,0x10d7,0x10d8,0x10d9,0x9f,0x40063,0x10d4,0x10d0,0x10da,0x100fd,0x10038, +}; +static const char *fu1_rcas_pass_0_cb_names[] = {"cbRCAS"}; +static const uint32_t fu1_rcas_pass_0_cb_bind[] = {4}; +static const uint32_t fu1_rcas_pass_0_cb_count[] = {1}; +static const uint32_t fu1_rcas_pass_0_cb_space[] = {0}; +static const char *fu1_rcas_pass_0_srv_tex_names[] = {"r_input_exposure", "r_rcas_input"}; +static const uint32_t fu1_rcas_pass_0_srv_tex_bind[] = {0, 1}; +static const uint32_t fu1_rcas_pass_0_srv_tex_count[] = {1, 1}; +static const uint32_t fu1_rcas_pass_0_srv_tex_space[] = {0, 0}; +static const char *fu1_rcas_pass_0_uav_tex_names[] = {"rw_upscaled_output"}; +static const uint32_t fu1_rcas_pass_0_uav_tex_bind[] = {2}; +static const uint32_t fu1_rcas_pass_0_uav_tex_count[] = {1}; +static const uint32_t fu1_rcas_pass_0_uav_tex_space[] = {0}; + +static const uint32_t fu1_debug_view_pass_0_spv[2411] = { + 0x7230203,0x10500,0x8000b,0x709,0x0,0x20011,0x1,0x20011,0x38,0x6000b,0x1,0x4c534c47, + 0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0xd000f,0x5,0x4,0x6e69616d,0x0,0x8a, + 0xa9,0xad,0xb7,0xbf,0xc8,0xd3,0x26f,0x60010,0x4,0x11,0x8,0x8, + 0x1,0x30003,0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572, + 0x74636e75,0x736e6f69,0x0,0x80004,0x455f4c47,0x735f5458,0x65646168,0x36315f72,0x5f746962,0x726f7473,0x656761,0xb0004, + 0x455f4c47,0x735f5458,0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004,0x475f4c47, + 0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45, + 0x64756c63,0x69645f65,0x74636572,0x657669,0x40005,0x4,0x6e69616d,0x0,0x70005,0x4a,0x44786646,0x67756265, + 0x77656956,0x74726f70,0x0,0x50006,0x4a,0x0,0x7366666f,0x7465,0x50006,0x4a,0x1,0x657a6973, + 0x0,0x70005,0x88,0x53466263,0x50553352,0x4c414353,0x745f5245,0x0,0x60006,0x88,0x0,0x6e655269, + 0x53726564,0x657a69,0x70006,0x88,0x1,0x73705569,0x656c6163,0x657a6953,0x0,0x70006,0x88,0x2, + 0x78614d69,0x646e6552,0x69537265,0x657a,0x80006,0x88,0x3,0x76654466,0x54656369,0x6569566f,0x70654477,0x6874, + 0xa0006,0x88,0x4,0x65695666,0x61705377,0x6f546563,0x6574654d,0x61467372,0x726f7463,0x0,0x60005,0x8a, + 0x53466263,0x70553352,0x6c616373,0x7265,0x90005,0xa9,0x6e695f72,0x6e726574,0x755f6c61,0x61637370,0x5f64656c,0x6f6c6f63, + 0x72,0x60005,0xad,0x694c5f73,0x7261656e,0x6d616c43,0x70,0x70005,0xb7,0x755f7772,0x61637370,0x5f64656c, + 0x7074756f,0x7475,0x90005,0xbf,0x69645f72,0x6574616c,0x6f6d5f64,0x6e6f6974,0x6365765f,0x73726f74,0x0,0x60005, + 0xc8,0x69645f72,0x6574616c,0x65645f64,0x687470,0x90005,0xd3,0x69645f72,0x6574616c,0x65725f64,0x69746361,0x6d5f6576, + 0x736b7361,0x0,0x80005,0x26f,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x44,0x30047,0x88, + 0x2,0x50048,0x88,0x0,0x23,0x0,0x50048,0x88,0x1,0x23,0x10,0x50048, + 0x88,0x2,0x23,0x20,0x50048,0x88,0x3,0x23,0x30,0x50048,0x88,0x4, + 0x23,0x78,0x40047,0x8a,0x21,0x6,0x40047,0x8a,0x22,0x0,0x40047,0xa9, + 0x21,0x3,0x40047,0xa9,0x22,0x0,0x40047,0xad,0x21,0x3e9,0x40047,0xad, + 0x22,0x0,0x30047,0xb7,0x19,0x40047,0xb7,0x21,0x5,0x40047,0xb7,0x22, + 0x0,0x40047,0xbf,0x21,0x1,0x40047,0xbf,0x22,0x0,0x40047,0xc8,0x21, + 0x2,0x40047,0xc8,0x22,0x0,0x40047,0xd3,0x21,0x0,0x40047,0xd3,0x22, + 0x0,0x40047,0x26f,0xb,0x1c,0x40047,0x284,0xb,0x19,0x20013,0x2,0x30021, + 0x3,0x2,0x30016,0x6,0x20,0x40017,0xc,0x6,0x2,0x40015,0x17,0x20, + 0x1,0x40017,0x18,0x17,0x2,0x40017,0x20,0x6,0x4,0x40020,0x2b,0x7, + 0x18,0x4001e,0x4a,0x18,0x18,0x40020,0x4b,0x7,0x4a,0x20014,0x6e,0x4002b, + 0x6,0x79,0x0,0x4002b,0x6,0x7a,0x3f800000,0x7001e,0x88,0x18,0x18,0x18, + 0x20,0x6,0x40020,0x89,0x2,0x88,0x4003b,0x89,0x8a,0x2,0x4002b,0x17, + 0x8b,0x0,0x40020,0x8c,0x2,0x18,0x4002b,0x17,0x96,0x2,0x40020,0x9c, + 0x2,0x20,0x40020,0xa2,0x2,0x6,0x90019,0xa7,0x6,0x1,0x0,0x0, + 0x0,0x1,0x0,0x40020,0xa8,0x0,0xa7,0x4003b,0xa8,0xa9,0x0,0x2001a, + 0xab,0x40020,0xac,0x0,0xab,0x4003b,0xac,0xad,0x0,0x3001b,0xaf,0xa7, + 0x90019,0xb5,0x6,0x1,0x0,0x0,0x0,0x2,0x0,0x40020,0xb6,0x0, + 0xb5,0x4003b,0xb6,0xb7,0x0,0x4003b,0xa8,0xbf,0x0,0x4003b,0xa8,0xc8, + 0x0,0x40015,0xce,0x20,0x0,0x4003b,0xa8,0xd3,0x0,0x4002b,0x6,0xe1, + 0x3f000000,0x5002c,0xc,0xe2,0xe1,0xe1,0x4002b,0xce,0xf8,0x1,0x4002b,0x17, + 0x111,0x1,0x4002b,0xce,0x19a,0x3,0x4002b,0x6,0x1ec,0x3eaaaaab,0x5002c,0xc, + 0x1ed,0x1ec,0x1ec,0x4002b,0x17,0x1fb,0x3,0x4001c,0x205,0x4a,0x19a,0x4001c, + 0x206,0x205,0x19a,0x40020,0x207,0x7,0x206,0x40017,0x26d,0xce,0x3,0x40020, + 0x26e,0x1,0x26d,0x4003b,0x26e,0x26f,0x1,0x40017,0x270,0xce,0x2,0x4002b, + 0xce,0x283,0x8,0x6002c,0x26d,0x284,0x283,0x283,0xf8,0x4002b,0x6,0x6d4, + 0x3d23d70a,0x4002b,0xce,0x707,0x2,0x4002b,0xce,0x708,0x4,0x50036,0x2,0x4, + 0x0,0x3,0x200f8,0x5,0x4003b,0x207,0x289,0x7,0x4003d,0x26d,0x271,0x26f, + 0x7004f,0x270,0x272,0x271,0x271,0x0,0x1,0x4007c,0x18,0x273,0x272,0x50041, + 0x8c,0x304,0x8a,0xf8,0x4003d,0x18,0x305,0x304,0x4006f,0xc,0x2a4,0x305, + 0x50085,0xc,0x2a6,0x2a4,0x1ed,0x4006e,0x18,0x2a7,0x2a6,0x200f9,0x2a8,0x200f8, + 0x2a8,0x700f5,0x17,0x6b4,0x8b,0x5,0x2c4,0x2c2,0x500b1,0x6e,0x2ab,0x6b4, + 0x1fb,0x400f6,0x2c5,0x2c2,0x0,0x400fa,0x2ab,0x2ac,0x2c5,0x200f8,0x2ac,0x200f9, + 0x2ad,0x200f8,0x2ad,0x700f5,0x17,0x6cd,0x8b,0x2ac,0x2c0,0x2b1,0x500b1,0x6e, + 0x2b0,0x6cd,0x1fb,0x400f6,0x2c1,0x2b1,0x0,0x400fa,0x2b0,0x2b1,0x2c1,0x200f8, + 0x2b1,0x50050,0x18,0x2b7,0x6cd,0x6b4,0x50084,0x18,0x2b8,0x2a7,0x2b7,0x70041, + 0x2b,0x2b9,0x289,0x6b4,0x6cd,0x8b,0x3003e,0x2b9,0x2b8,0x70041,0x2b,0x2bd, + 0x289,0x6b4,0x6cd,0x111,0x3003e,0x2bd,0x2a7,0x50080,0x17,0x2c0,0x6cd,0x111, + 0x200f9,0x2ad,0x200f8,0x2c1,0x200f9,0x2c2,0x200f8,0x2c2,0x50080,0x17,0x2c4,0x6b4, + 0x111,0x200f9,0x2a8,0x200f8,0x2c5,0x60041,0x4b,0x2c7,0x289,0x8b,0x8b,0x4003d, + 0x4a,0x2c8,0x2c7,0x50051,0x18,0x668,0x2c8,0x0,0x50051,0x18,0x669,0x2c8, + 0x1,0x50080,0x18,0x30e,0x668,0x669,0x50051,0x17,0x310,0x273,0x0,0x50051, + 0x17,0x312,0x668,0x0,0x500af,0x6e,0x313,0x310,0x312,0x300f7,0x31a,0x0, + 0x400fa,0x313,0x314,0x31a,0x200f8,0x314,0x50051,0x17,0x318,0x30e,0x0,0x500b1, + 0x6e,0x319,0x310,0x318,0x200f9,0x31a,0x200f8,0x31a,0x700f5,0x6e,0x31b,0x313, + 0x2c5,0x319,0x314,0x300f7,0x32a,0x0,0x400fa,0x31b,0x31c,0x32a,0x200f8,0x31c, + 0x50051,0x17,0x31e,0x273,0x1,0x50051,0x17,0x320,0x668,0x1,0x500af,0x6e, + 0x321,0x31e,0x320,0x300f7,0x328,0x0,0x400fa,0x321,0x322,0x328,0x200f8,0x322, + 0x50051,0x17,0x326,0x30e,0x1,0x500b1,0x6e,0x327,0x31e,0x326,0x200f9,0x328, + 0x200f8,0x328,0x700f5,0x6e,0x329,0x321,0x31c,0x327,0x322,0x200f9,0x32a,0x200f8, + 0x32a,0x700f5,0x6e,0x32b,0x31b,0x31a,0x329,0x328,0x300f7,0x2cf,0x0,0x400fa, + 0x32b,0x2ca,0x2cf,0x200f8,0x2ca,0x4003d,0x4a,0x2cd,0x2c7,0x50051,0x18,0x664, + 0x2cd,0x0,0x50051,0x18,0x665,0x2cd,0x1,0x50082,0x18,0x34c,0x273,0x664, + 0x4006f,0xc,0x34d,0x34c,0x50081,0xc,0x34f,0x34d,0xe2,0x4006f,0xc,0x352, + 0x665,0x50088,0xc,0x353,0x34f,0x352,0x50041,0x8c,0x357,0x8a,0x8b,0x4003d, + 0x18,0x358,0x357,0x50041,0x8c,0x35b,0x8a,0x707,0x4003d,0x18,0x35c,0x35b, + 0x4006f,0xc,0x368,0x358,0x50085,0xc,0x369,0x353,0x368,0x50083,0xc,0x36c, + 0x368,0xe2,0x7000c,0xc,0x379,0x1,0x25,0x369,0x36c,0x7000c,0xc,0x37e, + 0x1,0x28,0xe2,0x379,0x4006f,0xc,0x372,0x35c,0x50088,0xc,0x373,0x37e, + 0x372,0x4003d,0xa7,0x381,0xbf,0x4003d,0xab,0x382,0xad,0x50056,0xaf,0x383, + 0x381,0x382,0x70058,0x20,0x385,0x383,0x373,0x2,0x79,0x7004f,0xc,0x386, + 0x385,0x385,0x0,0x1,0x50085,0xc,0x38c,0x386,0x368,0x5008e,0xc,0x38d, + 0x38c,0xe1,0x50081,0xc,0x38f,0xe2,0x38d,0x50051,0x6,0x390,0x38f,0x0, + 0x50051,0x6,0x391,0x38f,0x1,0x4003d,0xb5,0x398,0xb7,0x70050,0x20,0x39e, + 0x390,0x391,0xe1,0x7a,0x40063,0x398,0x273,0x39e,0x200f9,0x2cf,0x200f8,0x2cf, + 0x60041,0x4b,0x2d1,0x289,0x8b,0x111,0x4003d,0x4a,0x2d2,0x2d1,0x50051,0x18, + 0x675,0x2d2,0x0,0x50051,0x18,0x676,0x2d2,0x1,0x50080,0x18,0x3a6,0x675, + 0x676,0x50051,0x17,0x3aa,0x675,0x0,0x500af,0x6e,0x3ab,0x310,0x3aa,0x300f7, + 0x3b2,0x0,0x400fa,0x3ab,0x3ac,0x3b2,0x200f8,0x3ac,0x50051,0x17,0x3b0,0x3a6, + 0x0,0x500b1,0x6e,0x3b1,0x310,0x3b0,0x200f9,0x3b2,0x200f8,0x3b2,0x700f5,0x6e, + 0x3b3,0x3ab,0x2cf,0x3b1,0x3ac,0x300f7,0x3c2,0x0,0x400fa,0x3b3,0x3b4,0x3c2, + 0x200f8,0x3b4,0x50051,0x17,0x3b6,0x273,0x1,0x50051,0x17,0x3b8,0x675,0x1, + 0x500af,0x6e,0x3b9,0x3b6,0x3b8,0x300f7,0x3c0,0x0,0x400fa,0x3b9,0x3ba,0x3c0, + 0x200f8,0x3ba,0x50051,0x17,0x3be,0x3a6,0x1,0x500b1,0x6e,0x3bf,0x3b6,0x3be, + 0x200f9,0x3c0,0x200f8,0x3c0,0x700f5,0x6e,0x3c1,0x3b9,0x3b4,0x3bf,0x3ba,0x200f9, + 0x3c2,0x200f8,0x3c2,0x700f5,0x6e,0x3c3,0x3b3,0x3b2,0x3c1,0x3c0,0x300f7,0x2d9, + 0x0,0x400fa,0x3c3,0x2d4,0x2d9,0x200f8,0x2d4,0x4003d,0x4a,0x2d7,0x2d1,0x50051, + 0x18,0x660,0x2d7,0x0,0x50051,0x18,0x661,0x2d7,0x1,0x50082,0x18,0x3df, + 0x273,0x660,0x4006f,0xc,0x3e0,0x3df,0x50081,0xc,0x3e2,0x3e0,0xe2,0x4006f, + 0xc,0x3e5,0x661,0x50088,0xc,0x3e6,0x3e2,0x3e5,0x4003d,0xa7,0x3ea,0xa9, + 0x4003d,0xab,0x3eb,0xad,0x50056,0xaf,0x3ec,0x3ea,0x3eb,0x70058,0x20,0x3ee, + 0x3ec,0x3e6,0x2,0x79,0x50051,0x6,0x3d2,0x3ee,0x3,0x50083,0x6,0x3d3, + 0x3d2,0x7a,0x8000c,0x6,0x3f2,0x1,0x2b,0x3d3,0x79,0x7a,0x4003d,0xb5, + 0x3f4,0xb7,0x70050,0x20,0x3fa,0x3f2,0x79,0x79,0x7a,0x40063,0x3f4,0x273, + 0x3fa,0x200f9,0x2d9,0x200f8,0x2d9,0x60041,0x4b,0x2db,0x289,0x8b,0x96,0x4003d, + 0x4a,0x2dc,0x2db,0x50051,0x18,0x682,0x2dc,0x0,0x50051,0x18,0x683,0x2dc, + 0x1,0x50080,0x18,0x402,0x682,0x683,0x50051,0x17,0x406,0x682,0x0,0x500af, + 0x6e,0x407,0x310,0x406,0x300f7,0x40e,0x0,0x400fa,0x407,0x408,0x40e,0x200f8, + 0x408,0x50051,0x17,0x40c,0x402,0x0,0x500b1,0x6e,0x40d,0x310,0x40c,0x200f9, + 0x40e,0x200f8,0x40e,0x700f5,0x6e,0x40f,0x407,0x2d9,0x40d,0x408,0x300f7,0x41e, + 0x0,0x400fa,0x40f,0x410,0x41e,0x200f8,0x410,0x50051,0x17,0x412,0x273,0x1, + 0x50051,0x17,0x414,0x682,0x1,0x500af,0x6e,0x415,0x412,0x414,0x300f7,0x41c, + 0x0,0x400fa,0x415,0x416,0x41c,0x200f8,0x416,0x50051,0x17,0x41a,0x402,0x1, + 0x500b1,0x6e,0x41b,0x412,0x41a,0x200f9,0x41c,0x200f8,0x41c,0x700f5,0x6e,0x41d, + 0x415,0x410,0x41b,0x416,0x200f9,0x41e,0x200f8,0x41e,0x700f5,0x6e,0x41f,0x40f, + 0x40e,0x41d,0x41c,0x300f7,0x2e3,0x0,0x400fa,0x41f,0x2de,0x2e3,0x200f8,0x2de, + 0x4003d,0x4a,0x2e1,0x2db,0x50051,0x18,0x65c,0x2e1,0x0,0x50051,0x18,0x65d, + 0x2e1,0x1,0x50082,0x18,0x446,0x273,0x65c,0x4006f,0xc,0x447,0x446,0x50081, + 0xc,0x449,0x447,0xe2,0x4006f,0xc,0x44c,0x65d,0x50088,0xc,0x44d,0x449, + 0x44c,0x50041,0x8c,0x451,0x8a,0x8b,0x4003d,0x18,0x452,0x451,0x50041,0x8c, + 0x455,0x8a,0x707,0x4003d,0x18,0x456,0x455,0x4006f,0xc,0x462,0x452,0x50085, + 0xc,0x463,0x44d,0x462,0x50083,0xc,0x466,0x462,0xe2,0x7000c,0xc,0x473, + 0x1,0x25,0x463,0x466,0x7000c,0xc,0x478,0x1,0x28,0xe2,0x473,0x4006f, + 0xc,0x46c,0x456,0x50088,0xc,0x46d,0x478,0x46c,0x4003d,0xa7,0x47b,0xc8, + 0x4003d,0xab,0x47c,0xad,0x50056,0xaf,0x47d,0x47b,0x47c,0x70058,0x20,0x47f, + 0x47d,0x46d,0x2,0x79,0x50051,0x6,0x480,0x47f,0x0,0x50041,0x9c,0x495, + 0x8a,0x19a,0x4003d,0x20,0x496,0x495,0x50051,0x6,0x48d,0x496,0x1,0x50051, + 0x6,0x490,0x496,0x0,0x50083,0x6,0x491,0x480,0x490,0x50088,0x6,0x492, + 0x48d,0x491,0x50041,0xa2,0x499,0x8a,0x708,0x4003d,0x6,0x49a,0x499,0x50085, + 0x6,0x487,0x492,0x49a,0x50085,0x6,0x43b,0x487,0x6d4,0x8000c,0x6,0x49e, + 0x1,0x2b,0x43b,0x79,0x7a,0x4003d,0xb5,0x4a0,0xb7,0x70050,0x20,0x4a6, + 0x49e,0x79,0x79,0x7a,0x40063,0x4a0,0x273,0x4a6,0x200f9,0x2e3,0x200f8,0x2e3, + 0x60041,0x4b,0x2e5,0x289,0x96,0x8b,0x4003d,0x4a,0x2e6,0x2e5,0x50051,0x18, + 0x68f,0x2e6,0x0,0x50051,0x18,0x690,0x2e6,0x1,0x50080,0x18,0x4ae,0x68f, + 0x690,0x50051,0x17,0x4b2,0x68f,0x0,0x500af,0x6e,0x4b3,0x310,0x4b2,0x300f7, + 0x4ba,0x0,0x400fa,0x4b3,0x4b4,0x4ba,0x200f8,0x4b4,0x50051,0x17,0x4b8,0x4ae, + 0x0,0x500b1,0x6e,0x4b9,0x310,0x4b8,0x200f9,0x4ba,0x200f8,0x4ba,0x700f5,0x6e, + 0x4bb,0x4b3,0x2e3,0x4b9,0x4b4,0x300f7,0x4ca,0x0,0x400fa,0x4bb,0x4bc,0x4ca, + 0x200f8,0x4bc,0x50051,0x17,0x4be,0x273,0x1,0x50051,0x17,0x4c0,0x68f,0x1, + 0x500af,0x6e,0x4c1,0x4be,0x4c0,0x300f7,0x4c8,0x0,0x400fa,0x4c1,0x4c2,0x4c8, + 0x200f8,0x4c2,0x50051,0x17,0x4c6,0x4ae,0x1,0x500b1,0x6e,0x4c7,0x4be,0x4c6, + 0x200f9,0x4c8,0x200f8,0x4c8,0x700f5,0x6e,0x4c9,0x4c1,0x4bc,0x4c7,0x4c2,0x200f9, + 0x4ca,0x200f8,0x4ca,0x700f5,0x6e,0x4cb,0x4bb,0x4ba,0x4c9,0x4c8,0x300f7,0x2ed, + 0x0,0x400fa,0x4cb,0x2e8,0x2ed,0x200f8,0x2e8,0x4003d,0x4a,0x2eb,0x2e5,0x50051, + 0x18,0x658,0x2eb,0x0,0x50051,0x18,0x659,0x2eb,0x1,0x50082,0x18,0x4ee, + 0x273,0x658,0x4006f,0xc,0x4ef,0x4ee,0x50081,0xc,0x4f1,0x4ef,0xe2,0x4006f, + 0xc,0x4f4,0x659,0x50088,0xc,0x4f5,0x4f1,0x4f4,0x50041,0x8c,0x4f9,0x8a, + 0x8b,0x4003d,0x18,0x4fa,0x4f9,0x50041,0x8c,0x4fd,0x8a,0x707,0x4003d,0x18, + 0x4fe,0x4fd,0x4006f,0xc,0x50a,0x4fa,0x50085,0xc,0x50b,0x4f5,0x50a,0x50083, + 0xc,0x50e,0x50a,0xe2,0x7000c,0xc,0x51b,0x1,0x25,0x50b,0x50e,0x7000c, + 0xc,0x520,0x1,0x28,0xe2,0x51b,0x4006f,0xc,0x514,0x4fe,0x50088,0xc, + 0x515,0x520,0x514,0x4003d,0xa7,0x523,0xd3,0x4003d,0xab,0x524,0xad,0x50056, + 0xaf,0x525,0x523,0x524,0x70058,0x20,0x527,0x525,0x515,0x2,0x79,0x50051, + 0x6,0x4e2,0x527,0x1,0x8000c,0x6,0x52b,0x1,0x2b,0x4e2,0x79,0x7a, + 0x4003d,0xb5,0x52d,0xb7,0x70050,0x20,0x533,0x79,0x52b,0x79,0x7a,0x40063, + 0x52d,0x273,0x533,0x200f9,0x2ed,0x200f8,0x2ed,0x60041,0x4b,0x2ef,0x289,0x96, + 0x111,0x4003d,0x4a,0x2f0,0x2ef,0x50051,0x18,0x69c,0x2f0,0x0,0x50051,0x18, + 0x69d,0x2f0,0x1,0x50080,0x18,0x53b,0x69c,0x69d,0x50051,0x17,0x53f,0x69c, + 0x0,0x500af,0x6e,0x540,0x310,0x53f,0x300f7,0x547,0x0,0x400fa,0x540,0x541, + 0x547,0x200f8,0x541,0x50051,0x17,0x545,0x53b,0x0,0x500b1,0x6e,0x546,0x310, + 0x545,0x200f9,0x547,0x200f8,0x547,0x700f5,0x6e,0x548,0x540,0x2ed,0x546,0x541, + 0x300f7,0x557,0x0,0x400fa,0x548,0x549,0x557,0x200f8,0x549,0x50051,0x17,0x54b, + 0x273,0x1,0x50051,0x17,0x54d,0x69c,0x1,0x500af,0x6e,0x54e,0x54b,0x54d, + 0x300f7,0x555,0x0,0x400fa,0x54e,0x54f,0x555,0x200f8,0x54f,0x50051,0x17,0x553, + 0x53b,0x1,0x500b1,0x6e,0x554,0x54b,0x553,0x200f9,0x555,0x200f8,0x555,0x700f5, + 0x6e,0x556,0x54e,0x549,0x554,0x54f,0x200f9,0x557,0x200f8,0x557,0x700f5,0x6e, + 0x558,0x548,0x547,0x556,0x555,0x300f7,0x2f7,0x0,0x400fa,0x558,0x2f2,0x2f7, + 0x200f8,0x2f2,0x4003d,0x4a,0x2f5,0x2ef,0x50051,0x18,0x654,0x2f5,0x0,0x50051, + 0x18,0x655,0x2f5,0x1,0x50082,0x18,0x57b,0x273,0x654,0x4006f,0xc,0x57c, + 0x57b,0x50081,0xc,0x57e,0x57c,0xe2,0x4006f,0xc,0x581,0x655,0x50088,0xc, + 0x582,0x57e,0x581,0x50041,0x8c,0x586,0x8a,0x8b,0x4003d,0x18,0x587,0x586, + 0x50041,0x8c,0x58a,0x8a,0x707,0x4003d,0x18,0x58b,0x58a,0x4006f,0xc,0x597, + 0x587,0x50085,0xc,0x598,0x582,0x597,0x50083,0xc,0x59b,0x597,0xe2,0x7000c, + 0xc,0x5a8,0x1,0x25,0x598,0x59b,0x7000c,0xc,0x5ad,0x1,0x28,0xe2, + 0x5a8,0x4006f,0xc,0x5a1,0x58b,0x50088,0xc,0x5a2,0x5ad,0x5a1,0x4003d,0xa7, + 0x5b0,0xd3,0x4003d,0xab,0x5b1,0xad,0x50056,0xaf,0x5b2,0x5b0,0x5b1,0x70058, + 0x20,0x5b4,0x5b2,0x5a2,0x2,0x79,0x50051,0x6,0x56f,0x5b4,0x2,0x8000c, + 0x6,0x5b8,0x1,0x2b,0x56f,0x79,0x7a,0x4003d,0xb5,0x5ba,0xb7,0x70050, + 0x20,0x5c0,0x79,0x5b8,0x79,0x7a,0x40063,0x5ba,0x273,0x5c0,0x200f9,0x2f7, + 0x200f8,0x2f7,0x60041,0x4b,0x2f9,0x289,0x96,0x96,0x4003d,0x4a,0x2fa,0x2f9, + 0x50051,0x18,0x6a9,0x2fa,0x0,0x50051,0x18,0x6aa,0x2fa,0x1,0x50080,0x18, + 0x5c8,0x6a9,0x6aa,0x50051,0x17,0x5cc,0x6a9,0x0,0x500af,0x6e,0x5cd,0x310, + 0x5cc,0x300f7,0x5d4,0x0,0x400fa,0x5cd,0x5ce,0x5d4,0x200f8,0x5ce,0x50051,0x17, + 0x5d2,0x5c8,0x0,0x500b1,0x6e,0x5d3,0x310,0x5d2,0x200f9,0x5d4,0x200f8,0x5d4, + 0x700f5,0x6e,0x5d5,0x5cd,0x2f7,0x5d3,0x5ce,0x300f7,0x5e4,0x0,0x400fa,0x5d5, + 0x5d6,0x5e4,0x200f8,0x5d6,0x50051,0x17,0x5d8,0x273,0x1,0x50051,0x17,0x5da, + 0x6a9,0x1,0x500af,0x6e,0x5db,0x5d8,0x5da,0x300f7,0x5e2,0x0,0x400fa,0x5db, + 0x5dc,0x5e2,0x200f8,0x5dc,0x50051,0x17,0x5e0,0x5c8,0x1,0x500b1,0x6e,0x5e1, + 0x5d8,0x5e0,0x200f9,0x5e2,0x200f8,0x5e2,0x700f5,0x6e,0x5e3,0x5db,0x5d6,0x5e1, + 0x5dc,0x200f9,0x5e4,0x200f8,0x5e4,0x700f5,0x6e,0x5e5,0x5d5,0x5d4,0x5e3,0x5e2, + 0x300f7,0x301,0x0,0x400fa,0x5e5,0x2fc,0x301,0x200f8,0x2fc,0x4003d,0x4a,0x2ff, + 0x2f9,0x50051,0x18,0x650,0x2ff,0x0,0x50051,0x18,0x651,0x2ff,0x1,0x50082, + 0x18,0x608,0x273,0x650,0x4006f,0xc,0x609,0x608,0x50081,0xc,0x60b,0x609, + 0xe2,0x4006f,0xc,0x60e,0x651,0x50088,0xc,0x60f,0x60b,0x60e,0x50041,0x8c, + 0x613,0x8a,0x8b,0x4003d,0x18,0x614,0x613,0x50041,0x8c,0x617,0x8a,0x707, + 0x4003d,0x18,0x618,0x617,0x4006f,0xc,0x624,0x614,0x50085,0xc,0x625,0x60f, + 0x624,0x50083,0xc,0x628,0x624,0xe2,0x7000c,0xc,0x635,0x1,0x25,0x625, + 0x628,0x7000c,0xc,0x63a,0x1,0x28,0xe2,0x635,0x4006f,0xc,0x62e,0x618, + 0x50088,0xc,0x62f,0x63a,0x62e,0x4003d,0xa7,0x63d,0xd3,0x4003d,0xab,0x63e, + 0xad,0x50056,0xaf,0x63f,0x63d,0x63e,0x70058,0x20,0x641,0x63f,0x62f,0x2, + 0x79,0x50051,0x6,0x5fc,0x641,0x0,0x8000c,0x6,0x645,0x1,0x2b,0x5fc, + 0x79,0x7a,0x4003d,0xb5,0x647,0xb7,0x70050,0x20,0x64d,0x79,0x645,0x79, + 0x7a,0x40063,0x647,0x273,0x64d,0x200f9,0x301,0x200f8,0x301,0x100fd,0x10038, +}; +static const char *fu1_debug_view_pass_0_cb_names[] = {"cbFSR3Upscaler"}; +static const uint32_t fu1_debug_view_pass_0_cb_bind[] = {6}; +static const uint32_t fu1_debug_view_pass_0_cb_count[] = {1}; +static const uint32_t fu1_debug_view_pass_0_cb_space[] = {0}; +static const char *fu1_debug_view_pass_0_srv_tex_names[] = {"r_dilated_reactive_masks", "r_dilated_motion_vectors", "r_dilated_depth", "r_internal_upscaled_color"}; +static const uint32_t fu1_debug_view_pass_0_srv_tex_bind[] = {0, 1, 2, 3}; +static const uint32_t fu1_debug_view_pass_0_srv_tex_count[] = {1, 1, 1, 1}; +static const uint32_t fu1_debug_view_pass_0_srv_tex_space[] = {0, 0, 0, 0}; +static const char *fu1_debug_view_pass_0_uav_tex_names[] = {"rw_upscaled_output"}; +static const uint32_t fu1_debug_view_pass_0_uav_tex_bind[] = {5}; +static const uint32_t fu1_debug_view_pass_0_uav_tex_count[] = {1}; +static const uint32_t fu1_debug_view_pass_0_uav_tex_space[] = {0}; +static const char *fu1_debug_view_pass_0_sampler_names[] = {"s_LinearClamp"}; +static const uint32_t fu1_debug_view_pass_0_sampler_bind[] = {1001}; +static const uint32_t fu1_debug_view_pass_0_sampler_count[] = {1}; +static const uint32_t fu1_debug_view_pass_0_sampler_space[] = {0}; + +static const uint32_t fu1_autogen_reactive_pass_0_spv[1005] = { + 0x7230203,0x10500,0x8000b,0x1d1,0x0,0x20011,0x1,0x20011,0x16,0x6000b,0x1,0x4c534c47, + 0x6474732e,0x3035342e,0x0,0x3000e,0x0,0x1,0xb000f,0x5,0x4,0x6e69616d,0x0,0x36, + 0x4f,0x57,0x94,0x98,0xf6,0x60010,0x4,0x11,0x8,0x8,0x1,0x30003, + 0x2,0x1c2,0xb0004,0x455f4c47,0x735f5458,0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69, + 0x0,0x80004,0x455f4c47,0x735f5458,0x65646168,0x36315f72,0x5f746962,0x726f7473,0x656761,0xb0004,0x455f4c47,0x735f5458, + 0x65646168,0x78655f72,0x63696c70,0x615f7469,0x68746972,0x6974656d,0x79745f63,0x736570,0xa0004,0x475f4c47,0x4c474f4f,0x70635f45, + 0x74735f70,0x5f656c79,0x656e696c,0x7269645f,0x69746365,0x6576,0x80004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65, + 0x74636572,0x657669,0x40005,0x4,0x6e69616d,0x0,0x80005,0x34,0x65476263,0x6172656e,0x65526574,0x69746361, + 0x745f6576,0x0,0x80006,0x34,0x0,0x5f6e6567,0x63616572,0x65766974,0x6163735f,0x656c,0x90006,0x34, + 0x1,0x5f6e6567,0x63616572,0x65766974,0x7268745f,0x6f687365,0x646c,0xa0006,0x34,0x2,0x5f6e6567,0x63616572, + 0x65766974,0x6e69625f,0x56797261,0x65756c61,0x0,0x80006,0x34,0x3,0x5f6e6567,0x63616572,0x65766974,0x616c665f, + 0x7367,0x70005,0x36,0x65476263,0x6172656e,0x65526574,0x69746361,0x6576,0x80005,0x4f,0x6e695f72,0x5f747570, + 0x6f6c6f63,0x696a5f72,0x72657474,0x6465,0x70005,0x57,0x6e695f72,0x5f747570,0x7161706f,0x6f5f6575,0x796c6e,0x60005, + 0x94,0x575f6c67,0x476b726f,0x70756f72,0x4449,0x80005,0x98,0x4c5f6c67,0x6c61636f,0x6f766e49,0x69746163,0x44496e6f, + 0x0,0x80005,0xf6,0x6f5f7772,0x75707475,0x75615f74,0x65726f74,0x69746361,0x6576,0x30047,0x34,0x2, + 0x50048,0x34,0x0,0x23,0x0,0x50048,0x34,0x1,0x23,0x4,0x50048,0x34, + 0x2,0x23,0x8,0x50048,0x34,0x3,0x23,0xc,0x40047,0x36,0x21,0x5, + 0x40047,0x36,0x22,0x0,0x40047,0x4f,0x21,0x1,0x40047,0x4f,0x22,0x0, + 0x40047,0x57,0x21,0x0,0x40047,0x57,0x22,0x0,0x40047,0x94,0xb,0x1a, + 0x40047,0x98,0xb,0x1b,0x40047,0xf6,0x21,0x2,0x40047,0xf6,0x22,0x0, + 0x40047,0x10f,0xb,0x19,0x20013,0x2,0x30021,0x3,0x2,0x30016,0x6,0x20, + 0x40015,0x14,0x20,0x0,0x40015,0x18,0x20,0x1,0x40017,0x19,0x18,0x2, + 0x40017,0x1b,0x6,0x3,0x40015,0x20,0x10,0x1,0x40017,0x21,0x20,0x2, + 0x6001e,0x34,0x6,0x6,0x6,0x14,0x40020,0x35,0x2,0x34,0x4003b,0x35, + 0x36,0x2,0x4002b,0x18,0x37,0x0,0x40020,0x38,0x2,0x6,0x4002b,0x18, + 0x3d,0x1,0x4002b,0x18,0x42,0x2,0x4002b,0x18,0x47,0x3,0x40020,0x48, + 0x2,0x14,0x90019,0x4d,0x6,0x1,0x0,0x0,0x0,0x1,0x0,0x40020, + 0x4e,0x0,0x4d,0x4003b,0x4e,0x4f,0x0,0x40017,0x52,0x6,0x4,0x4003b, + 0x4e,0x57,0x0,0x4002b,0x6,0x60,0x0,0x4002b,0x14,0x63,0x0,0x4002b, + 0x14,0x68,0x1,0x4002b,0x14,0x6c,0x2,0x4002b,0x6,0x73,0x3f800000,0x4002b, + 0x6,0x7a,0x387fda40,0x40017,0x8f,0x14,0x2,0x40017,0x92,0x14,0x3,0x40020, + 0x93,0x1,0x92,0x4003b,0x93,0x94,0x1,0x4003b,0x93,0x98,0x1,0x4002b, + 0x14,0x9d,0x8,0x5002c,0x8f,0x9e,0x9d,0x9d,0x40015,0xa4,0x10,0x0, + 0x40017,0xa5,0xa4,0x2,0x20014,0xb1,0x4002b,0x14,0xe2,0x4,0x90019,0xf4, + 0x6,0x1,0x0,0x0,0x0,0x2,0x3,0x40020,0xf5,0x0,0xf4,0x4003b, + 0xf5,0xf6,0x0,0x6002c,0x92,0x10f,0x9d,0x9d,0x68,0x50036,0x2,0x4, + 0x0,0x3,0x200f8,0x5,0x4003d,0x92,0x95,0x94,0x7004f,0x8f,0x96,0x95, + 0x95,0x0,0x1,0x4003d,0x92,0x99,0x98,0x7004f,0x8f,0x9a,0x99,0x99, + 0x0,0x1,0x50084,0x8f,0x9f,0x96,0x9e,0x50080,0x8f,0xa1,0x9f,0x9a, + 0x40071,0xa5,0xa6,0xa1,0x4007c,0x21,0xa7,0xa6,0x4003d,0x4d,0x112,0x57, + 0x40072,0x19,0x114,0xa7,0x7005f,0x52,0x115,0x112,0x114,0x2,0x37,0x8004f, + 0x1b,0x116,0x115,0x115,0x0,0x1,0x2,0x4007c,0x19,0xac,0xa1,0x4003d, + 0x4d,0x119,0x4f,0x7005f,0x52,0x11b,0x119,0xac,0x2,0x37,0x8004f,0x1b, + 0x11c,0x11b,0x11b,0x0,0x1,0x2,0x50041,0x48,0x120,0x36,0x47,0x4003d, + 0x14,0x121,0x120,0x500c7,0x14,0xb0,0x121,0x68,0x500ab,0xb1,0xb2,0xb0, + 0x63,0x300f7,0xb4,0x0,0x400fa,0xb2,0xb3,0xb4,0x200f8,0xb3,0x50051,0x6, + 0x12c,0x115,0x0,0x7000c,0x6,0x13b,0x1,0x28,0x60,0x12c,0x50051,0x6, + 0x12f,0x115,0x1,0x50051,0x6,0x131,0x115,0x2,0x7000c,0x6,0x140,0x1, + 0x28,0x12f,0x131,0x7000c,0x6,0x145,0x1,0x28,0x13b,0x140,0x50081,0x6, + 0x134,0x145,0x73,0x60050,0x1b,0x135,0x134,0x134,0x134,0x50088,0x1b,0x136, + 0x116,0x135,0x50051,0x6,0x150,0x11b,0x0,0x7000c,0x6,0x15f,0x1,0x28, + 0x60,0x150,0x50051,0x6,0x153,0x11b,0x1,0x50051,0x6,0x155,0x11b,0x2, + 0x7000c,0x6,0x164,0x1,0x28,0x153,0x155,0x7000c,0x6,0x169,0x1,0x28, + 0x15f,0x164,0x50081,0x6,0x158,0x169,0x73,0x60050,0x1b,0x159,0x158,0x158, + 0x158,0x50088,0x1b,0x15a,0x11c,0x159,0x200f9,0xb4,0x200f8,0xb4,0x700f5,0x1b, + 0x1cb,0x11c,0x5,0x15a,0xb3,0x700f5,0x1b,0x1ca,0x116,0x5,0x136,0xb3, + 0x500c7,0x14,0xbc,0x121,0x6c,0x500ab,0xb1,0xbd,0xbc,0x63,0x300f7,0xbf, + 0x0,0x400fa,0xbd,0xbe,0xbf,0x200f8,0xbe,0x50051,0x6,0x178,0x1ca,0x1, + 0x50051,0x6,0x17a,0x1ca,0x2,0x7000c,0x6,0x187,0x1,0x28,0x178,0x17a, + 0x50051,0x6,0x17d,0x1ca,0x0,0x7000c,0x6,0x18c,0x1,0x28,0x17d,0x187, + 0x50083,0x6,0x17f,0x73,0x18c,0x7000c,0x6,0x191,0x1,0x28,0x7a,0x17f, + 0x60050,0x1b,0x181,0x191,0x191,0x191,0x50088,0x1b,0x182,0x1ca,0x181,0x50051, + 0x6,0x19c,0x1cb,0x1,0x50051,0x6,0x19e,0x1cb,0x2,0x7000c,0x6,0x1ab, + 0x1,0x28,0x19c,0x19e,0x50051,0x6,0x1a1,0x1cb,0x0,0x7000c,0x6,0x1b0, + 0x1,0x28,0x1a1,0x1ab,0x50083,0x6,0x1a3,0x73,0x1b0,0x7000c,0x6,0x1b5, + 0x1,0x28,0x7a,0x1a3,0x60050,0x1b,0x1a5,0x1b5,0x1b5,0x1b5,0x50088,0x1b, + 0x1a6,0x1cb,0x1a5,0x200f9,0xbf,0x200f8,0xbf,0x700f5,0x1b,0x1cd,0x1ca,0xb4, + 0x182,0xbe,0x700f5,0x1b,0x1cc,0x1cb,0xb4,0x1a6,0xbe,0x50083,0x1b,0xca, + 0x1cc,0x1cd,0x6000c,0x1b,0xcb,0x1,0x4,0xca,0x500c7,0x14,0xcd,0x121, + 0x9d,0x500ab,0xb1,0xce,0xcd,0x63,0x300f7,0xd1,0x0,0x400fa,0xce,0xd0, + 0xda,0x200f8,0xd0,0x50051,0x6,0xd3,0xcb,0x0,0x50051,0x6,0xd5,0xcb, + 0x1,0x50051,0x6,0xd7,0xcb,0x2,0x7000c,0x6,0xd8,0x1,0x28,0xd5, + 0xd7,0x7000c,0x6,0xd9,0x1,0x28,0xd3,0xd8,0x200f9,0xd1,0x200f8,0xda, + 0x6000c,0x6,0xdc,0x1,0x42,0xcb,0x200f9,0xd1,0x200f8,0xd1,0x700f5,0x6, + 0x1ce,0xd9,0xd0,0xdc,0xda,0x50041,0x38,0x1bc,0x36,0x37,0x4003d,0x6, + 0x1bd,0x1bc,0x50085,0x6,0xe0,0x1ce,0x1bd,0x500c7,0x14,0xe3,0x121,0xe2, + 0x500ab,0xb1,0xe4,0xe3,0x63,0x300f7,0xe7,0x0,0x400fa,0xe4,0xe6,0xf1, + 0x200f8,0xe6,0x50041,0x38,0x1c4,0x36,0x3d,0x4003d,0x6,0x1c5,0x1c4,0x500b8, + 0xb1,0xea,0xe0,0x1c5,0x300f7,0xed,0x0,0x400fa,0xea,0xec,0xee,0x200f8, + 0xec,0x200f9,0xed,0x200f8,0xee,0x50041,0x38,0x1c8,0x36,0x42,0x4003d,0x6, + 0x1c9,0x1c8,0x200f9,0xed,0x200f8,0xed,0x700f5,0x6,0x1cf,0x60,0xec,0x1c9, + 0xee,0x200f9,0xe7,0x200f8,0xf1,0x200f9,0xe7,0x200f8,0xe7,0x700f5,0x6,0x1d0, + 0x1cf,0xed,0xe0,0xf1,0x4003d,0xf4,0xf7,0xf6,0x70050,0x52,0xfb,0x1d0, + 0x60,0x60,0x60,0x40063,0xf7,0xac,0xfb,0x100fd,0x10038, +}; +static const char *fu1_autogen_reactive_pass_0_cb_names[] = {"cbGenerateReactive"}; +static const uint32_t fu1_autogen_reactive_pass_0_cb_bind[] = {5}; +static const uint32_t fu1_autogen_reactive_pass_0_cb_count[] = {1}; +static const uint32_t fu1_autogen_reactive_pass_0_cb_space[] = {0}; +static const char *fu1_autogen_reactive_pass_0_srv_tex_names[] = {"r_input_opaque_only", "r_input_color_jittered"}; +static const uint32_t fu1_autogen_reactive_pass_0_srv_tex_bind[] = {0, 1}; +static const uint32_t fu1_autogen_reactive_pass_0_srv_tex_count[] = {1, 1}; +static const uint32_t fu1_autogen_reactive_pass_0_srv_tex_space[] = {0, 0}; +static const char *fu1_autogen_reactive_pass_0_uav_tex_names[] = {"rw_output_autoreactive"}; +static const uint32_t fu1_autogen_reactive_pass_0_uav_tex_bind[] = {2}; +static const uint32_t fu1_autogen_reactive_pass_0_uav_tex_count[] = {1}; +static const uint32_t fu1_autogen_reactive_pass_0_uav_tex_space[] = {0}; + +// [16-bit floats][FfxFsr3UpscalerPass] (an empty blob: no shader) +static const FfxShaderBlob ffx_fu_blobs[2][12] = { + { + {(const uint8_t *)fu0_prepare_inputs_pass_0_spv, sizeof fu0_prepare_inputs_pass_0_spv, 1, 3, 5, 0, 0, 0, 0, fu0_prepare_inputs_pass_0_cb_names, fu0_prepare_inputs_pass_0_cb_bind, fu0_prepare_inputs_pass_0_cb_count, fu0_prepare_inputs_pass_0_cb_space, fu0_prepare_inputs_pass_0_srv_tex_names, fu0_prepare_inputs_pass_0_srv_tex_bind, fu0_prepare_inputs_pass_0_srv_tex_count, fu0_prepare_inputs_pass_0_srv_tex_space, fu0_prepare_inputs_pass_0_uav_tex_names, fu0_prepare_inputs_pass_0_uav_tex_bind, fu0_prepare_inputs_pass_0_uav_tex_count, fu0_prepare_inputs_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + {(const uint8_t *)fu0_luma_pyramid_pass_0_spv, sizeof fu0_luma_pyramid_pass_0_spv, 2, 2, 4, 0, 0, 0, 0, fu0_luma_pyramid_pass_0_cb_names, fu0_luma_pyramid_pass_0_cb_bind, fu0_luma_pyramid_pass_0_cb_count, fu0_luma_pyramid_pass_0_cb_space, fu0_luma_pyramid_pass_0_srv_tex_names, fu0_luma_pyramid_pass_0_srv_tex_bind, fu0_luma_pyramid_pass_0_srv_tex_count, fu0_luma_pyramid_pass_0_srv_tex_space, fu0_luma_pyramid_pass_0_uav_tex_names, fu0_luma_pyramid_pass_0_uav_tex_bind, fu0_luma_pyramid_pass_0_uav_tex_count, fu0_luma_pyramid_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + {(const uint8_t *)fu0_shading_change_pyramid_pass_0_spv, sizeof fu0_shading_change_pyramid_pass_0_spv, 2, 4, 7, 0, 0, 0, 0, fu0_shading_change_pyramid_pass_0_cb_names, fu0_shading_change_pyramid_pass_0_cb_bind, fu0_shading_change_pyramid_pass_0_cb_count, fu0_shading_change_pyramid_pass_0_cb_space, fu0_shading_change_pyramid_pass_0_srv_tex_names, fu0_shading_change_pyramid_pass_0_srv_tex_bind, fu0_shading_change_pyramid_pass_0_srv_tex_count, fu0_shading_change_pyramid_pass_0_srv_tex_space, fu0_shading_change_pyramid_pass_0_uav_tex_names, fu0_shading_change_pyramid_pass_0_uav_tex_bind, fu0_shading_change_pyramid_pass_0_uav_tex_count, fu0_shading_change_pyramid_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + {(const uint8_t *)fu0_shading_change_pass_0_spv, sizeof fu0_shading_change_pass_0_spv, 1, 1, 1, 0, 0, 1, 0, fu0_shading_change_pass_0_cb_names, fu0_shading_change_pass_0_cb_bind, fu0_shading_change_pass_0_cb_count, fu0_shading_change_pass_0_cb_space, fu0_shading_change_pass_0_srv_tex_names, fu0_shading_change_pass_0_srv_tex_bind, fu0_shading_change_pass_0_srv_tex_count, fu0_shading_change_pass_0_srv_tex_space, fu0_shading_change_pass_0_uav_tex_names, fu0_shading_change_pass_0_uav_tex_bind, fu0_shading_change_pass_0_uav_tex_count, fu0_shading_change_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, fu0_shading_change_pass_0_sampler_names, fu0_shading_change_pass_0_sampler_bind, fu0_shading_change_pass_0_sampler_count, fu0_shading_change_pass_0_sampler_space, 0, 0, 0, 0}, + {(const uint8_t *)fu0_prepare_reactivity_pass_0_spv, sizeof fu0_prepare_reactivity_pass_0_spv, 1, 9, 3, 0, 0, 1, 0, fu0_prepare_reactivity_pass_0_cb_names, fu0_prepare_reactivity_pass_0_cb_bind, fu0_prepare_reactivity_pass_0_cb_count, fu0_prepare_reactivity_pass_0_cb_space, fu0_prepare_reactivity_pass_0_srv_tex_names, fu0_prepare_reactivity_pass_0_srv_tex_bind, fu0_prepare_reactivity_pass_0_srv_tex_count, fu0_prepare_reactivity_pass_0_srv_tex_space, fu0_prepare_reactivity_pass_0_uav_tex_names, fu0_prepare_reactivity_pass_0_uav_tex_bind, fu0_prepare_reactivity_pass_0_uav_tex_count, fu0_prepare_reactivity_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, fu0_prepare_reactivity_pass_0_sampler_names, fu0_prepare_reactivity_pass_0_sampler_bind, fu0_prepare_reactivity_pass_0_sampler_count, fu0_prepare_reactivity_pass_0_sampler_space, 0, 0, 0, 0}, + {(const uint8_t *)fu0_luma_instability_pass_0_spv, sizeof fu0_luma_instability_pass_0_spv, 1, 5, 2, 0, 0, 1, 0, fu0_luma_instability_pass_0_cb_names, fu0_luma_instability_pass_0_cb_bind, fu0_luma_instability_pass_0_cb_count, fu0_luma_instability_pass_0_cb_space, fu0_luma_instability_pass_0_srv_tex_names, fu0_luma_instability_pass_0_srv_tex_bind, fu0_luma_instability_pass_0_srv_tex_count, fu0_luma_instability_pass_0_srv_tex_space, fu0_luma_instability_pass_0_uav_tex_names, fu0_luma_instability_pass_0_uav_tex_bind, fu0_luma_instability_pass_0_uav_tex_count, fu0_luma_instability_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, fu0_luma_instability_pass_0_sampler_names, fu0_luma_instability_pass_0_sampler_bind, fu0_luma_instability_pass_0_sampler_count, fu0_luma_instability_pass_0_sampler_space, 0, 0, 0, 0}, + {(const uint8_t *)fu0_accumulate_pass_0_spv, sizeof fu0_accumulate_pass_0_spv, 1, 7, 3, 0, 0, 1, 0, fu0_accumulate_pass_0_cb_names, fu0_accumulate_pass_0_cb_bind, fu0_accumulate_pass_0_cb_count, fu0_accumulate_pass_0_cb_space, fu0_accumulate_pass_0_srv_tex_names, fu0_accumulate_pass_0_srv_tex_bind, fu0_accumulate_pass_0_srv_tex_count, fu0_accumulate_pass_0_srv_tex_space, fu0_accumulate_pass_0_uav_tex_names, fu0_accumulate_pass_0_uav_tex_bind, fu0_accumulate_pass_0_uav_tex_count, fu0_accumulate_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, fu0_accumulate_pass_0_sampler_names, fu0_accumulate_pass_0_sampler_bind, fu0_accumulate_pass_0_sampler_count, fu0_accumulate_pass_0_sampler_space, 0, 0, 0, 0}, + {(const uint8_t *)fu0_accumulate_pass_1_spv, sizeof fu0_accumulate_pass_1_spv, 1, 7, 2, 0, 0, 1, 0, fu0_accumulate_pass_1_cb_names, fu0_accumulate_pass_1_cb_bind, fu0_accumulate_pass_1_cb_count, fu0_accumulate_pass_1_cb_space, fu0_accumulate_pass_1_srv_tex_names, fu0_accumulate_pass_1_srv_tex_bind, fu0_accumulate_pass_1_srv_tex_count, fu0_accumulate_pass_1_srv_tex_space, fu0_accumulate_pass_1_uav_tex_names, fu0_accumulate_pass_1_uav_tex_bind, fu0_accumulate_pass_1_uav_tex_count, fu0_accumulate_pass_1_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, fu0_accumulate_pass_1_sampler_names, fu0_accumulate_pass_1_sampler_bind, fu0_accumulate_pass_1_sampler_count, fu0_accumulate_pass_1_sampler_space, 0, 0, 0, 0}, + {(const uint8_t *)fu0_rcas_pass_0_spv, sizeof fu0_rcas_pass_0_spv, 1, 2, 1, 0, 0, 0, 0, fu0_rcas_pass_0_cb_names, fu0_rcas_pass_0_cb_bind, fu0_rcas_pass_0_cb_count, fu0_rcas_pass_0_cb_space, fu0_rcas_pass_0_srv_tex_names, fu0_rcas_pass_0_srv_tex_bind, fu0_rcas_pass_0_srv_tex_count, fu0_rcas_pass_0_srv_tex_space, fu0_rcas_pass_0_uav_tex_names, fu0_rcas_pass_0_uav_tex_bind, fu0_rcas_pass_0_uav_tex_count, fu0_rcas_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + {(const uint8_t *)fu0_debug_view_pass_0_spv, sizeof fu0_debug_view_pass_0_spv, 1, 4, 1, 0, 0, 1, 0, fu0_debug_view_pass_0_cb_names, fu0_debug_view_pass_0_cb_bind, fu0_debug_view_pass_0_cb_count, fu0_debug_view_pass_0_cb_space, fu0_debug_view_pass_0_srv_tex_names, fu0_debug_view_pass_0_srv_tex_bind, fu0_debug_view_pass_0_srv_tex_count, fu0_debug_view_pass_0_srv_tex_space, fu0_debug_view_pass_0_uav_tex_names, fu0_debug_view_pass_0_uav_tex_bind, fu0_debug_view_pass_0_uav_tex_count, fu0_debug_view_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, fu0_debug_view_pass_0_sampler_names, fu0_debug_view_pass_0_sampler_bind, fu0_debug_view_pass_0_sampler_count, fu0_debug_view_pass_0_sampler_space, 0, 0, 0, 0}, + {(const uint8_t *)fu0_autogen_reactive_pass_0_spv, sizeof fu0_autogen_reactive_pass_0_spv, 1, 2, 1, 0, 0, 0, 0, fu0_autogen_reactive_pass_0_cb_names, fu0_autogen_reactive_pass_0_cb_bind, fu0_autogen_reactive_pass_0_cb_count, fu0_autogen_reactive_pass_0_cb_space, fu0_autogen_reactive_pass_0_srv_tex_names, fu0_autogen_reactive_pass_0_srv_tex_bind, fu0_autogen_reactive_pass_0_srv_tex_count, fu0_autogen_reactive_pass_0_srv_tex_space, fu0_autogen_reactive_pass_0_uav_tex_names, fu0_autogen_reactive_pass_0_uav_tex_bind, fu0_autogen_reactive_pass_0_uav_tex_count, fu0_autogen_reactive_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + {}, + }, + { + {(const uint8_t *)fu1_prepare_inputs_pass_0_spv, sizeof fu1_prepare_inputs_pass_0_spv, 1, 3, 5, 0, 0, 0, 0, fu1_prepare_inputs_pass_0_cb_names, fu1_prepare_inputs_pass_0_cb_bind, fu1_prepare_inputs_pass_0_cb_count, fu1_prepare_inputs_pass_0_cb_space, fu1_prepare_inputs_pass_0_srv_tex_names, fu1_prepare_inputs_pass_0_srv_tex_bind, fu1_prepare_inputs_pass_0_srv_tex_count, fu1_prepare_inputs_pass_0_srv_tex_space, fu1_prepare_inputs_pass_0_uav_tex_names, fu1_prepare_inputs_pass_0_uav_tex_bind, fu1_prepare_inputs_pass_0_uav_tex_count, fu1_prepare_inputs_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + {(const uint8_t *)fu1_luma_pyramid_pass_0_spv, sizeof fu1_luma_pyramid_pass_0_spv, 1, 0, 1, 0, 0, 0, 0, fu1_luma_pyramid_pass_0_cb_names, fu1_luma_pyramid_pass_0_cb_bind, fu1_luma_pyramid_pass_0_cb_count, fu1_luma_pyramid_pass_0_cb_space, 0, 0, 0, 0, fu1_luma_pyramid_pass_0_uav_tex_names, fu1_luma_pyramid_pass_0_uav_tex_bind, fu1_luma_pyramid_pass_0_uav_tex_count, fu1_luma_pyramid_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + {(const uint8_t *)fu1_shading_change_pyramid_pass_0_spv, sizeof fu1_shading_change_pyramid_pass_0_spv, 1, 0, 1, 0, 0, 0, 0, fu1_shading_change_pyramid_pass_0_cb_names, fu1_shading_change_pyramid_pass_0_cb_bind, fu1_shading_change_pyramid_pass_0_cb_count, fu1_shading_change_pyramid_pass_0_cb_space, 0, 0, 0, 0, fu1_shading_change_pyramid_pass_0_uav_tex_names, fu1_shading_change_pyramid_pass_0_uav_tex_bind, fu1_shading_change_pyramid_pass_0_uav_tex_count, fu1_shading_change_pyramid_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + {(const uint8_t *)fu1_shading_change_pass_0_spv, sizeof fu1_shading_change_pass_0_spv, 1, 1, 1, 0, 0, 1, 0, fu1_shading_change_pass_0_cb_names, fu1_shading_change_pass_0_cb_bind, fu1_shading_change_pass_0_cb_count, fu1_shading_change_pass_0_cb_space, fu1_shading_change_pass_0_srv_tex_names, fu1_shading_change_pass_0_srv_tex_bind, fu1_shading_change_pass_0_srv_tex_count, fu1_shading_change_pass_0_srv_tex_space, fu1_shading_change_pass_0_uav_tex_names, fu1_shading_change_pass_0_uav_tex_bind, fu1_shading_change_pass_0_uav_tex_count, fu1_shading_change_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, fu1_shading_change_pass_0_sampler_names, fu1_shading_change_pass_0_sampler_bind, fu1_shading_change_pass_0_sampler_count, fu1_shading_change_pass_0_sampler_space, 0, 0, 0, 0}, + {(const uint8_t *)fu1_prepare_reactivity_pass_0_spv, sizeof fu1_prepare_reactivity_pass_0_spv, 1, 9, 3, 0, 0, 1, 0, fu1_prepare_reactivity_pass_0_cb_names, fu1_prepare_reactivity_pass_0_cb_bind, fu1_prepare_reactivity_pass_0_cb_count, fu1_prepare_reactivity_pass_0_cb_space, fu1_prepare_reactivity_pass_0_srv_tex_names, fu1_prepare_reactivity_pass_0_srv_tex_bind, fu1_prepare_reactivity_pass_0_srv_tex_count, fu1_prepare_reactivity_pass_0_srv_tex_space, fu1_prepare_reactivity_pass_0_uav_tex_names, fu1_prepare_reactivity_pass_0_uav_tex_bind, fu1_prepare_reactivity_pass_0_uav_tex_count, fu1_prepare_reactivity_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, fu1_prepare_reactivity_pass_0_sampler_names, fu1_prepare_reactivity_pass_0_sampler_bind, fu1_prepare_reactivity_pass_0_sampler_count, fu1_prepare_reactivity_pass_0_sampler_space, 0, 0, 0, 0}, + {(const uint8_t *)fu1_luma_instability_pass_0_spv, sizeof fu1_luma_instability_pass_0_spv, 1, 5, 2, 0, 0, 1, 0, fu1_luma_instability_pass_0_cb_names, fu1_luma_instability_pass_0_cb_bind, fu1_luma_instability_pass_0_cb_count, fu1_luma_instability_pass_0_cb_space, fu1_luma_instability_pass_0_srv_tex_names, fu1_luma_instability_pass_0_srv_tex_bind, fu1_luma_instability_pass_0_srv_tex_count, fu1_luma_instability_pass_0_srv_tex_space, fu1_luma_instability_pass_0_uav_tex_names, fu1_luma_instability_pass_0_uav_tex_bind, fu1_luma_instability_pass_0_uav_tex_count, fu1_luma_instability_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, fu1_luma_instability_pass_0_sampler_names, fu1_luma_instability_pass_0_sampler_bind, fu1_luma_instability_pass_0_sampler_count, fu1_luma_instability_pass_0_sampler_space, 0, 0, 0, 0}, + {(const uint8_t *)fu1_accumulate_pass_0_spv, sizeof fu1_accumulate_pass_0_spv, 1, 7, 3, 0, 0, 1, 0, fu1_accumulate_pass_0_cb_names, fu1_accumulate_pass_0_cb_bind, fu1_accumulate_pass_0_cb_count, fu1_accumulate_pass_0_cb_space, fu1_accumulate_pass_0_srv_tex_names, fu1_accumulate_pass_0_srv_tex_bind, fu1_accumulate_pass_0_srv_tex_count, fu1_accumulate_pass_0_srv_tex_space, fu1_accumulate_pass_0_uav_tex_names, fu1_accumulate_pass_0_uav_tex_bind, fu1_accumulate_pass_0_uav_tex_count, fu1_accumulate_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, fu1_accumulate_pass_0_sampler_names, fu1_accumulate_pass_0_sampler_bind, fu1_accumulate_pass_0_sampler_count, fu1_accumulate_pass_0_sampler_space, 0, 0, 0, 0}, + {(const uint8_t *)fu1_accumulate_pass_1_spv, sizeof fu1_accumulate_pass_1_spv, 1, 7, 2, 0, 0, 1, 0, fu1_accumulate_pass_1_cb_names, fu1_accumulate_pass_1_cb_bind, fu1_accumulate_pass_1_cb_count, fu1_accumulate_pass_1_cb_space, fu1_accumulate_pass_1_srv_tex_names, fu1_accumulate_pass_1_srv_tex_bind, fu1_accumulate_pass_1_srv_tex_count, fu1_accumulate_pass_1_srv_tex_space, fu1_accumulate_pass_1_uav_tex_names, fu1_accumulate_pass_1_uav_tex_bind, fu1_accumulate_pass_1_uav_tex_count, fu1_accumulate_pass_1_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, fu1_accumulate_pass_1_sampler_names, fu1_accumulate_pass_1_sampler_bind, fu1_accumulate_pass_1_sampler_count, fu1_accumulate_pass_1_sampler_space, 0, 0, 0, 0}, + {(const uint8_t *)fu1_rcas_pass_0_spv, sizeof fu1_rcas_pass_0_spv, 1, 2, 1, 0, 0, 0, 0, fu1_rcas_pass_0_cb_names, fu1_rcas_pass_0_cb_bind, fu1_rcas_pass_0_cb_count, fu1_rcas_pass_0_cb_space, fu1_rcas_pass_0_srv_tex_names, fu1_rcas_pass_0_srv_tex_bind, fu1_rcas_pass_0_srv_tex_count, fu1_rcas_pass_0_srv_tex_space, fu1_rcas_pass_0_uav_tex_names, fu1_rcas_pass_0_uav_tex_bind, fu1_rcas_pass_0_uav_tex_count, fu1_rcas_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + {(const uint8_t *)fu1_debug_view_pass_0_spv, sizeof fu1_debug_view_pass_0_spv, 1, 4, 1, 0, 0, 1, 0, fu1_debug_view_pass_0_cb_names, fu1_debug_view_pass_0_cb_bind, fu1_debug_view_pass_0_cb_count, fu1_debug_view_pass_0_cb_space, fu1_debug_view_pass_0_srv_tex_names, fu1_debug_view_pass_0_srv_tex_bind, fu1_debug_view_pass_0_srv_tex_count, fu1_debug_view_pass_0_srv_tex_space, fu1_debug_view_pass_0_uav_tex_names, fu1_debug_view_pass_0_uav_tex_bind, fu1_debug_view_pass_0_uav_tex_count, fu1_debug_view_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, fu1_debug_view_pass_0_sampler_names, fu1_debug_view_pass_0_sampler_bind, fu1_debug_view_pass_0_sampler_count, fu1_debug_view_pass_0_sampler_space, 0, 0, 0, 0}, + {(const uint8_t *)fu1_autogen_reactive_pass_0_spv, sizeof fu1_autogen_reactive_pass_0_spv, 1, 2, 1, 0, 0, 0, 0, fu1_autogen_reactive_pass_0_cb_names, fu1_autogen_reactive_pass_0_cb_bind, fu1_autogen_reactive_pass_0_cb_count, fu1_autogen_reactive_pass_0_cb_space, fu1_autogen_reactive_pass_0_srv_tex_names, fu1_autogen_reactive_pass_0_srv_tex_bind, fu1_autogen_reactive_pass_0_srv_tex_count, fu1_autogen_reactive_pass_0_srv_tex_space, fu1_autogen_reactive_pass_0_uav_tex_names, fu1_autogen_reactive_pass_0_uav_tex_bind, fu1_autogen_reactive_pass_0_uav_tex_count, fu1_autogen_reactive_pass_0_uav_tex_space, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + {}, + }, +}; diff --git a/runtime/ui/menu.cpp b/runtime/ui/menu.cpp index cb52199b..0513c7ba 100644 --- a/runtime/ui/menu.cpp +++ b/runtime/ui/menu.cpp @@ -616,6 +616,34 @@ static void row_hud_width(void) { opt_choice_list("TOTK_HUD_WIDTH", UI_MENU_HUD_WIDTH, vals, names, n, UI_MENU_HUD_WIDTH_DESC); } +// The 3D scene upscaler (vk_dlaa.c): off, NVIDIA DLSS or AMD FSR 3.1. An engine that cannot run here is left out of +// the steps, and the note under the value says why; a totk.ini that names it anyway shows it, with the same note. +// Returns the value the settings name ("off", "dlss", "fsr3"; without scene_upscaler, dlaa = 1 is "dlss"). +static const char *row_scene_upscaler(void) { + static const char *const all[] = {"off", "dlss", "fsr3"}; + static const int engines[] = {UPSCALER_OFF, UPSCALER_DLSS, UPSCALER_FSR3}; + static const UiTextId ids[] = {UI_MENU_SCENE_UPSCALER_OFF, UI_MENU_SCENE_UPSCALER_DLSS, UI_MENU_SCENE_UPSCALER_FSR3}; + const char *now = cfg_scene_upscaler(); + const char *vals[3], *names[3]; + static char note[256]; + note[0] = 0; + int n = 0, cur = -1; + for (int i = 0; i < 3; i++) { + int why = vk_upscaler_missing(engines[i]); + if (why) { + UiTextId t = why == UPSCALER_MISSING_DLL ? UI_MENU_SCENE_UPSCALER_NO_DLSS_DLL : UI_MENU_SCENE_UPSCALER_NO_DLSS_GPU; + size_t k = strlen(note); + snprintf(note + k, sizeof note - k, "%s%s", k ? "; " : "", menu_text(t)); + } + if (why && strcmp(now, all[i])) continue; + if (!strcmp(now, all[i])) cur = n; + vals[n] = all[i], names[n] = menu_text(ids[i]), n++; + } + opt_choice_list("TOTK_SCENE_UPSCALER", UI_MENU_SCENE_UPSCALER, vals, names, n, UI_MENU_SCENE_UPSCALER_DESC, cur, + note[0] ? note : nullptr); + return cfg_scene_upscaler(); +} + static void row_render_scale(void) { static const char *const vals[] = {"game", "50", "67", "75", "100", "125", "150", "200"}; enum { N = sizeof vals / sizeof *vals }; @@ -793,17 +821,21 @@ static void tab_screen(float scale) { opt_toggle("TOTK_LOD_STEADY", UI_MENU_LOD_STEADY, UI_MENU_LOD_STEADY_DESC); opt_slider("TOTK_PCSS", UI_MENU_PCSS, 0, 200, UI_MENU_PCSS_DESC, 10, "%.0f %%"); opt_slider("TOTK_CONTACT_SHADOWS", UI_MENU_CONTACT_SHADOWS, 0, 100, UI_MENU_CONTACT_SHADOWS_DESC, 10, "%.0f %%"); - opt_toggle("TOTK_DLAA", UI_MENU_DLAA, UI_MENU_DLAA_DESC); - static const UiTextId dlss[] = {UI_MENU_DLSS_DLAA, UI_MENU_DLSS_QUALITY, UI_MENU_DLSS_BALANCED, - UI_MENU_DLSS_PERFORMANCE, UI_MENU_DLSS_ULTRA}; - opt_choice("TOTK_DLSS", UI_MENU_DLSS, dlss, 5, UI_MENU_DLSS_DESC); - static const UiTextId preset[] = {UI_MENU_DLSS_PRESET_DEFAULT, UI_MENU_DLSS_PRESET_K, UI_MENU_DLSS_PRESET_J}; - opt_choice("TOTK_DLSS_PRESET", UI_MENU_DLSS_PRESET, preset, 3, UI_MENU_DLSS_PRESET_DESC); - static const UiTextId chars[] = {UI_MENU_DLSS_CHARS_OFF, UI_MENU_DLSS_CHARS_LIGHT, UI_MENU_DLSS_CHARS_MEDIUM, - UI_MENU_DLSS_CHARS_FULL}; - opt_choice("TOTK_DLSS_CHAR_MASK", UI_MENU_DLSS_CHARS, chars, 4, UI_MENU_DLSS_CHARS_DESC); - opt_toggle("TOTK_DLSS_FIXED_EXPOSURE", UI_MENU_DLSS_FIXED_EXPOSURE, UI_MENU_DLSS_FIXED_EXPOSURE_DESC); - opt_toggle("TOTK_DLAA_EFFECTS_AFTER", UI_MENU_DLAA_EFFECTS_AFTER, UI_MENU_DLAA_EFFECTS_AFTER_DESC); + const char *engine = row_scene_upscaler(); + if (strcmp(engine, "off")) { // the mode serves both engines + static const UiTextId dlss[] = {UI_MENU_DLSS_DLAA, UI_MENU_DLSS_QUALITY, UI_MENU_DLSS_BALANCED, + UI_MENU_DLSS_PERFORMANCE, UI_MENU_DLSS_ULTRA}; + opt_choice("TOTK_DLSS", UI_MENU_DLSS, dlss, 5, UI_MENU_DLSS_DESC); + } + if (!strcmp(engine, "dlss")) { // DLSS's model, its characters' mask and its other switches (FSR 3.1 has none) + static const UiTextId preset[] = {UI_MENU_DLSS_PRESET_DEFAULT, UI_MENU_DLSS_PRESET_K, UI_MENU_DLSS_PRESET_J}; + opt_choice("TOTK_DLSS_PRESET", UI_MENU_DLSS_PRESET, preset, 3, UI_MENU_DLSS_PRESET_DESC); + static const UiTextId chars[] = {UI_MENU_DLSS_CHARS_OFF, UI_MENU_DLSS_CHARS_LIGHT, UI_MENU_DLSS_CHARS_MEDIUM, + UI_MENU_DLSS_CHARS_FULL}; + opt_choice("TOTK_DLSS_CHAR_MASK", UI_MENU_DLSS_CHARS, chars, 4, UI_MENU_DLSS_CHARS_DESC); + opt_toggle("TOTK_DLSS_FIXED_EXPOSURE", UI_MENU_DLSS_FIXED_EXPOSURE, UI_MENU_DLSS_FIXED_EXPOSURE_DESC); + opt_toggle("TOTK_DLAA_EFFECTS_AFTER", UI_MENU_DLAA_EFFECTS_AFTER, UI_MENU_DLAA_EFFECTS_AFTER_DESC); + } static const UiTextId reflex[] = {UI_MENU_REFLEX_OFF, UI_MENU_REFLEX_ON, UI_MENU_REFLEX_BOOST}; opt_choice("TOTK_REFLEX", UI_MENU_REFLEX, reflex, 3, UI_MENU_REFLEX_DESC); opt_toggle("TOTK_FXAA", UI_MENU_FXAA, UI_MENU_FXAA_DESC); @@ -1708,13 +1740,14 @@ static void perf_label(UiTextId label, const ImVec4 &c) { static float perf_gb(float mb) { return mb < 0 ? -1 : mb / 1024; } -// The picture lines: the window, the game image the present shows and the 3D scene it holds (resolution.c), how the -// present scales the image to the window (gfx_present.c, the last present), the frame limit and the presentation mode -// in use. +// The picture lines: the window, the game image the present shows and the 3D scene it holds (resolution.c), the +// temporal upscaler that scales the scene (vk_dlaa.c) with its mode, how the present scales the image to the window +// (gfx_present.c, the last present), the frame limit, the presentation mode in use and, with frame generation, the +// pictures shown a second. static void perf_picture(const MenuTarget *t, const ImVec4 &c) { unsigned out[2], scene[2]; res_sizes(out, scene); - char v[7][64]; + char v[8][64]; snprintf(v[0], sizeof v[0], menu_text(UI_MENU_OV_FMT_SIZE), t->width, t->height); snprintf(v[1], sizeof v[1], menu_text(UI_MENU_OV_FMT_SIZE), (unsigned)t->image_w, (unsigned)t->image_h); snprintf(v[2], sizeof v[2], menu_text(UI_MENU_OV_FMT_SCENE), scene[0], scene[1], scene[0] * 100.0 / out[0]); @@ -1733,20 +1766,38 @@ static void perf_picture(const MenuTarget *t, const ImVec4 &c) { if (hz > 0) snprintf(v[4], sizeof v[4], menu_text(UI_MENU_OV_FPS), hz); const char *pm = present_name(gfx_window_present_mode()); snprintf(v[5], sizeof v[5], "%s", pm ? pm : menu_text(UI_MENU_OV_NONE)); + // the temporal upscaler that ran (vk_dlaa.c: it ran and has not failed) and its mode, after the scene it scales; the + // line is left out while none runs, so the overlay without one has the same lines as before the setting existed + int up = vk_upscaler_running(); + if (up) { + const char *m = cfg_value("TOTK_DLSS"); + UiTextId mt = !strcmp(m, "quality") ? UI_MENU_DLSS_QUALITY + : !strcmp(m, "balanced") ? UI_MENU_DLSS_BALANCED + : !strcmp(m, "performance") ? UI_MENU_DLSS_PERFORMANCE + : !strcmp(m, "ultra_performance") ? UI_MENU_DLSS_ULTRA + : UI_MENU_DLSS_DLAA; + snprintf(v[6], sizeof v[6], "%s, %s", + menu_text(up == UPSCALER_FSR3 ? UI_MENU_SCENE_UPSCALER_FSR3 : UI_MENU_SCENE_UPSCALER_DLSS), + menu_text(mt)); + } // with frame generation: the pictures shown a second, of which the FPS row above counts the ones the game drew - int n = 6; - if (g_shown_fps > 0) snprintf(v[n++], sizeof v[6], menu_text(UI_MENU_OV_FPS), g_shown_fps); - static const UiTextId labels[7] = {UI_MENU_OV_WINDOW, UI_MENU_OV_OUTPUT, UI_MENU_OV_SCENE, UI_MENU_OV_SCALING, - UI_MENU_OV_LIMIT, UI_MENU_OV_PRESENT, UI_MENU_OV_SHOWN}; + if (g_shown_fps > 0) snprintf(v[7], sizeof v[7], menu_text(UI_MENU_OV_FPS), g_shown_fps); + static const UiTextId labels[8] = {UI_MENU_OV_WINDOW, UI_MENU_OV_OUTPUT, UI_MENU_OV_SCENE, UI_MENU_OV_SCALING, + UI_MENU_OV_LIMIT, UI_MENU_OV_PRESENT, UI_MENU_OV_UPSCALER, UI_MENU_OV_SHOWN}; + int order[8], n = 0; + order[n++] = 0, order[n++] = 1, order[n++] = 2; + if (up) order[n++] = 6; + order[n++] = 3, order[n++] = 4, order[n++] = 5; + if (g_shown_fps > 0) order[n++] = 7; if (!ImGui::BeginTable("##perfp", 2, ImGuiTableFlags_SizingFixedFit)) return; float vw = 0; - for (int i = 0; i < n; i++) vw = fmaxf(vw, ImGui::CalcTextSize(v[i]).x); + for (int i = 0; i < n; i++) vw = fmaxf(vw, ImGui::CalcTextSize(v[order[i]]).x); ImGui::TableSetupColumn("##p0", ImGuiTableColumnFlags_WidthStretch); ImGui::TableSetupColumn("##p1", ImGuiTableColumnFlags_WidthFixed, vw); for (int i = 0; i < n; i++) { - perf_label(labels[i], c); + perf_label(labels[order[i]], c); ImGui::TableNextColumn(); - perf_right(v[i], false); + perf_right(v[order[i]], false); } ImGui::EndTable(); } diff --git a/runtime/ui_text.c b/runtime/ui_text.c index a3ade981..8c96fa3a 100644 --- a/runtime/ui_text.c +++ b/runtime/ui_text.c @@ -153,10 +153,6 @@ static const char *const text_en[UI_TEXT_COUNT] = { [UI_MENU_GRASS_RANGE_DESC] = "How far around the camera grass grows (the game's: 62.5 m). Higher keeps the " "grass in meadows further out instead of growing it in just in front of you; lower " "draws less of it. Takes effect at the next start.", - [UI_MENU_DLAA] = "NVIDIA DLSS / DLAA", - [UI_MENU_DLAA_DESC] = "NVIDIA DLSS for the 3D scene (NVIDIA RTX GPUs; " DLSS_FILE " next to " EXE_FILE "): smoother " - "edges and less shimmer. The HUD is not touched. The mode below sets the resolution it works " - "from. Takes effect after a restart.", [UI_MENU_DLSS_PRESET] = "DLSS model", [UI_MENU_DLSS_PRESET_DESC] = "Which DLSS model runs. Automatic follows NVIDIA's advice per mode: K for DLAA, Quality " "and Balanced, M for Performance, L for Ultra Performance. J: slightly less ghosting " @@ -170,11 +166,11 @@ static const char *const text_en[UI_TEXT_COUNT] = { "edges a little less smooth. Applies at once.", [UI_MENU_DLSS_CHARS_OFF] = "Off", [UI_MENU_DLSS_CHARS_LIGHT] = "Light", [UI_MENU_DLSS_CHARS_MEDIUM] = "Medium", [UI_MENU_DLSS_CHARS_FULL] = "Full", - [UI_MENU_DLSS] = "DLSS mode", - [UI_MENU_DLSS_DESC] = "DLAA draws the 3D scene at full resolution. Quality, Balanced, Performance and Ultra " - "Performance draw it at 67, 58, 50 and 33 % and let DLSS scale it up, which saves GPU time; " - "they replace the 3D render scale. Takes effect at once.", - [UI_MENU_DLSS_DLAA] = "DLAA (native)", [UI_MENU_DLSS_QUALITY] = "Quality", [UI_MENU_DLSS_BALANCED] = "Balanced", + [UI_MENU_DLSS] = "Upscaling mode", + [UI_MENU_DLSS_DESC] = "Native anti-aliases the 3D scene at full resolution. Quality, Balanced, Performance and Ultra " + "Performance draw it at 67, 58, 50 and 33 % and let the upscaler (DLSS or FSR 3.1) scale it " + "up, which saves GPU time; they replace the 3D render scale. Takes effect at once.", + [UI_MENU_DLSS_DLAA] = "Native", [UI_MENU_DLSS_QUALITY] = "Quality", [UI_MENU_DLSS_BALANCED] = "Balanced", [UI_MENU_DLSS_PERFORMANCE] = "Performance", [UI_MENU_DLSS_ULTRA] = "Ultra Performance", [UI_MENU_FXAA] = "Game anti-aliasing (FXAA)", [UI_MENU_FXAA_DESC] = "The game's own FXAA edge smoothing. It blurs fine detail a little; with DLAA on it is not needed.", @@ -183,6 +179,16 @@ static const char *const text_en[UI_TEXT_COUNT] = { [UI_MENU_REFLEX_OFF] = "Off", [UI_MENU_REFLEX_ON] = "On", [UI_MENU_REFLEX_BOOST] = "On + Boost", + [UI_MENU_SCENE_UPSCALER] = "3D scene upscaler", + [UI_MENU_SCENE_UPSCALER_DESC] = "A temporal upscaler for the 3D scene: smoother edges and less shimmer, and in a mode below Native it draws " + "the scene smaller and scales it up, which saves GPU time. NVIDIA DLSS needs an NVIDIA " + "RTX GPU and " DLSS_FILE " next to " EXE_FILE "; AMD FSR 3.1 runs on any GPU. Off keeps " + "the game's own scaling and FXAA. The HUD is not touched; the upscaler and sharpness " + "above still fit the game image to the window. Takes effect after a restart.", + [UI_MENU_SCENE_UPSCALER_OFF] = "Off", [UI_MENU_SCENE_UPSCALER_DLSS] = "NVIDIA DLSS", + [UI_MENU_SCENE_UPSCALER_FSR3] = "AMD FSR 3.1", + [UI_MENU_SCENE_UPSCALER_NO_DLSS_GPU] = "DLSS: needs an NVIDIA RTX GPU", + [UI_MENU_SCENE_UPSCALER_NO_DLSS_DLL] = "DLSS: " DLSS_FILE " is missing", [UI_MENU_FPS_LIMIT] = "Frame rate limit", [UI_MENU_FPS_LIMIT_DESC] = "The most frames per second the game draws. Above 60 is experimental and needs Game speed " @@ -605,6 +611,7 @@ static const char *const text_en[UI_TEXT_COUNT] = { [UI_MENU_OV_FMT_MHZ] = "%.0f MHz", [UI_MENU_OV_FMT_GB] = "%.1f GB", [UI_MENU_OV_FMT_GB_OF] = "/ %.1f GB", [UI_MENU_OV_GAME_GB] = "game %.1f GB", [UI_MENU_OV_FMT_MS] = "%.2f ms", [UI_MENU_OV_PER_FRAME] = "%.1f per frame", [UI_MENU_OV_WINDOW] = "Window", [UI_MENU_OV_OUTPUT] = "Game image", [UI_MENU_OV_SCENE] = "3D scene", + [UI_MENU_OV_UPSCALER] = "3D upscaler", [UI_MENU_OV_SCALING] = "Scaling", [UI_MENU_OV_LIMIT] = "Frame limit", [UI_MENU_OV_PRESENT] = "Presentation", [UI_MENU_OV_SHOWN] = "Shown", [UI_MENU_OV_FMT_SIZE] = "%ux%u", [UI_MENU_OV_FMT_SCENE] = "%ux%u, %.0f%%", [UI_MENU_OV_FMT_FSR] = "AMD FSR 1, sharpness %d%%", [UI_MENU_OV_SCALE_NONE] = "none (1:1)", @@ -788,10 +795,6 @@ static const char *const text_ru[UI_TEXT_COUNT] = { [UI_MENU_GRASS_RANGE_DESC] = "Как далеко вокруг камеры растёт трава (в игре 62,5 м). Выше: трава на лугах видна " "дальше и не вырастает прямо перед вами; ниже: травы меньше. Действует после " "перезапуска.", - [UI_MENU_DLAA] = "NVIDIA DLSS / DLAA", - [UI_MENU_DLAA_DESC] = "NVIDIA DLSS для 3D-сцены (видеокарты NVIDIA RTX; " DLSS_FILE " рядом с " EXE_FILE "): ровнее " - "края и меньше мерцания. Интерфейс не затрагивается. Режим ниже задаёт разрешение, с которым он " - "работает. Действует после перезапуска.", [UI_MENU_DLSS_PRESET] = "Модель DLSS", [UI_MENU_DLSS_PRESET_DESC] = "Какая модель DLSS работает. «Автоматически» следует совету NVIDIA для каждого режима: K " "для DLAA, «Качества» и «Баланса», M для «Производительности», L для «Макс. " @@ -805,11 +808,12 @@ static const char *const text_ru[UI_TEXT_COUNT] = { "гладкие края. Действует сразу.", [UI_MENU_DLSS_CHARS_OFF] = "Выкл.", [UI_MENU_DLSS_CHARS_LIGHT] = "Слабо", [UI_MENU_DLSS_CHARS_MEDIUM] = "Средне", [UI_MENU_DLSS_CHARS_FULL] = "Полностью", - [UI_MENU_DLSS] = "Режим DLSS", - [UI_MENU_DLSS_DESC] = "DLAA рисует 3D-сцену в полном разрешении. «Качество», «Баланс», «Производительность» и " - "«Макс. производительность» рисуют её в 67, 58, 50 и 33 % и масштабируют через DLSS, что " - "экономит время видеокарты; они заменяют масштаб 3D-отрисовки. Действует сразу.", - [UI_MENU_DLSS_DLAA] = "DLAA (родное)", [UI_MENU_DLSS_QUALITY] = "Качество", [UI_MENU_DLSS_BALANCED] = "Баланс", + [UI_MENU_DLSS] = "Режим апскейлера", + [UI_MENU_DLSS_DESC] = "«Родное» сглаживает 3D-сцену в полном разрешении. «Качество», «Баланс», «Производительность» и " + "«Макс. производительность» рисуют её в 67, 58, 50 и 33 % и масштабируют апскейлером (DLSS " + "или FSR 3.1), что экономит время видеокарты; они заменяют масштаб 3D-отрисовки. Действует " + "сразу.", + [UI_MENU_DLSS_DLAA] = "Родное", [UI_MENU_DLSS_QUALITY] = "Качество", [UI_MENU_DLSS_BALANCED] = "Баланс", [UI_MENU_DLSS_PERFORMANCE] = "Производительность", [UI_MENU_DLSS_ULTRA] = "Макс. производительность", [UI_MENU_FXAA] = "Сглаживание игры (FXAA)", [UI_MENU_FXAA_DESC] = "Собственное сглаживание FXAA. Слегка размывает мелкие детали; с DLAA оно не нужно.", @@ -818,6 +822,17 @@ static const char *const text_ru[UI_TEXT_COUNT] = { [UI_MENU_REFLEX_OFF] = "Выкл", [UI_MENU_REFLEX_ON] = "Вкл", [UI_MENU_REFLEX_BOOST] = "Вкл + Ускорение", + [UI_MENU_SCENE_UPSCALER] = "Апскейлер 3D-сцены", + [UI_MENU_SCENE_UPSCALER_DESC] = "Временной апскейлер для 3D-сцены: ровнее края и меньше мерцания, а в режимах ниже «Родного» он " + "рисует сцену меньше и увеличивает её, что экономит время видеокарты. NVIDIA DLSS " + "нужна видеокарта NVIDIA RTX и " DLSS_FILE " рядом с " EXE_FILE "; AMD FSR 3.1 " + "работает на любой видеокарте. «Выкл» оставляет собственное масштабирование игры и " + "FXAA. Интерфейс не затрагивается; масштабирование и резкость выше по-прежнему " + "подгоняют изображение игры под окно. Действует после перезапуска.", + [UI_MENU_SCENE_UPSCALER_OFF] = "Выкл", [UI_MENU_SCENE_UPSCALER_DLSS] = "NVIDIA DLSS", + [UI_MENU_SCENE_UPSCALER_FSR3] = "AMD FSR 3.1", + [UI_MENU_SCENE_UPSCALER_NO_DLSS_GPU] = "DLSS: нужна видеокарта NVIDIA RTX", + [UI_MENU_SCENE_UPSCALER_NO_DLSS_DLL] = "DLSS: нет " DLSS_FILE, [UI_MENU_FPS_LIMIT] = "Ограничение частоты кадров", [UI_MENU_FPS_LIMIT_DESC] = "Наибольшее число кадров в секунду. Выше 60 — экспериментальный режим, нужна «Скорость " @@ -1244,6 +1259,7 @@ static const char *const text_ru[UI_TEXT_COUNT] = { [UI_MENU_OV_FMT_MHZ] = "%.0f МГц", [UI_MENU_OV_FMT_GB] = "%.1f ГБ", [UI_MENU_OV_FMT_GB_OF] = "/ %.1f ГБ", [UI_MENU_OV_GAME_GB] = "игра %.1f ГБ", [UI_MENU_OV_FMT_MS] = "%.2f мс", [UI_MENU_OV_PER_FRAME] = "%.1f за кадр", [UI_MENU_OV_WINDOW] = "Окно", [UI_MENU_OV_OUTPUT] = "Изображение игры", [UI_MENU_OV_SCENE] = "3D-сцена", + [UI_MENU_OV_UPSCALER] = "3D-апскейлер", [UI_MENU_OV_SCALING] = "Масштабирование", [UI_MENU_OV_LIMIT] = "Лимит кадров", [UI_MENU_OV_PRESENT] = "Вывод кадров", [UI_MENU_OV_SHOWN] = "Показано", [UI_MENU_OV_FMT_SIZE] = "%ux%u", [UI_MENU_OV_FMT_SCENE] = "%ux%u, %.0f%%", [UI_MENU_OV_FMT_FSR] = "AMD FSR 1, резкость %d%%", [UI_MENU_OV_SCALE_NONE] = "нет (1:1)", @@ -1699,6 +1715,7 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = { [UI_MENU_OV_FMT_MHZ] = "%.0f MHz", [UI_MENU_OV_FMT_GB] = "%.1f GB", [UI_MENU_OV_FMT_GB_OF] = "/ %.1f GB", [UI_MENU_OV_GAME_GB] = "jogo %.1f GB", [UI_MENU_OV_FMT_MS] = "%.2f ms", [UI_MENU_OV_PER_FRAME] = "%.1f por quadro", [UI_MENU_OV_WINDOW] = "Janela", [UI_MENU_OV_OUTPUT] = "Imagem do jogo", [UI_MENU_OV_SCENE] = "Cena 3D", + [UI_MENU_OV_UPSCALER] = "Upscaler 3D", [UI_MENU_OV_SCALING] = "Escala", [UI_MENU_OV_LIMIT] = "Limite de quadros", [UI_MENU_OV_PRESENT] = "Apresentação", [UI_MENU_OV_SHOWN] = "Exibidos", [UI_MENU_OV_FMT_SIZE] = "%ux%u", [UI_MENU_OV_FMT_SCENE] = "%ux%u, %.0f%%", [UI_MENU_OV_FMT_FSR] = "AMD FSR 1, nitidez %d%%", [UI_MENU_OV_SCALE_NONE] = "nenhuma (1:1)", @@ -1887,15 +1904,11 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = { [UI_MENU_PCSS] = "Sombras suaves", [UI_MENU_PCSS_DESC] = "Sombras do sol nítidas onde um objeto toca o chão e mais suaves quanto mais longe a sombra " "cai (PCSS). 0 mantém o filtro do jogo. Vale no próximo início.", - [UI_MENU_DLAA] = "NVIDIA DLSS / DLAA", - [UI_MENU_DLAA_DESC] = "NVIDIA DLSS para a cena 3D (placas NVIDIA RTX; nvngx_dlss.dll ao lado do totk.exe): bordas " - "mais suaves e menos cintilação. O HUD não é afetado. O modo abaixo define a resolução de " - "onde ele parte. Vale após reiniciar.", - [UI_MENU_DLSS] = "Modo do DLSS", - [UI_MENU_DLSS_DESC] = "DLAA desenha a cena 3D na resolução cheia. Qualidade, Equilibrado, Desempenho e Ultra " - "Desempenho a desenham em 67, 58, 50 e 33 % e deixam o DLSS ampliá-la, o que poupa tempo da " - "GPU; eles substituem a escala 3D. Vale na hora.", - [UI_MENU_DLSS_DLAA] = "DLAA (nativo)", + [UI_MENU_DLSS] = "Modo de upscaling", + [UI_MENU_DLSS_DESC] = "Nativo suaviza a cena 3D na resolução cheia. Qualidade, Equilibrado, Desempenho e Ultra " + "Desempenho a desenham em 67, 58, 50 e 33 % e deixam o upscaler (DLSS ou FSR 3.1) ampliá-la, " + "o que poupa tempo da GPU; eles substituem a escala 3D. Vale na hora.", + [UI_MENU_DLSS_DLAA] = "Nativo", [UI_MENU_DLSS_QUALITY] = "Qualidade", [UI_MENU_DLSS_BALANCED] = "Equilibrado", [UI_MENU_DLSS_PERFORMANCE] = "Desempenho", [UI_MENU_DLSS_ULTRA] = "Ultra Desempenho", @@ -1920,6 +1933,17 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = { [UI_MENU_REFLEX_OFF] = "Desligado", [UI_MENU_REFLEX_ON] = "Ligado", [UI_MENU_REFLEX_BOOST] = "Ligado + Boost", + [UI_MENU_SCENE_UPSCALER] = "Upscaler da cena 3D", + [UI_MENU_SCENE_UPSCALER_DESC] = "Um upscaler temporal para a cena 3D: bordas mais suaves e menos cintilação, e nos modos abaixo do " + "Nativo ele desenha a cena menor e a amplia, o que poupa tempo da GPU. O NVIDIA DLSS " + "precisa de uma GPU NVIDIA RTX e do " DLSS_FILE " ao lado do " EXE_FILE "; o AMD FSR " + "3.1 roda em qualquer GPU. Desligado mantém a escala e o FXAA do próprio jogo. O HUD " + "não é afetado; o upscaler e a nitidez acima continuam ajustando a imagem do jogo à " + "janela. Vale após reiniciar.", + [UI_MENU_SCENE_UPSCALER_OFF] = "Desligado", [UI_MENU_SCENE_UPSCALER_DLSS] = "NVIDIA DLSS", + [UI_MENU_SCENE_UPSCALER_FSR3] = "AMD FSR 3.1", + [UI_MENU_SCENE_UPSCALER_NO_DLSS_GPU] = "DLSS: precisa de uma GPU NVIDIA RTX", + [UI_MENU_SCENE_UPSCALER_NO_DLSS_DLL] = "DLSS: falta o " DLSS_FILE, [UI_MENU_TAB_CHEATS] = "Cheats", [UI_MENU_CHEATS_NONE] = "Nenhum cheat para esta versão do jogo. Os cheats de um mod são um arquivo de cheats do " "Atmosphere na pasta cheats dele, com o nome da build do jogo: mods\\\\cheats\\%s. " @@ -2504,6 +2528,7 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = { [UI_MENU_OV_WINDOW] = "窗口", [UI_MENU_OV_OUTPUT] = "游戏画面", [UI_MENU_OV_SCENE] = "3D 场景", + [UI_MENU_OV_UPSCALER] = "3D 超分", [UI_MENU_OV_SCALING] = "缩放", [UI_MENU_OV_LIMIT] = "帧率上限", [UI_MENU_OV_PRESENT] = "呈现模式", @@ -2638,12 +2663,10 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = { [UI_MENU_CONTACT_SHADOWS_DESC] = "阴影贴图遗漏的细小太阳阴影:脚下、石头下、草丛和褶皱中。在光照之后于屏幕空间追踪。下次启动时生效。", [UI_MENU_PCSS] = "柔和阴影", [UI_MENU_PCSS_DESC] = "物体接触地面处的太阳阴影锐利,阴影投得越远越柔和(PCSS)。0 保留游戏自身的过滤。下次启动时生效。", - [UI_MENU_DLAA] = "NVIDIA DLSS / DLAA", - [UI_MENU_DLAA_DESC] = "用于 3D 场景的 NVIDIA DLSS(NVIDIA RTX 显卡;nvngx_dlss.dll 放在 totk.exe 旁):边缘更平滑,闪烁更少。HUD " - "不受影响。下方的模式决定它的工作分辨率。重启后生效。", - [UI_MENU_DLSS] = "DLSS 模式", - [UI_MENU_DLSS_DESC] = "DLAA 以全分辨率绘制 3D 场景。质量、平衡、性能和超级性能分别以 67%、58%、50% 和 33% 绘制,再由 DLSS 放大,以节省 GPU 时间;它们会取代 3D 渲染比例。立即生效。", - [UI_MENU_DLSS_DLAA] = "DLAA(原生)", + [UI_MENU_DLSS] = "超分模式", + [UI_MENU_DLSS_DESC] = "原生以全分辨率对 3D 场景做抗锯齿。质量、平衡、性能和超级性能分别以 67%、58%、50% 和 33% 绘制,再由超分" + "(DLSS 或 FSR 3.1)放大,以节省 GPU 时间;它们会取代 3D 渲染比例。立即生效。", + [UI_MENU_DLSS_DLAA] = "原生", [UI_MENU_DLSS_QUALITY] = "质量", [UI_MENU_DLSS_BALANCED] = "平衡", [UI_MENU_DLSS_PERFORMANCE] = "性能", @@ -2665,6 +2688,15 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = { [UI_MENU_REFLEX_OFF] = "关", [UI_MENU_REFLEX_ON] = "开", [UI_MENU_REFLEX_BOOST] = "开 + 增强", + [UI_MENU_SCENE_UPSCALER] = "3D 场景超分", + [UI_MENU_SCENE_UPSCALER_DESC] = "用于 3D 场景的时间性超分:边缘更平滑,闪烁更少;低于“原生”的模式会以更小的尺寸绘制场景再放大,以节省 GPU " + "时间。NVIDIA DLSS 需要 NVIDIA RTX 显卡,并将 " DLSS_FILE " 放在 " EXE_FILE " 旁;AMD " + "FSR 3.1 可在任何显卡上运行。“关”保留游戏自己的缩放和 FXAA。HUD 不受影响;上方的缩放" + "方式和锐度仍负责把游戏画面适配到窗口。重启后生效。", + [UI_MENU_SCENE_UPSCALER_OFF] = "关", [UI_MENU_SCENE_UPSCALER_DLSS] = "NVIDIA DLSS", + [UI_MENU_SCENE_UPSCALER_FSR3] = "AMD FSR 3.1", + [UI_MENU_SCENE_UPSCALER_NO_DLSS_GPU] = "DLSS:需要 NVIDIA RTX 显卡", + [UI_MENU_SCENE_UPSCALER_NO_DLSS_DLL] = "DLSS:缺少 " DLSS_FILE, [UI_MENU_TAB_CHEATS] = "金手指", [UI_MENU_CHEATS_NONE] = "此游戏版本没有金手指。模组的金手指是它的 cheats 文件夹中以游戏构建命名的 Atmosphere " "金手指文件:mods\\<模组>\\cheats\\%s。重启游戏后才会读取。对于修改游戏代码的金手指," diff --git a/runtime/ui_text.h b/runtime/ui_text.h index 09cabce1..da69fe77 100644 --- a/runtime/ui_text.h +++ b/runtime/ui_text.h @@ -59,11 +59,13 @@ typedef enum { UI_MENU_GRASS_RANGE, UI_MENU_GRASS_RANGE_DESC, UI_MENU_CONTACT_SHADOWS, UI_MENU_CONTACT_SHADOWS_DESC, UI_MENU_PCSS, UI_MENU_PCSS_DESC, - UI_MENU_DLAA, UI_MENU_DLAA_DESC, UI_MENU_DLSS, UI_MENU_DLSS_DESC, UI_MENU_DLSS_DLAA, UI_MENU_DLSS_QUALITY, + UI_MENU_DLSS, UI_MENU_DLSS_DESC, UI_MENU_DLSS_DLAA, UI_MENU_DLSS_QUALITY, UI_MENU_DLSS_BALANCED, UI_MENU_DLSS_PERFORMANCE, UI_MENU_DLSS_ULTRA, UI_MENU_DLSS_PRESET, UI_MENU_DLSS_PRESET_DESC, UI_MENU_DLSS_PRESET_DEFAULT, UI_MENU_DLSS_PRESET_K, UI_MENU_DLSS_PRESET_J, UI_MENU_DLSS_CHARS, UI_MENU_DLSS_CHARS_DESC, UI_MENU_DLSS_CHARS_OFF, UI_MENU_DLSS_CHARS_LIGHT, UI_MENU_DLSS_CHARS_MEDIUM, UI_MENU_DLSS_CHARS_FULL, UI_MENU_FXAA, UI_MENU_FXAA_DESC, UI_MENU_REFLEX, UI_MENU_REFLEX_DESC, UI_MENU_REFLEX_OFF, UI_MENU_REFLEX_ON, UI_MENU_REFLEX_BOOST, + UI_MENU_SCENE_UPSCALER, UI_MENU_SCENE_UPSCALER_DESC, UI_MENU_SCENE_UPSCALER_OFF, UI_MENU_SCENE_UPSCALER_DLSS, + UI_MENU_SCENE_UPSCALER_FSR3, UI_MENU_SCENE_UPSCALER_NO_DLSS_GPU, UI_MENU_SCENE_UPSCALER_NO_DLSS_DLL, // Game UI_MENU_FPS_LIMIT, UI_MENU_FPS_LIMIT_DESC, UI_MENU_FPS_30, UI_MENU_FPS_40, UI_MENU_FPS_45, UI_MENU_FPS_60, UI_MENU_FPS_90, @@ -285,7 +287,7 @@ typedef enum { UI_MENU_OV_FMT_PCT, UI_MENU_OV_FMT_TEMP, UI_MENU_OV_FMT_POWER, UI_MENU_OV_FMT_MHZ, UI_MENU_OV_FMT_GB, UI_MENU_OV_FMT_GB_OF, UI_MENU_OV_GAME_GB, UI_MENU_OV_FMT_MS, UI_MENU_OV_PER_FRAME, // the picture lines: window, game image and 3D scene sizes, the scaling to the window, frame limit and presentation - UI_MENU_OV_WINDOW, UI_MENU_OV_OUTPUT, UI_MENU_OV_SCENE, UI_MENU_OV_SCALING, UI_MENU_OV_LIMIT, UI_MENU_OV_PRESENT, + UI_MENU_OV_WINDOW, UI_MENU_OV_OUTPUT, UI_MENU_OV_SCENE, UI_MENU_OV_UPSCALER, UI_MENU_OV_SCALING, UI_MENU_OV_LIMIT, UI_MENU_OV_PRESENT, UI_MENU_OV_SHOWN, // frame generation: the pictures shown a second UI_MENU_OV_FMT_SIZE, // "%ux%u" UI_MENU_OV_FMT_SCENE, // "%ux%u, %.0f%%": the scene and its share of the game image's width diff --git a/runtime/vk_device.c b/runtime/vk_device.c index e4fbf247..07f128f7 100644 --- a/runtime/vk_device.c +++ b/runtime/vk_device.c @@ -13,6 +13,7 @@ #include "platform/platform.h" #include "vk_dlaa.h" #include "vk_fg.h" +#include "vk_fsr3.h" static VkCtx g_vk; static int g_ready; @@ -484,6 +485,7 @@ static void destroy_all(void) { gfx_window_release_vk(); if (g_vk.device) vkDeviceWaitIdle(g_vk.device); if (g_vk.device) vk_fg_release(); + if (g_vk.device) fsr3_release(); if (g_vk.device) vk_astc_release(); if (g_vk.device) vk_deswz_release(); if (g_vk.device) vk_crumbs_release(); diff --git a/runtime/vk_dlaa.c b/runtime/vk_dlaa.c index 50ea7274..de982d73 100644 --- a/runtime/vk_dlaa.c +++ b/runtime/vk_dlaa.c @@ -26,6 +26,7 @@ #include "nvn_api.h" #include "vk_exec.h" #include "vk_fg.h" +#include "vk_fsr3.h" #include "vk_rec.h" #include "dlaa_mv_spv.h" @@ -103,12 +104,29 @@ static int p_getp(const NgxParam *p, const char *n, void **v) { return NGX_OK((( #define DLSS_MODEL "libnvidia-ngx-dlss.so." #endif -// NGX is brought up only when dlaa is on at start: its device extensions can only be asked for at device creation, and -// loading the driver's NGX core on every NVIDIA machine would cost start time and change the device with DLAA off. So -// dlaa applies after a restart; switched off, nothing else of DLAA runs. +// The scene upscaler picked at start (scene_upscaler; without it dlaa = 1 is DLSS): a restart applies another. AMD FSR +// 3.1 (vk_fsr3.cpp) takes the same inputs at the same point of the frame as DLSS and runs on any GPU. +int vk_upscaler_engine(void) { + static int e = -1; + if (e < 0) { + const char *v = cfg_scene_upscaler(); + e = !strcmp(v, "dlss") ? UPSCALER_DLSS : !strcmp(v, "fsr3") ? UPSCALER_FSR3 : UPSCALER_OFF; + } + return e; +} + +// The engine picked at start while the settings still name it (the menu turns it off at once, as dlaa did). +int vk_upscaler_on(void) { + int e = vk_upscaler_engine(); + return e && !strcmp(cfg_scene_upscaler(), e == UPSCALER_DLSS ? "dlss" : "fsr3"); +} + +// NGX is brought up only when DLSS is the scene upscaler at start: its device extensions can only be asked for at +// device creation, and loading the driver's NGX core on every NVIDIA machine would cost start time and change the device +// with DLSS off. So the choice applies after a restart; with DLSS not picked (off or FSR 3.1), nothing of NGX runs. int vk_dlaa_wanted(void) { static int wanted = -1; - if (wanted < 0) wanted = cfg_bool("TOTK_DLAA"); + if (wanted < 0) wanted = vk_upscaler_engine() == UPSCALER_DLSS; return wanted; } @@ -191,7 +209,16 @@ static int vtable_ok(void) { return ok; } +// Per-object motion (vk_mvprev.c, vk_usnap.c's host copy, vk_exec_draw.c's motion draws) runs for the engine that +// reads the motion image: DLSS once NGX came up with it (vk_dlaa_available), FSR 3.1 whenever it is the scene upscaler +// picked at start. Latched in vk_dlaa_init, before the first frame: with no upscaler, or DLSS without NGX, it stays 0 +// as vk_dlaa_available does. +static int objmv; + +int vk_objmv_wanted(void) { return objmv; } + void vk_dlaa_init(void) { + objmv = vk_upscaler_engine() == UPSCALER_FSR3; if (!vk_dlaa_wanted() || !core_load()) return; // The executable's folder, where NGX looks for the DLSS model library and writes its logs. wchar_t wdir[PLAT_PATH_MAX]; @@ -215,6 +242,7 @@ void vk_dlaa_init(void) { p_geti(caps, "SuperSampling.NeedsUpdatedDriver", &driver); } N.available = avail != 0; + objmv = N.available; // vk_dlaa_available: wanted, and DLSS came up rt_log("dlaa: NGX up; DLSS %s%s", avail ? "available" : "NOT available (is " DLSS_MODEL " next to the executable?)", driver ? "; the driver needs an update" : ""); } @@ -313,17 +341,32 @@ static struct { VkExecTarget hud_t, win; // the output-sized target the scene is scaled into; the window texture float cam_dr[2]; // the viewport depth range of the draw cam_addr was noted at int fg_mv_ok; // the frame's camera motion is in the motion image (fg_motion) + int fsr; // the engine is AMD FSR 3.1 (scene_upscaler = fsr3 at start), else DLSS } D = {.mv_ok = -1, .cfg_seen = ~0u}; #define DLSS_SIZES (sizeof D.sizes / sizeof D.sizes[0]) const VkTexImage *vk_dlaa_swap_img; VkImageView vk_dlaa_swap_view; -static int dl_active(void) { return N.available && !D.failed && D.on; } +// DLSS needs NGX and its model, FSR 3.1 runs on any GPU the back end runs on: on already says the engine is there. +static int dl_active(void) { return !D.failed && D.on; } // The scene is followed (its G-buffer, light target, end and camera): for DLSS, or with DLSS off for frame generation. static int track(void) { return dl_active() || D.fg; } int vk_dlaa_fg_on; // D.fg for vk_exec_draw.c's per-draw test (vk_dlaa_hud) +int vk_upscaler_running(void) { + return dl_active() && D.evals ? (D.fsr ? UPSCALER_FSR3 : UPSCALER_DLSS) : UPSCALER_OFF; +} + +// For the menu. DLSS: after a start with it picked, what NGX said; before, an NVIDIA GPU and the DLL (an NVIDIA GPU +// without RTX shows only once NGX came up). FSR 3.1 is built in. +int vk_upscaler_missing(int engine) { + if (engine != UPSCALER_DLSS) return 0; + if (!res_dlss_dll()) return UPSCALER_MISSING_DLL; + if (N.tried) return N.available ? 0 : UPSCALER_MISSING_GPU; + return vk_ctx()->props.vendorID == 0x10de ? 0 : UPSCALER_MISSING_GPU; +} + static void dl_fail(const char *what, NgxResult r) { rt_log("dlaa: %s failed (%08x): DLAA off for this run", what, (unsigned)r); D.failed = 1; @@ -1229,6 +1272,41 @@ static int scene_shaped(const VkExecTarget *c) { return a * 20 >= b * 19 && b * 20 >= a * 19; } +// FSR 3.1's half of evaluate (vk_fsr3.cpp), after the motion vectors and the recorder's drain: the camera, the time step +// and the history reset, then the dispatch into e->out. 0 when it failed (DLAA is then off for the run). The camera +// comes from the scene camera block's rows 0-10 (vk_fg.cpp vk_fg_camera, which frame generation reads too: FSR 3.1 +// wants the near and far planes and the vertical field of view for its depth tests); a cut there (a cutscene's camera +// jump) starts a new history. The block's bytes are the snapshot's host copy, which vk_usnap.c keeps while the +// per-object motion runs (vk_objmv_wanted, so with FSR 3.1). +static int fsr_evaluate(VkExec *ex, struct Size *e, const VkExecTarget *t, const VkExecTarget *z, uint32_t ow, + uint32_t oh, float jx, float jy, int timed) { + static VkFgScene cam = {.near_m = 0.1f, .far_m = 25000.0f, .fov_y = 0.8727f}; // until the first camera read + // the SDK takes whole images: the scene's targets are level 0, layer 0 of their own images + if (t->level || t->base_layer || z->level || z->base_layer || z->format != VK_FORMAT_D32_SFLOAT) + return dl_fail("FSR 3.1 input (not level 0, layer 0 of a colour and a D32F depth image)", 0), 0; + const float *rows = D.cam_addr ? (const float *)vk_usnap_bytes(D.cam_addr, 11 * 16) : NULL; + int cut = rows && vk_fg_camera(rows, nvn_depth_minus_w(), D.cam_dr, &cam); + if (D.last_color != t->image) D.reset = 1, D.why[2]++, D.last_color = t->image; + if (cut) D.reset = 1, D.why[1]++; + uint64_t now = plat_now_ns(); + double dt = D.last_eval_ns ? (now - D.last_eval_ns) / 1e6 : 0; + D.last_eval_ns = now; + Fsr3Frame fr = {.color = t->image, .color_format = t->format, .depth = z->image, .mv = e->mv, .out = e->out, + .w = t->width, .h = t->height, .ow = ow, .oh = oh, .jx = jx, .jy = jy, .near_m = cam.near_m, + .far_m = cam.infinite || cam.far_m <= cam.near_m ? 1e5f : cam.far_m, .fov_y = cam.fov_y, + .dt_ms = dt > 0 && dt < 100 ? (float)dt : 16.67f, .reset = D.reset, .fence = ex->fence}; + uint64_t c0 = timed ? kern_now_ns() : 0; + int ok = fsr3_dispatch(ex->cb, &fr); + if (timed) T.cpu_ngx += kern_now_ns() - c0; + if (!ok) { + // the SDK may have bound a pipeline or descriptor sets of its own before it failed: the next draw binds + // everything again, and the game's own scaling and FXAA run from the next frame (DLAA off for the run) + vk_exec_draw_new_cb(ex); + return dl_fail("FSR 3.1 dispatch", 0), 0; + } + return 1; +} + // dst: the target DLSS's picture goes to, NULL for the light target itself (DLAA in place). static void evaluate(VkExec *ex, const VkExecTarget *dst) { const VkExecTarget *t = &D.color, *z = &D.depth; @@ -1244,7 +1322,7 @@ static void evaluate(VkExec *ex, const VkExecTarget *dst) { struct Size *e = size_for(cb, w, h, ow, oh, 1); if (!e) return dl_fail("work image creation", 0); if (e != D.last) D.reset = 1, D.why[0]++, e->chars_ok = 0; // another size's history is from another moment - if (!D.params && !NGX_OK(N.alloc_params(&D.params))) return dl_fail("parameter allocation", 0); + if (!D.fsr && !D.params && !NGX_OK(N.alloc_params(&D.params))) return dl_fail("parameter allocation", 0); NgxParam *p = D.params; VkImageView zv = vk_exec_target_view(z->img, z->format, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_DEPTH_BIT, z->level, z->base_layer, 1, 0); @@ -1252,7 +1330,7 @@ static void evaluate(VkExec *ex, const VkExecTarget *dst) { static int no_mv = -1; if (no_mv < 0) no_mv = !rt_knob("DLAA_MV", "1"); // TOTK_DLAA_MV=0: zero motion (test) int masked = 0; - if (no_mv || !mv_pass(ex, e, zv, jx, jy, char_bias(), &masked, 1)) { + if (no_mv || !mv_pass(ex, e, zv, jx, jy, D.fsr ? 0.0f : char_bias(), &masked, 1)) { VkClearColorValue zero = {{0, 0, 0, 0}}; VkImageSubresourceRange all = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; vkCmdClearColorImage(cb, e->mv, VK_IMAGE_LAYOUT_GENERAL, &zero, 1, &all); @@ -1261,12 +1339,16 @@ static void evaluate(VkExec *ex, const VkExecTarget *dst) { } VkImageView cv = vk_exec_target_view(t->img, t->format, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT, t->level, t->base_layer, 1, 0); - struct Snap *mk = D.mv_samp ? mask_pass(cb, cv, w, h) : NULL; + struct Snap *mk = !D.fsr && D.mv_samp ? mask_pass(cb, cv, w, h) : NULL; // a bias mask is DLSS's only int timed = T.on > 0 && T.used[T.slot]; // mv_pass began this frame's slot if (timed) times_mark(cb, T_DL0); uint64_t c0 = timed ? kern_now_ns() : 0; - rec_drain(); // NGX records into the command buffer itself: the recorder thread must have made every call so far + rec_drain(); // NGX and FSR record into the command buffer themselves: the recorder thread must have made every call if (timed) T.cpu_drain += kern_now_ns() - c0; + if (D.fsr) { + if (!fsr_evaluate(ex, e, t, z, ow, oh, jx, jy, timed)) return; + goto engine_done; + } if (!e->feat) { p_setu(p, "CreationNodeMask", 1); p_setu(p, "VisibilityNodeMask", 1); @@ -1337,7 +1419,8 @@ static void evaluate(VkExec *ex, const VkExecTarget *dst) { NgxResult r = N.evaluate(cb, e->feat, p, NULL); if (timed) T.cpu_ngx += kern_now_ns() - c0; if (!NGX_OK(r)) return dl_fail("DLSS evaluation", r); - if (timed) times_mark(cb, T_DL1); // through the recorder, after NGX's own commands +engine_done: + if (timed) times_mark(cb, T_DL1); // through the recorder, after NGX's or FSR's own commands D.reset = 0; D.last = e, e->used = D.evals + 1; full_barrier(cb); @@ -1365,10 +1448,10 @@ static void evaluate(VkExec *ex, const VkExecTarget *dst) { next_jitter(w, ow); cam_unjitter(ex); if (++D.evals == 1 || D.evals == 300 || D.evals % 3600 == 0) // 300: one early line with the frames counted - rt_log("dlaa: %llu frames anti-aliased (scene %ux%u, output %ux%u; %llu before the effects, %llu frames without the " + rt_log("dlaa: %llu frames anti-aliased%s (scene %ux%u, output %ux%u; %llu before the effects, %llu frames without the " "DLAA point, %llu with camera motion, %llu with the characters' mask, %llu without a camera, %llu jitter " "holds; resets: %llu size, %llu camera, %llu target; reactive mask %llu, without its copy %llu)", - (unsigned long long)D.evals, w, h, ow, oh, (unsigned long long)D.fx_frames, (unsigned long long)D.frames_missed, + (unsigned long long)D.evals, D.fsr ? " by FSR 3.1" : "", w, h, ow, oh, (unsigned long long)D.fx_frames, (unsigned long long)D.frames_missed, (unsigned long long)D.mv_frames, (unsigned long long)D.masked, (unsigned long long)D.mv_none, (unsigned long long)D.holds, (unsigned long long)D.why[0], (unsigned long long)D.why[1], (unsigned long long)D.why[2], (unsigned long long)R.made, (unsigned long long)R.missed); @@ -1750,14 +1833,19 @@ void vk_dlaa_frame(void) { vk_dlaa_swap_img = NULL, vk_dlaa_swap_view = VK_NULL_HANDLE; dlss_mode(); preset_check(); - int on = N.available && cfg_bool("TOTK_DLAA"); + int fsr = vk_upscaler_engine() == UPSCALER_FSR3; // fixed for the run: D.fsr never changes while on + int on = (fsr || N.available) && vk_upscaler_on(); vk_fg_frame(); - int fg = vk_fg_wanted(on && !D.failed); + // frame generation with an upscaler is not built yet: with FSR 3.1 picked it stays off (said once) + static int fg_said; + if (fsr && on && vk_fg_engine() != VK_FG_OFF && !fg_said++) + rt_log("fg: frame generation off while FSR 3.1 upscales the scene (scene_upscaler = fsr3)"); + int fg = fsr && on ? 0 : vk_fg_wanted(on && !D.failed); D.bloom = D.hud = D.hud_wait = D.fin = D.gen = D.fg_mv_ok = 0; if (on != D.on || fg != D.fg) { - if (on != D.on) rt_log("dlaa: %s", on ? "on" : "off"); + if (on != D.on) rt_log("dlaa: %s", on ? (fsr ? "on with FSR 3.1" : "on") : "off"); if (fg != D.fg) rt_log("dlaa: the scene is %s for frame generation", fg ? "followed" : "no longer followed"); - D.on = on, D.fg = vk_dlaa_fg_on = fg; + D.on = on, D.fg = vk_dlaa_fg_on = fg, D.fsr = fsr; // either way the next DLAA frame starts a new history from an unjittered frame D.reset = 1, D.cam_prev_ok = 0, D.jit_ok = D.jit_used = D.armed = D.done = D.gbuf = D.ended = D.up = 0; D.fx_seen = D.fx_open = D.fx_bad = 0, D.fx_steady = 0; diff --git a/runtime/vk_dlaa.h b/runtime/vk_dlaa.h index c9cd320c..6e6ea67d 100644 --- a/runtime/vk_dlaa.h +++ b/runtime/vk_dlaa.h @@ -1,4 +1,5 @@ -// DLAA (vk_dlaa.c): NVIDIA DLSS at the scene's own size, behind TOTK_DLAA (totk.ini dlaa = 1). +// DLAA (vk_dlaa.c): the scene upscaler, NVIDIA DLSS or AMD FSR 3.1 (vk_fsr3.cpp), behind scene_upscaler (dlaa = 1 without +// it: DLSS). #pragma once #include "vk.h" @@ -6,7 +7,7 @@ // output renders 640 wide, smaller windows less. #define DLAA_SCENE_MIN_W 320u -int vk_dlaa_wanted(void); // the setting is on (the device may still lack DLSS) +int vk_dlaa_wanted(void); // DLSS is the scene upscaler picked at start (the device may still lack it) // vk_device.c: NGX's instance and device extensions join the lists (room for max names); vk_dlaa_init after the // device exists brings NGX up and checks that DLSS is available. void vk_dlaa_instance_exts(const char **ext, uint32_t *n, uint32_t max); @@ -14,6 +15,8 @@ void vk_dlaa_device_exts(const VkExtensionProperties *have, uint32_t nhave, cons void vk_dlaa_init(void); // 1 when dlaa is on and NGX came up with DLSS (after vk_dlaa_init): a DLSS mode's smaller scene is scaled up by DLSS. int vk_dlaa_available(void); +// 1 when the per-object motion runs (after vk_dlaa_init): vk_dlaa_available, or FSR 3.1 picked as the scene upscaler. +int vk_objmv_wanted(void); // vk_exec.c vk_exec_pass_begin, once the pass's targets are resolved and before its barrier: arms the frame on the // scene's light target or, at the first quarter-width pass after it, runs DLAA on that target. Each present ends the // frame (vk_dlaa_frame). diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index 42a2ff86..d65e9be5 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -3527,7 +3527,7 @@ static int prepare_draw(VkExec *ex, int prim, int32_t count, int restart) { } D->B.st_pm = D->PM.valid; // st is this draw's state, which PM holds while valid vk_dlaa_draw(ex); - int mo = ex->chunked && vk_dlaa_available(); + int mo = ex->chunked && vk_objmv_wanted(); if (mo) plat_mutex_lock(&mo_lock); vk_mvsurvey_draw(ex); vk_mvprev_draw(ex); diff --git a/runtime/vk_fg.cpp b/runtime/vk_fg.cpp index 1d5762ec..7ee127aa 100644 --- a/runtime/vk_fg.cpp +++ b/runtime/vk_fg.cpp @@ -22,6 +22,7 @@ // The present (vk_backend.c present_pair) shows it before the frame, through vk_fg_present_gen (TOTK_FG_TEST shows it, or // the picture before the HUD, in place of the frame instead, for checks only). #include "vk_fg.h" +#include "vk_fsr3.h" #include #include @@ -56,6 +57,7 @@ extern "C" FfxErrorCode ffxGetPermutationBlobByIndex(FfxEffect effect, FfxPass p memcpy(out, &ffx_of_blobs[pass], sizeof *out); return FFX_OK; } + if (effect == FFX_EFFECT_FSR3UPSCALER && vk_fsr3_blob(pass, options, out)) return FFX_OK; // the upscaler's (vk_fsr3.cpp) rt_log("fg: no shader for effect %d pass %d", (int)effect, (int)pass); return FFX_ERROR_INVALID_ARGUMENT; } diff --git a/runtime/vk_fsr3.cpp b/runtime/vk_fsr3.cpp new file mode 100644 index 00000000..2a088a7a --- /dev/null +++ b/runtime/vk_fsr3.cpp @@ -0,0 +1,265 @@ +// AMD FSR 3.1 temporal upscaler (scene_upscaler = fsr3): the FidelityFX SDK 1.1.4's upscaler context +// (third_party/FidelityFX, MIT) on the SDK's Vulkan backend, driven directly, without the ffx-api DLL layer. +// +// Ported from Savage Wind (https://github.com/Revivedx/SavageWindRecomp @ bf6146c14c37fee8781a601e5a544b93dff6d75e, +// MIT), runtime/nvn/vulkan/fsr3.cpp: the context with the three images FSR 3.1 has the application own (dilated depth +// and motion vectors, the previous frame's nearest depth, made by the backend for a context of their own as the SDK's +// ffx_fsr3.cpp does), the resource wrapping and the dispatch parameters; framegen.cpp for the 16-bit blob choice. +// +// What differs from Savage Wind: the input is the scene's linear light before the bloom (vk_dlaa.c's DLSS point), so +// the context and the shaders are HDR; one context per output size with the output as its largest render size, so the +// upscaling modes (which change while the game runs) and the dynamic resolution tiers need no new context; the backend's +// per-frame rings are guarded against more frames in flight than they hold (wait_ring). +// +// Everything is recorded into the replay's command buffer by vk_dlaa.c evaluate, on the replay thread, after it drained +// the recorder thread; the SDK binds pipelines and descriptor sets of its own, so vk_dlaa.c makes the next draw bind +// everything again. +#include "vk_fsr3.h" + +#include +#include +#include +#include + +#include +#include +#include + +extern "C" { +#include "cfg.h" +#include "host.h" +#include "vk.h" +} + +// The shaders: tools/ffx_shaders.py --effects fu (wave32; HDR input, render-size motion vectors without jitter, depth +// not inverted; 32-bit and 16-bit floats) in place of the SDK's FidelityFX_SC permutation tables +#include "ffx_fsr3upscaler_vk.h" + +enum { FU_PERM_FP16 = 1 << 7 }; // ffx_fsr3upscaler_private.h FSR3UPSCALER_SHADER_PERMUTATION_ALLOW_FP16 + +static struct { + bool live, failed, fp16; + FfxFsr3UpscalerContext ctx; + FfxInterface iface; + void *scratch; + FfxUInt32 shared_id; + FfxResourceInternal shared[3]; + uint32_t ow, oh; + // the timeline values of the last dispatches: the backend reuses its descriptor sets, constant buffers and image + // views after FFX_MAX_QUEUED_FRAMES dispatches (wait_ring) + uint64_t ring[FFX_MAX_QUEUED_FRAMES]; + uint32_t n; + uint64_t waits; +} F; + +extern "C" int vk_fsr3_blob(uint32_t pass, uint32_t options, void *out) { + if (pass >= sizeof ffx_fu_blobs[0] / sizeof ffx_fu_blobs[0][0] || !ffx_fu_blobs[0][pass].data) return 0; + // the 16-bit version where the SDK asks for it (the backend found shaderFloat16) and the device has what its + // SPIR-V declares (Float16, Int16), which the runtime's device enables wherever the driver reports it + int half = (options & FU_PERM_FP16) && F.fp16; + memcpy(out, &ffx_fu_blobs[half][pass], sizeof(FfxShaderBlob)); + return 1; +} + +// The backend calls a few extension functions unchecked: the debug labels (VK_EXT_debug_utils, an instance extension +// the runtime enables only with validation) and vkGetBufferMemoryRequirements2KHR (core since 1.1 without the suffix) +static VKAPI_ATTR void VKAPI_CALL no_label(VkCommandBuffer, const VkDebugUtilsLabelEXT *) {} +static VKAPI_ATTR void VKAPI_CALL no_label_end(VkCommandBuffer) {} +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL device_proc(VkDevice d, const char *name) { + PFN_vkVoidFunction f = vkGetDeviceProcAddr(d, name); + if (f) return f; + if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) return vkGetDeviceProcAddr(d, "vkGetBufferMemoryRequirements2"); + if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT")) return (PFN_vkVoidFunction)no_label; + if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT")) return (PFN_vkVoidFunction)no_label_end; + return nullptr; +} + +// The backend's scratch memory holds its context, whose members the compiler aligns past malloc's 16 bytes +static void *scratch_alloc(size_t n) { +#ifdef _WIN32 + void *p = _aligned_malloc(n, 256); +#else + void *p = aligned_alloc(256, n); +#endif + if (p) memset(p, 0, n); + return p; +} + +static void scratch_free(void *p) { +#ifdef _WIN32 + _aligned_free(p); +#else + free(p); +#endif +} + +static void message(FfxMsgType type, const wchar_t *msg) { + static int n; + if (n++ >= 32) return; // (the debug checks repeat every frame) + char buf[512]; + snprintf(buf, sizeof buf, "%ls", msg); + rt_log("fsr3: SDK %s: %s", type == FFX_MESSAGE_TYPE_ERROR ? "error" : "warning", buf); +} + +// The SDK's objects: the device is idle or the context never recorded anything. +static void destroy(void) { + if (F.live) { + for (int i = 0; i < 3; i++) F.iface.fpDestroyResource(&F.iface, F.shared[i], F.shared_id); + F.iface.fpDestroyBackendContext(&F.iface, F.shared_id); + ffxFsr3UpscalerContextDestroy(&F.ctx); + } + scratch_free(F.scratch); + F.scratch = nullptr; + F.live = false; +} + +static int fp16_usable(VkPhysicalDevice phys) { + VkPhysicalDeviceVulkan12Features f12 = {}; + f12.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; + VkPhysicalDeviceFeatures2 f2 = {}; + f2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; + f2.pNext = &f12; + vkGetPhysicalDeviceFeatures2(phys, &f2); + return f12.shaderFloat16 && f2.features.shaderInt16; +} + +#define TRY(x, what) \ + do { \ + FfxErrorCode e_ = (x); \ + if (e_ != FFX_OK) { \ + rt_log("fsr3: %s failed (%#x) at %ux%u: FSR 3.1 off for this run", what, (unsigned)e_, ow, oh); \ + return false; \ + } \ + } while (0) + +static bool create(VkCtx *c, uint32_t ow, uint32_t oh) { + enum { CONTEXTS = FFX_FSR3UPSCALER_CONTEXT_COUNT + 1 }; // (+ the shared images') + size_t n = (ffxGetScratchMemorySizeVK(c->phys, CONTEXTS) + 255) & ~(size_t)255; + if (!(F.scratch = scratch_alloc(n))) { + rt_log("fsr3: no memory for the backend (%zu bytes): FSR 3.1 off for this run", n); + return false; + } + VkDeviceContext dc = {c->device, c->phys, device_proc}; // (ffxGetDeviceVK keeps a copy) + FfxFsr3UpscalerContextDescription cd = {}; + TRY(ffxGetInterfaceVK(&cd.backendInterface, ffxGetDeviceVK(&dc), F.scratch, n, CONTEXTS), "the backend"); + // HDR: the scene's linear light. Render-size motion vectors without the jitter (the defaults), standard depth with a + // finite far plane. TOTK_FSR3_DEBUG=1: the SDK's checks of the inputs, in the log. + cd.flags = FFX_FSR3UPSCALER_ENABLE_HIGH_DYNAMIC_RANGE | FFX_FSR3UPSCALER_ENABLE_DYNAMIC_RESOLUTION | + (rt_knob("FSR3_DEBUG", "0") ? FFX_FSR3UPSCALER_ENABLE_DEBUG_CHECKING : 0); + cd.maxRenderSize = {ow, oh}; + cd.maxUpscaleSize = {ow, oh}; + cd.fpMessage = message; + TRY(ffxFsr3UpscalerContextCreate(&F.ctx, &cd), "context creation"); + F.iface = cd.backendInterface; + F.live = true; // (from here destroy() takes the context down) + FfxFsr3UpscalerSharedResourceDescriptions sd = {}; + TRY(ffxFsr3UpscalerGetSharedResourceDescriptions(&F.ctx, &sd), "the shared images' descriptions"); + TRY(F.iface.fpCreateBackendContext(&F.iface, FFX_EFFECT_SHAREDRESOURCES, nullptr, &F.shared_id), "the shared context"); + const FfxCreateResourceDescription *rd[3] = {&sd.dilatedDepth, &sd.dilatedMotionVectors, &sd.reconstructedPrevNearestDepth}; + for (int i = 0; i < 3; i++) TRY(F.iface.fpCreateResource(&F.iface, rd[i], F.shared_id, &F.shared[i]), "a shared image"); + F.ow = ow, F.oh = oh, F.n = 0; + memset(F.ring, 0, sizeof F.ring); + FfxEffectMemoryUsage mu = {}; + ffxFsr3UpscalerContextGetGpuMemoryUsage(&F.ctx, &mu); + rt_log("fsr3: FSR 3.1 context up to %ux%u -> %ux%u (HDR, %s floats), %.1f MiB", ow, oh, ow, oh, + F.fp16 ? "16-bit" : "32-bit", (double)mu.totalUsageInBytes / 1048576.0); + return true; +} + +// An image of the runtime as the SDK sees it: every one is in GENERAL, which the backend takes both states as and +// returns it to after the dispatch (UnregisterResourcesVK). A D32F image is a depth target to it (its view's aspect). +static FfxResource res(VkImage img, VkFormat f, uint32_t w, uint32_t h, bool write, const wchar_t *name) { + VkImageCreateInfo ci = {}; + ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; + ci.imageType = VK_IMAGE_TYPE_2D; + ci.format = f; + ci.extent = {w, h, 1}; + ci.mipLevels = 1; + ci.arrayLayers = 1; + ci.samples = VK_SAMPLE_COUNT_1_BIT; + ci.usage = VK_IMAGE_USAGE_SAMPLED_BIT | (write ? VK_IMAGE_USAGE_STORAGE_BIT : 0); + return ffxGetResourceVK((void *)img, ffxGetImageResourceDescriptionVK(img, ci, write ? FFX_RESOURCE_USAGE_UAV + : FFX_RESOURCE_USAGE_READ_ONLY), name, write ? FFX_RESOURCE_STATE_UNORDERED_ACCESS + : FFX_RESOURCE_STATE_GENERIC_READ); +} + +// The backend writes a dispatch's descriptor sets and constants into rings FFX_MAX_QUEUED_FRAMES deep and destroys the +// image views of the dispatch that many back at the end of each one, without knowing the GPU. With the game's two or +// three frames in flight that dispatch is long done; should it not be, its submission is waited for here (counted). +static void wait_ring(uint64_t fence) { + if (F.n >= FFX_MAX_QUEUED_FRAMES - 1) { + uint64_t back = F.ring[(F.n + 1) % FFX_MAX_QUEUED_FRAMES]; // the dispatch FFX_MAX_QUEUED_FRAMES - 1 back + if (back && vk_sync_fence_done() < back) { + if (!F.waits++) rt_log("fsr3: waiting for the submission of a dispatch %d back (more frames in flight than " + "the SDK's rings hold)", FFX_MAX_QUEUED_FRAMES - 1); + vk_sync_fence_wait(back, 2000000000ull); + } + } + F.ring[F.n % FFX_MAX_QUEUED_FRAMES] = fence; +} + +extern "C" int fsr3_dispatch(VkCommandBuffer cb, const Fsr3Frame *f) { + if (F.failed) return 0; + VkCtx *c = vk_ctx(); + if (!F.live || f->ow != F.ow || f->oh != F.oh) { + if (F.live) { + vkDeviceWaitIdle(c->device); // what the old context recorded is queued or submitted + destroy(); + } + F.fp16 = fp16_usable(c->phys); + if (!create(c, f->ow, f->oh)) { + destroy(); + F.failed = true; + return 0; + } + } + if (f->w > F.ow || f->h > F.oh) { + rt_log("fsr3: a %ux%u scene is larger than the %ux%u output: FSR 3.1 off for this run", f->w, f->h, F.ow, F.oh); + F.failed = true; + return 0; + } + wait_ring(f->fence); + FfxFsr3UpscalerDispatchDescription dd = {}; + dd.commandList = ffxGetCommandListVK(cb); + dd.color = res(f->color, f->color_format, f->w, f->h, false, L"FSR3_Color"); + dd.depth = res(f->depth, VK_FORMAT_D32_SFLOAT, f->w, f->h, false, L"FSR3_Depth"); + dd.motionVectors = res(f->mv, VK_FORMAT_R16G16_SFLOAT, f->w, f->h, false, L"FSR3_MotionVectors"); + dd.output = res(f->out, VK_FORMAT_R16G16B16A16_SFLOAT, f->ow, f->oh, true, L"FSR3_Output"); + dd.dilatedDepth = F.iface.fpGetResource(&F.iface, F.shared[0]); + dd.dilatedMotionVectors = F.iface.fpGetResource(&F.iface, F.shared[1]); + dd.reconstructedPrevNearestDepth = F.iface.fpGetResource(&F.iface, F.shared[2]); + // (no reactive or transparency mask, no exposure: the SDK's defaults, zero and exposure 1) + dd.jitterOffset = {f->jx, f->jy}; + dd.motionVectorScale = {1.0f, 1.0f}; // render pixels already + dd.renderSize = {f->w, f->h}; + dd.upscaleSize = {f->ow, f->oh}; + dd.enableSharpening = false; // the present's RCAS (upscaler = fsr, sharpness) is the one sharpening pass + dd.sharpness = 0.0f; + dd.frameTimeDelta = f->dt_ms; + dd.preExposure = 1.0f; + dd.reset = f->reset != 0; + dd.cameraNear = f->near_m; + dd.cameraFar = f->far_m; + dd.cameraFovAngleVertical = f->fov_y; + dd.viewSpaceToMetersFactor = 1.0f; // (TotK's units are meters) + static int view = -1; // TOTK_FSR3_VIEW=1: FSR's own debug view of its inputs and state + if (view < 0) view = rt_knob("FSR3_VIEW", "0"); + if (view) dd.flags |= FFX_FSR3UPSCALER_DISPATCH_DRAW_DEBUG_VIEW; + FfxErrorCode e = ffxFsr3UpscalerContextDispatch(&F.ctx, &dd); + F.n++; + if (e != FFX_OK) { + rt_log("fsr3: dispatch failed (%#x) at %ux%u -> %ux%u: FSR 3.1 off for this run", (unsigned)e, f->w, f->h, f->ow, + f->oh); + F.failed = true; + return 0; + } + return 1; +} + +extern "C" void fsr3_release(void) { + VkCtx *c = vk_ctx(); + if (!c || !c->device || (!F.live && !F.scratch)) return; + vkDeviceWaitIdle(c->device); + if (F.waits) rt_log("fsr3: %llu dispatches waited for an earlier one's submission", (unsigned long long)F.waits); + destroy(); +} diff --git a/runtime/vk_fsr3.h b/runtime/vk_fsr3.h new file mode 100644 index 00000000..c367c25b --- /dev/null +++ b/runtime/vk_fsr3.h @@ -0,0 +1,40 @@ +// AMD FSR 3.1 temporal upscaler (vk_fsr3.cpp): the FidelityFX SDK 1.1.4's upscaler (third_party/FidelityFX, MIT) on +// its Vulkan backend, the other engine of vk_dlaa.c's DLSS point. The same scene light, depth, motion vectors and +// jitter go to FSR 3.1 instead of NGX, on any GPU the back end runs on. Plain C interface: the SDK is C++. +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + VkImage color; // the scene's light (level 0, layer 0; R11G11B10F or RGBA16F, linear), w x h + VkFormat color_format; + VkImage depth; // its D32F depth (level 0, layer 0), w x h, standard direction (0 near) + VkImage mv; // RG16F motion vectors, w x h: last frame's window position minus this frame's, render + // pixels, without the jitter (vk_dlaa.c mv_pass, with the per-object pass) + VkImage out; // RGBA16F with storage, ow x oh: the upscaled scene + uint32_t w, h, ow, oh; + float jx, jy; // the jitter the scene was drawn with, render pixels (x right, y down) + float near_m, far_m, fov_y; // the camera's planes (m) and vertical field of view (radians) + float dt_ms; // time since the last upscaled frame + int reset; // no usable history (a cut, a new size, the first frame) + uint64_t fence; // the submission's timeline value (VkExec.fence) +} Fsr3Frame; + +// Records FSR 3.1 into cb (every image in VK_IMAGE_LAYOUT_GENERAL, left so; no render pass open; recorder drained by the +// caller). The context is made at the first call and made again when the output size changes; the scene may be any +// size up to the output (the modes, the dynamic resolution). 0 when it failed (logged; FSR 3.1 stays off for the run). +int fsr3_dispatch(VkCommandBuffer cb, const Fsr3Frame *f); +// vk_device.c destroy_all, before the device goes away; harmless when nothing was made. +void fsr3_release(void); +// vk_fg.cpp ffxGetPermutationBlobByIndex for FFX_EFFECT_FSR3UPSCALER: the blob of pass (FfxFsr3UpscalerPass) for the +// SDK's permutation options into out (an FfxShaderBlob). 0: no shader for that pass. +int vk_fsr3_blob(uint32_t pass, uint32_t options, void *out); + +#ifdef __cplusplus +} +#endif diff --git a/runtime/vk_mvprev.c b/runtime/vk_mvprev.c index 386c48c9..953a18a8 100644 --- a/runtime/vk_mvprev.c +++ b/runtime/vk_mvprev.c @@ -1,6 +1,6 @@ -// Last frame's object and bone blocks, for per-object motion vectors (TOTK_DLAA_OBJMV, on with DLAA). The banks kept -// start as c5, c7 and c14 and grow with what the vertex shader variants read (vk_mvprev_want); c7 and c5 are described -// here, the others follow the same two-copy rule. +// Last frame's object and bone blocks, for per-object motion vectors (TOTK_DLAA_OBJMV, on with DLSS or FSR 3.1). The +// banks kept start as c5, c7 and c14 and grow with what the vertex shader variants read (vk_mvprev_want); c7 and c5 are +// described here, the others follow the same two-copy rule. // // The scene's vertex shaders read an object's place from bank c7 (gsys_shape: one 3x4 matrix at the start of a // 0x100 block) and a skinned object's bones from c5 (gsys_skeleton: a run of 3x4 matrices), of this frame only. The @@ -172,8 +172,9 @@ static void mvprev_draw_(VkExec *ex) { } void vk_mvprev_frame(void) { - // without DLSS (no NGX, no RTX GPU, dlaa = 0) nothing reads last frame's blocks: P.on stays 0, no tables - if (!vk_dlaa_available()) return; + // without an upscaler that reads the motion (DLSS with NGX up, or FSR 3.1) nothing reads last frame's blocks: P.on + // stays 0, no tables + if (!vk_objmv_wanted()) return; if (P.knob < 0) { P.knob = rt_knob("DLAA_OBJMV", "1"); if (P.knob) { @@ -186,7 +187,7 @@ void vk_mvprev_frame(void) { P.timed = rt_knob("MVOBJ_TIMES", "0"); } } - int on = P.knob && cfg_bool("TOTK_DLAA"); + int on = P.knob && vk_upscaler_on(); if (on != (P.on > 0)) { P.on = on ? 1 : -1; if (P.t[0]) memset(P.t[0], 0, TABLE * sizeof(Seen)), memset(P.t[1], 0, TABLE * sizeof(Seen)); diff --git a/runtime/vk_usnap.c b/runtime/vk_usnap.c index 43356141..f360e130 100644 --- a/runtime/vk_usnap.c +++ b/runtime/vk_usnap.c @@ -37,9 +37,10 @@ typedef struct Arena { VkBuffer buf; VmaAllocation alloc; uint8_t *map; - uint8_t *cpu; // with DLSS (vk_dlaa_available), the same bytes in host memory for the CPU's reads (vk_usnap_bytes): - // map is often device memory through the BAR, written fast but read back at about a microsecond a - // cache line. Without DLSS nothing reads them back, and the bytes go into map in one copy. + uint8_t *cpu; // with the per-object motion (vk_objmv_wanted: DLSS or FSR 3.1), the same bytes in host memory for + // the CPU's reads (vk_usnap_bytes): map is often device memory through the BAR, written fast but + // read back at about a microsecond a cache line. Without it nothing reads them back, and the bytes + // go into map in one copy. uint64_t size; } Arena; @@ -289,7 +290,7 @@ void vk_usnap_begin(const uint64_t *handles, int n, uint64_t fence) { if (!U.nreg) return; if (!(U.arena = arena_get(total))) return; uint8_t *dst = U.arena->map; - if (vk_dlaa_available()) { + if (vk_objmv_wanted()) { if (!U.arena->cpu && !(U.arena->cpu = malloc(U.arena->size))) rt_fatal("vk_usnap: out of memory"); dst = U.arena->cpu; } diff --git a/tools/ffx_shaders.py b/tools/ffx_shaders.py index 47e6983b..e248dc4f 100644 --- a/tools/ffx_shaders.py +++ b/tools/ffx_shaders.py @@ -1,20 +1,24 @@ #!/usr/bin/env python3 -"""FidelityFX frame interpolation and optical flow shaders -> one C header (runtime/vk_fg.cpp). +"""FidelityFX frame interpolation, optical flow and FSR 3 upscaler shaders -> C headers (runtime/vk_fg.cpp, +runtime/vk_fsr3.cpp). -Ported from Savage Wind (https://github.com/Revivedx/SavageWindRecomp, MIT), tools/ffx_shaders.py, without its FSR 3 -upscaler effect. +Ported from Savage Wind (https://github.com/Revivedx/SavageWindRecomp, MIT), tools/ffx_shaders.py. The SDK builds its shader "permutation" headers with FidelityFX_SC.exe (a Windows-only wrapper around glslang that also writes each shader's resource bindings). This does the same with glslangValidator and a small SPIR-V reader, for the permutations used here only: wave32, 32-bit floats, low-resolution motion vectors without jitter, and both -depth directions (frame interpolation); SDR luma (optical flow). The backend (ffx_vk.cpp) takes each blob with its +depth directions (frame interpolation); SDR luma (optical flow); HDR input (the scene's linear light before the +bloom), low-resolution motion vectors without jitter, depth not inverted, the reference (not LUT) Lanczos and Savage +Wind's Catmull-Rom history reprojection, in 32-bit and 16-bit floats (FSR 3 upscaler; its accumulate pass twice, +without and with sharpening, FFX_FSR3UPSCALER_PASS_ACCUMULATE / _SHARPEN). The backend (ffx_vk.cpp) takes each blob with its bindings by name, as FidelityFX_SC writes them. The header is committed (AMD shader builds, no game data), so building totk.exe needs no shader compiler; run this after changing the GLSL or this script: - python tools/ffx_shaders.py [] [] + python tools/ffx_shaders.py [--effects fi,of | fu] [] [] -The defaults are runtime/third_party/FidelityFX/spirv/ffx_shaders_vk.h and glslangValidator from MSYS2 UCRT64 -(C:/msys64/ucrt64/bin) or PATH; the Vulkan SDK's works too. +--effects picks the header: fi,of (the default: frame interpolation and optical flow, spirv/ffx_shaders_vk.h) or fu +(the FSR 3 upscaler, spirv/ffx_fsr3upscaler_vk.h), so that regenerating one does not rewrite the other's blobs. The +other defaults are glslangValidator from MSYS2 UCRT64 (C:/msys64/ucrt64/bin) or PATH; the Vulkan SDK's works too. """ import os import struct @@ -41,6 +45,21 @@ FI_DEFS = ['-DFFX_FRAMEINTERPOLATION_OPTION_UPSAMPLE_SAMPLERS_USE_DATA_HALF=0', '-DFFX_FRAMEINTERPOLATION_OPTION_LOW_RES_MOTION_VECTORS=1', '-DFFX_FRAMEINTERPOLATION_OPTION_JITTER_MOTION_VECTORS=0'] OF_DEFS = ['-DFFX_OPTICALFLOW_OPTION_HDR_COLOR_INPUT=0'] +FU_PASSES = [ # FfxFsr3UpscalerPass order: (shader, sharpening); None: no shader (the deprecated TCR pass) + ('prepare_inputs_pass', 0), ('luma_pyramid_pass', 0), ('shading_change_pyramid_pass', 0), ('shading_change_pass', 0), + ('prepare_reactivity_pass', 0), ('luma_instability_pass', 0), ('accumulate_pass', 0), ('accumulate_pass', 1), + ('rcas_pass', 0), ('debug_view_pass', 0), ('autogen_reactive_pass', 0), None] +FU_DEFS = ['-DFFX_FSR3UPSCALER_OPTION_UPSAMPLE_SAMPLERS_USE_DATA_HALF=0', + '-DFFX_FSR3UPSCALER_OPTION_ACCUMULATE_SAMPLERS_USE_DATA_HALF=0', + '-DFFX_FSR3UPSCALER_OPTION_REPROJECT_SAMPLERS_USE_DATA_HALF=1', + '-DFFX_FSR3UPSCALER_OPTION_POSTPROCESSLOCKSTATUS_SAMPLERS_USE_DATA_HALF=0', + '-DFFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE=2', + '-DFFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE=2', + '-DFFX_FSR3UPSCALER_OPTION_REPROJECT_CATMULL_ROM_5=1', + '-DFFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT=1', + '-DFFX_FSR3UPSCALER_OPTION_LOW_RESOLUTION_MOTION_VECTORS=1', + '-DFFX_FSR3UPSCALER_OPTION_JITTERED_MOTION_VECTORS=0', + '-DFFX_FSR3UPSCALER_OPTION_INVERTED_DEPTH=0'] # SPIR-V opcodes / enums used below OP_NAME, OP_ENTRY, OP_CONSTANT, OP_DECORATE, OP_MEMBER_DECORATE = 5, 15, 43, 71, 72 @@ -134,8 +153,13 @@ def default_glslang(): def main(): args = sys.argv[1:] effects = {'fi', 'of'} + if '--effects' in args: + k = args.index('--effects') + effects = set(args[k + 1].split(',')) + del args[k:k + 2] sdk = str(ROOT / 'runtime' / 'third_party' / 'FidelityFX' / 'sdk') - out = args[0] if args else str(ROOT / 'runtime' / 'third_party' / 'FidelityFX' / 'spirv' / 'ffx_shaders_vk.h') + spirv = ROOT / 'runtime' / 'third_party' / 'FidelityFX' / 'spirv' + out = args[0] if args else str(spirv / ('ffx_fsr3upscaler_vk.h' if effects == {'fu'} else 'ffx_shaders_vk.h')) glslang = args[1] if len(args) > 1 else default_glslang() gpu = os.path.join(sdk, 'include', 'FidelityFX', 'gpu') shaders = os.path.join(sdk, 'src', 'backends', 'vk', 'shaders') @@ -150,6 +174,15 @@ def main(): src = os.path.join(shaders, 'opticalflow', 'ffx_opticalflow_%s.glsl' % p) spv = compile_glsl(glslang, src, [gpu, os.path.join(gpu, 'opticalflow')], OF_DEFS) blobs.append(('of_%s' % p, spv, reflect(spv))) + for half in (0, 1) if 'fu' in effects else (): # (16-bit floats where the SDK asks and the device has them) + for e in FU_PASSES: + if e is None: + continue + p, sharpen = e + src = os.path.join(shaders, 'fsr3upscaler', 'ffx_fsr3upscaler_%s.glsl' % p) + spv = compile_glsl(glslang, src, [gpu, os.path.join(gpu, 'fsr3upscaler')], + FU_DEFS + ['-DFFX_FSR3UPSCALER_OPTION_APPLY_SHARPENING=%d' % sharpen], half) + blobs.append(('fu%d_%s_%d' % (half, p, sharpen), spv, reflect(spv))) L = ['// Generated by tools/ffx_shaders.py from the AMD FidelityFX SDK (MIT, see runtime/third_party/FidelityFX/LICENSE.txt).', '// Do not edit.', '#pragma once', '#include ', ''] for cname, spv, refl in blobs: @@ -191,6 +224,16 @@ def main(): L.append('static const FfxShaderBlob ffx_of_blobs[%d] = {' % len(OF_PASSES)) L += [blob(c, r) for c, _, r in blobs if c.startswith('of_')] L.append('};') + if 'fu' in effects: + L.append('// [16-bit floats][FfxFsr3UpscalerPass] (an empty blob: no shader)') + L.append('static const FfxShaderBlob ffx_fu_blobs[2][%d] = {' % len(FU_PASSES)) + refl = {c: r for c, _, r in blobs} + for half in (0, 1): + L.append(' {') + L += [' {},' if e is None else blob('fu%d_%s_%d' % ((half,) + e), refl['fu%d_%s_%d' % ((half,) + e)]) + for e in FU_PASSES] + L.append(' },') + L.append('};') with open(out, 'w', newline='\n') as f: f.write('\n'.join(L) + '\n') total = sum(len(s) for _, s, _ in blobs) diff --git a/totk.ini.example b/totk.ini.example index 9e34fb70..5fdc945c 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -22,8 +22,8 @@ # frame_queue = 0 # Frame generation: off, or fsr3 (AMD FSR 3 frame interpolation). A generated picture goes on screen between each two # the game draws: twice the pictures, the game at half of fps_limit (the limit counts the pictures shown), the controls -# about half a frame later. For displays of 120 Hz and more; off with DLSS or HDR, and in menus and fades. Applies at -# once. +# about half a frame later. For displays of 120 Hz and more; off with DLSS, FSR 3.1 (scene_upscaler) or HDR, and in +# menus and fades. Applies at once. # frame_gen = off # Real-time frame step: game speed follows the clock instead of the frame count. # realtime = 1 @@ -291,15 +291,22 @@ # shaders (translator patches 0010 and 0017), so the shader cache is rebuilt once after an update. Read at start. # pcss = 0 -# NVIDIA DLSS / DLAA for the 3D scene, on NVIDIA RTX GPUs with the DLSS model from NVIDIA's DLSS SDK next to the -# executable (Windows: nvngx_dlss.dll next to totk.exe; Linux: libnvidia-ngx-dlss.so. next to totk, with the -# NVIDIA driver's libnvidia-ngx.so.1 installed); elsewhere the setting does nothing. The HUD is drawn after it and is not touched. -# Read at start. +# The temporal upscaler for the 3D scene: off (the game's own scaling and FXAA), dlss (NVIDIA DLSS, on NVIDIA RTX GPUs +# with the DLSS model from NVIDIA's DLSS SDK next to the executable: Windows nvngx_dlss.dll next to totk.exe; Linux +# libnvidia-ngx-dlss.so. next to totk, with the NVIDIA driver's libnvidia-ngx.so.1 installed) or fsr3 (AMD FSR +# 3.1 from AMD's FidelityFX SDK, on any GPU). FSR 3.1 below native (dlss = quality and down) pays where the GPU limits +# the frame rate: integrated GPUs, weak cards, 4K output; where the CPU limits it, its own GPU and CPU time make the game +# slower. An engine that cannot run here leaves the game's own scaling in place. The HUD is drawn after it, at the +# output size, and is not touched. The present's upscaler and sharpness below still scale the game image to the window. +# Frame generation stays off with fsr3. Read at start. Without this line, dlaa = 1 (the older switch) means dlss. +# scene_upscaler = off +# The older DLSS switch, read only when scene_upscaler is not set: 1 is scene_upscaler = dlss. # dlaa = 0 -# What DLSS works from: dlaa (the 3D scene at full size), quality, balanced, performance or ultra_performance (the -# scene at 67, 58, 50 or 33 % of the output, scaled up by DLSS; these replace render_scale and sharpen texture filtering -# to match). They apply only with dlaa = 1 and the DLSS model next to the executable; otherwise the scene follows -# render_scale. Changes while the game runs take effect at once (1.4.3; 1.2.1 at the next start). +# The upscaling mode of the scene upscaler, DLSS or FSR 3.1: dlaa (native: the 3D scene at full size, anti-aliased +# only), quality, balanced, performance or ultra_performance (the scene at 67, 58, 50 or 33 % of the output, scaled up by +# the upscaler; these replace render_scale and sharpen texture filtering to match). They apply only while a scene +# upscaler runs; otherwise the scene follows render_scale. Changes while the game runs take effect at once (1.4.3; 1.2.1 +# at the next start). # dlss = dlaa # The DLSS model: default (NVIDIA's advice per mode: K for dlaa, quality and balanced, M for performance, L for # ultra_performance), k (K in every mode) or j (the other transformer model: slightly less ghosting behind moving From fef31d9f7cfce013b334c4a916c49019a88923d7 Mon Sep 17 00:00:00 2001 From: Valiantsin Dzerakh Date: Fri, 20 Nov 2026 16:10:46 +0300 Subject: [PATCH 2/7] FSR 3.1 sharpens its own picture at a new setting, fsr_sharpness (default 80, 0 off, live, a slider under the upscaler on the menu), as the game's sharpening sits in the FXAA draw FSR replaces; while FSR 3.1 runs the game's dynamic resolution stays at 100 %, and in place it skips the game's FXAA and its copy of the scene onto itself. The fix follows codexx-dev's pull request #1245. Town still view, 1080p, mean absolute Laplacian of luma: quality 5.2 -> 7.9 against 9.4 with FSR off. Co-Authored-By: Claude Opus 5.5 Co-Authored-By: codexx-dev <221918751+codexx-dev@users.noreply.github.com> --- runtime/cfg.c | 5 +++-- runtime/resolution.c | 18 ++++++++++++++---- runtime/ui/menu.cpp | 2 ++ runtime/ui_text.c | 8 ++++++++ runtime/ui_text.h | 3 ++- runtime/vk_dlaa.c | 40 ++++++++++++++++++++++++++++++++++++++-- runtime/vk_fsr3.cpp | 6 ++++-- runtime/vk_fsr3.h | 1 + totk.ini.example | 6 +++++- 9 files changed, 77 insertions(+), 12 deletions(-) diff --git a/runtime/cfg.c b/runtime/cfg.c index 566acbcc..76714066 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -44,7 +44,7 @@ static const char *const known[] = { "DESC_TEMPLATE", "DESWIZZLE", "DEVICE_PROFILE", "DIALOGUE_CLICK", "DISCORD_APP_ID", "DISCORD_IMAGE", "DISCORD_RPC", "DLAA", "DLAA_CAM_JITTER", "DLAA_EFFECTS_AFTER", "DLAA_JITTER", "DLAA_MV", "DLAA_MASKDEBUG", "DLAA_MVDEBUG", "DLAA_OBJMV", "DLAA_SURVEY", "DLAA_TIMES", "DLSS", "DLSS_CHAR_MASK", "DLSS_FIXED_EXPOSURE", "DLSS_PRESET", "DLSS_REACTIVE", "DUMP", "DUMP_BUF", "DUMP_DIR", "DUMP_LOG", "DYNAMIC_RES", "DYN_DELTA", "EXEFS", "FEEDBACK", "FG_DEBUG", "FG_SHOT", "FG_SHOT_DIR", "FG_TEST", "FG_TIMES", "FIXED_RES_PATCH", "FIX_C0", "FIX_ZERO", "FLIGHT", "FLIGHT_AT", "FLIGHT_DIR", "FLIGHT_FRAMES", "FLIGHT_SPIKE_MS", "FLIGHT_THUMBS", "FLUSH_SPAN", "FOV", "FOV_PATCH", "FPS60", "FPS_LIMIT", "FRAME_GEN", "FRAME_QUEUE", "FREECAM_KEY", "FREECAM_PAD", "FREECAM_PATCH", - "FREEZE_IDLE", "FREE_CORES", "FSR3_DEBUG", "FSR3_VIEW", + "FREEZE_IDLE", "FREE_CORES", "FSR3_DEBUG", "FSR3_VIEW", "FSR_SHARPNESS", "FULLSCREEN", "FXAA", "GAMEPLAY_DISTANCE_SENSITIVITY", "GAMEPLAY_ITEM_AD", "GAMEPLAY_ITEM_SENSITIVITY", "GAMEPLAY_ITEM_WHEEL", "GAMEPLAY_MAP_ZOOM", "GAMEPLAY_MAP_ZOOM_SENSITIVITY", "GAMEPLAY_ROTATION_SENSITIVITY", "GAMEPLAY_TWEAKS_ENABLED", @@ -85,7 +85,7 @@ static const struct { const char *key, *section; } sections[] = { {"COLOR_BRIGHTNESS", "display"}, {"COLOR_CONTRAST", "display"}, {"COLOR_SATURATION", "display"}, {"COLOR_GAMMA", "display"}, {"HDR", "display"}, {"HDR_PEAK_NITS", "display"}, {"HDR_GAME_NITS", "display"}, {"HDR_UI_NITS", "display"}, {"HDR_HUE", "display"}, {"SHADOW_RES", "display"}, - {"SCENE_UPSCALER", "display"}, {"DLAA", "display"}, {"DLSS", "display"}, {"DLSS_PRESET", "display"}, {"DLSS_CHAR_MASK", "display"}, {"DLSS_FIXED_EXPOSURE", "display"}, {"DLAA_EFFECTS_AFTER", "display"}, {"REFLEX", "display"}, {"FXAA", "display"}, + {"SCENE_UPSCALER", "display"}, {"DLAA", "display"}, {"DLSS", "display"}, {"FSR_SHARPNESS", "display"}, {"DLSS_PRESET", "display"}, {"DLSS_CHAR_MASK", "display"}, {"DLSS_FIXED_EXPOSURE", "display"}, {"DLAA_EFFECTS_AFTER", "display"}, {"REFLEX", "display"}, {"FXAA", "display"}, {"DEVICE_PROFILE", "display"}, {"ASSUME_FOCUS", "display"}, {"DISCORD_RPC", "discord"}, {"DISCORD_APP_ID", "discord"}, {"DISCORD_IMAGE", "discord"}, {"SHADOW_SCALE", "display"}, {"SHADOW_RANGE", "display"}, {"GRASS_RANGE", "display"}, {"CONTACT_SHADOWS", "display"}, @@ -143,6 +143,7 @@ static const CfgMeta metas[] = { {"UPSCALER", "fsr", "fsr|bilinear", LIVE}, {"SHARPNESS", "80", "0..100", LIVE}, {"SCENE_UPSCALER", "off", "off|dlss|fsr3", RESTART}, {"DLAA", "0", "0|1", RESTART}, {"DLSS", "dlaa", "dlaa|quality|balanced|performance|ultra_performance", LIVE}, + {"FSR_SHARPNESS", "80", "0..100", LIVE}, // vk_dlaa.c fsr_evaluate {"DLSS_PRESET", "default", "default|k|j", LIVE}, {"DLSS_FIXED_EXPOSURE", "0", "0|1", LIVE}, {"DLAA_EFFECTS_AFTER", "0", "0|1", LIVE}, {"DLSS_CHAR_MASK", "65", "0|35|65|100", LIVE}, {"REFLEX", "off", "off|on|boost", RESTART}, {"FXAA", "1", "0|1", LIVE}, {"LOD_STEADY", "0", "0|1", RESTART}, // sets steady diff --git a/runtime/resolution.c b/runtime/resolution.c index 57de14f9..420f0dc5 100644 --- a/runtime/resolution.c +++ b/runtime/resolution.c @@ -674,19 +674,29 @@ void res_fov_live(void) { // 2867-wide scene stays at 100 %, one wider than about 2970 does not, and a 4267-wide one (5120x1440 at render_scale // 83) fits no tier and falls back to 80 % every frame, whatever the GPU's load. 1 (the default) leaves the game's own // stepping and the set off. Runs on a settings change (gfx_present.c window_settings_live), like res_fov_live. +// FSR 3.1 as the scene upscaler holds it at 100 % whatever dynamic_res says, as codexx-dev's pull request #1245 does +// for its FSR: each tier is a scene of another size, so every step starts FSR's history again, and below 100 % the +// game ends its frame another way (a frame log on 1.4.3: its copy shader scales the scene straight into the +// output-sized target instead of the scaling FXAA draw), which #1245 measured as a picture that went soft and sharp in +// turns at a 2560x1440 scene. A 1280x720 scene (1080p, quality) stayed at 100 % through a 70 s town run, so it gains +// nothing there; the hold matters for the wide scenes the cost model steps down. void res_dynres_live(void) { static int set = -2, shown = -1; if (set == -2) set = rt_patch_set("fixres"); - int dyn = cfg_bool("TOTK_DYNAMIC_RES"); - if (dyn == shown) return; - shown = dyn; + int fsr = vk_upscaler_on() && vk_upscaler_engine() == UPSCALER_FSR3; + int dyn = cfg_bool("TOTK_DYNAMIC_RES") && !fsr; + int state = dyn | fsr << 1; + if (state == shown) return; + shown = state; if (set < 0) { if (!dyn) rt_log("resolution: this game version has no fixed-resolution patch; the game keeps its dynamic resolution"); return; } rt_patch_switch(set, !dyn); rt_log("resolution: dynamic resolution %s", - dyn ? "on: the game's own 100, 90 or 80 %" : "off: the scene stays at 100 %"); + dyn ? "on: the game's own 100, 90 or 80 %" + : fsr ? "off while FSR 3.1 upscales the scene: the scene stays at 100 %" + : "off: the scene stays at 100 %"); } void res_wanted(unsigned out[2]) { diff --git a/runtime/ui/menu.cpp b/runtime/ui/menu.cpp index 0513c7ba..60684572 100644 --- a/runtime/ui/menu.cpp +++ b/runtime/ui/menu.cpp @@ -827,6 +827,8 @@ static void tab_screen(float scale) { UI_MENU_DLSS_PERFORMANCE, UI_MENU_DLSS_ULTRA}; opt_choice("TOTK_DLSS", UI_MENU_DLSS, dlss, 5, UI_MENU_DLSS_DESC); } + if (!strcmp(engine, "fsr3")) // FSR 3.1's own sharpening (vk_dlaa.c fsr_evaluate) + opt_slider("TOTK_FSR_SHARPNESS", UI_MENU_FSR3_SHARPNESS, 0, 100, UI_MENU_FSR3_SHARPNESS_DESC, 5, "%.0f %%"); if (!strcmp(engine, "dlss")) { // DLSS's model, its characters' mask and its other switches (FSR 3.1 has none) static const UiTextId preset[] = {UI_MENU_DLSS_PRESET_DEFAULT, UI_MENU_DLSS_PRESET_K, UI_MENU_DLSS_PRESET_J}; opt_choice("TOTK_DLSS_PRESET", UI_MENU_DLSS_PRESET, preset, 3, UI_MENU_DLSS_PRESET_DESC); diff --git a/runtime/ui_text.c b/runtime/ui_text.c index 8c96fa3a..5d2a1a8f 100644 --- a/runtime/ui_text.c +++ b/runtime/ui_text.c @@ -189,6 +189,8 @@ static const char *const text_en[UI_TEXT_COUNT] = { [UI_MENU_SCENE_UPSCALER_FSR3] = "AMD FSR 3.1", [UI_MENU_SCENE_UPSCALER_NO_DLSS_GPU] = "DLSS: needs an NVIDIA RTX GPU", [UI_MENU_SCENE_UPSCALER_NO_DLSS_DLL] = "DLSS: " DLSS_FILE " is missing", + [UI_MENU_FSR3_SHARPNESS] = "FSR 3.1 sharpness", + [UI_MENU_FSR3_SHARPNESS_DESC] = "Sharpening of the 3D scene after FSR 3.1; 0 turns it off.", [UI_MENU_FPS_LIMIT] = "Frame rate limit", [UI_MENU_FPS_LIMIT_DESC] = "The most frames per second the game draws. Above 60 is experimental and needs Game speed " @@ -833,6 +835,8 @@ static const char *const text_ru[UI_TEXT_COUNT] = { [UI_MENU_SCENE_UPSCALER_FSR3] = "AMD FSR 3.1", [UI_MENU_SCENE_UPSCALER_NO_DLSS_GPU] = "DLSS: нужна видеокарта NVIDIA RTX", [UI_MENU_SCENE_UPSCALER_NO_DLSS_DLL] = "DLSS: нет " DLSS_FILE, + [UI_MENU_FSR3_SHARPNESS] = "Резкость FSR 3.1", + [UI_MENU_FSR3_SHARPNESS_DESC] = "Повышение резкости 3D-сцены после FSR 3.1; 0 выключает его.", [UI_MENU_FPS_LIMIT] = "Ограничение частоты кадров", [UI_MENU_FPS_LIMIT_DESC] = "Наибольшее число кадров в секунду. Выше 60 — экспериментальный режим, нужна «Скорость " @@ -1944,6 +1948,8 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = { [UI_MENU_SCENE_UPSCALER_FSR3] = "AMD FSR 3.1", [UI_MENU_SCENE_UPSCALER_NO_DLSS_GPU] = "DLSS: precisa de uma GPU NVIDIA RTX", [UI_MENU_SCENE_UPSCALER_NO_DLSS_DLL] = "DLSS: falta o " DLSS_FILE, + [UI_MENU_FSR3_SHARPNESS] = "Nitidez do FSR 3.1", + [UI_MENU_FSR3_SHARPNESS_DESC] = "Aumento de nitidez da cena 3D após o FSR 3.1; 0 desliga.", [UI_MENU_TAB_CHEATS] = "Cheats", [UI_MENU_CHEATS_NONE] = "Nenhum cheat para esta versão do jogo. Os cheats de um mod são um arquivo de cheats do " "Atmosphere na pasta cheats dele, com o nome da build do jogo: mods\\\\cheats\\%s. " @@ -2697,6 +2703,8 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = { [UI_MENU_SCENE_UPSCALER_FSR3] = "AMD FSR 3.1", [UI_MENU_SCENE_UPSCALER_NO_DLSS_GPU] = "DLSS:需要 NVIDIA RTX 显卡", [UI_MENU_SCENE_UPSCALER_NO_DLSS_DLL] = "DLSS:缺少 " DLSS_FILE, + [UI_MENU_FSR3_SHARPNESS] = "FSR 3.1 锐度", + [UI_MENU_FSR3_SHARPNESS_DESC] = "FSR 3.1 之后 3D 场景的锐化强度;0 为关闭。", [UI_MENU_TAB_CHEATS] = "金手指", [UI_MENU_CHEATS_NONE] = "此游戏版本没有金手指。模组的金手指是它的 cheats 文件夹中以游戏构建命名的 Atmosphere " "金手指文件:mods\\<模组>\\cheats\\%s。重启游戏后才会读取。对于修改游戏代码的金手指," diff --git a/runtime/ui_text.h b/runtime/ui_text.h index da69fe77..3cdb2ff4 100644 --- a/runtime/ui_text.h +++ b/runtime/ui_text.h @@ -65,7 +65,8 @@ typedef enum { UI_MENU_DLSS_CHARS_OFF, UI_MENU_DLSS_CHARS_LIGHT, UI_MENU_DLSS_CHARS_MEDIUM, UI_MENU_DLSS_CHARS_FULL, UI_MENU_FXAA, UI_MENU_FXAA_DESC, UI_MENU_REFLEX, UI_MENU_REFLEX_DESC, UI_MENU_REFLEX_OFF, UI_MENU_REFLEX_ON, UI_MENU_REFLEX_BOOST, UI_MENU_SCENE_UPSCALER, UI_MENU_SCENE_UPSCALER_DESC, UI_MENU_SCENE_UPSCALER_OFF, UI_MENU_SCENE_UPSCALER_DLSS, - UI_MENU_SCENE_UPSCALER_FSR3, UI_MENU_SCENE_UPSCALER_NO_DLSS_GPU, UI_MENU_SCENE_UPSCALER_NO_DLSS_DLL, + UI_MENU_SCENE_UPSCALER_FSR3, UI_MENU_SCENE_UPSCALER_NO_DLSS_GPU, UI_MENU_SCENE_UPSCALER_NO_DLSS_DLL, UI_MENU_FSR3_SHARPNESS, + UI_MENU_FSR3_SHARPNESS_DESC, // Game UI_MENU_FPS_LIMIT, UI_MENU_FPS_LIMIT_DESC, UI_MENU_FPS_30, UI_MENU_FPS_40, UI_MENU_FPS_45, UI_MENU_FPS_60, UI_MENU_FPS_90, diff --git a/runtime/vk_dlaa.c b/runtime/vk_dlaa.c index de982d73..30ec999e 100644 --- a/runtime/vk_dlaa.c +++ b/runtime/vk_dlaa.c @@ -1291,10 +1291,15 @@ static int fsr_evaluate(VkExec *ex, struct Size *e, const VkExecTarget *t, const uint64_t now = plat_now_ns(); double dt = D.last_eval_ns ? (now - D.last_eval_ns) / 1e6 : 0; D.last_eval_ns = now; + // FSR's own sharpening (fsr_sharpness, live): the game's sharpening is part of its FXAA, which FSR's frames go + // without (vk_dlaa_skip_draw), so without it FSR's picture is softer than the game's own + int sharp = cfg_int("TOTK_FSR_SHARPNESS"); + sharp = sharp < 0 ? 0 : sharp > 100 ? 100 : sharp; Fsr3Frame fr = {.color = t->image, .color_format = t->format, .depth = z->image, .mv = e->mv, .out = e->out, .w = t->width, .h = t->height, .ow = ow, .oh = oh, .jx = jx, .jy = jy, .near_m = cam.near_m, .far_m = cam.infinite || cam.far_m <= cam.near_m ? 1e5f : cam.far_m, .fov_y = cam.fov_y, - .dt_ms = dt > 0 && dt < 100 ? (float)dt : 16.67f, .reset = D.reset, .fence = ex->fence}; + .dt_ms = dt > 0 && dt < 100 ? (float)dt : 16.67f, .reset = D.reset, .sharpness = sharp / 100.0f, + .fence = ex->fence}; uint64_t c0 = timed ? kern_now_ns() : 0; int ok = fsr3_dispatch(ex->cb, &fr); if (timed) T.cpu_ngx += kern_now_ns() - c0; @@ -1885,6 +1890,10 @@ void vk_dlaa_frame(void) { // stretched over the whole screen. static const uint64_t FXAA_FS[] = {0xf450003ebeb3dc52ull, 0x0a12f4bc2a9a4fbeull, 0x5c43ae18948d52cbull, 0xaad42238801d31d8ull, 0xde20aef90fea4ce6ull, 0x755964e8dce7f34dull}; +// The fragment shader of the FXAA's first pass, the copy of the scene target into the scratch target (this build's +// translator, seen in 1.4.3 frame logs; another hash leaves the draw alone). See vk_dlaa_skip_draw for why FSR 3.1's +// frames skip it where it copies the scene target onto itself. +static const uint64_t FXAA_COPY_FS[] = {0xa0fd34391f2af811ull}; // Chunks of one submission look shaders up side by side: an entry's hash is stored before its shader, and entries are // added under the lock. @@ -1929,7 +1938,16 @@ int vk_dlaa_skip_draw(VkExec *ex, const GfxShader *fs) { "FXAA_FS): the FXAA stays on", (unsigned long long)fx_off_frames); } } - if (fxaa && !D.up) return 0; // nothing to skip: no shader lookup per draw at the defaults + // FSR 3.1 in place (the scene as large as the output, so no scaling draw follows) goes without the game's FXAA + // and its copy of the scene target onto itself on every frame, as codexx-dev found for FSR (pull request #1245, + // vk_dlaa.c vk_dlaa_skip_draw there). Measured there on 1.4.3 at a 2560x1440 scene and output: with the upscaler on + // the game ran its FXAA, which also sharpens, on 17 frames in every 96 and on the others drew its copy shader from + // the scene target onto itself, so the picture went soft and sharp in turns. Here the dynamic resolution stays at + // 100 % while FSR 3.1 runs (resolution.c res_dynres_live) and FSR sharpens its own output (fsr_sharpness, + // fsr_evaluate) in place of the FXAA's sharpening. Scaled frames (D.up) need nothing more: there FSR's picture + // already replaces the scaling FXAA draw below. + int fsr_in_place = D.done && !D.up && D.fsr; + if (fxaa && !D.up && !fsr_in_place) return 0; // nothing to skip: no shader lookup per draw at the defaults if (!fs) return 0; // 1.2.1 scales the light target to the output with an upscaler of its own (12 texelFetch taps around the source // pixel, fragment shader e6f7ae35b8479ef3 with this build's translator), not with the FXAA one, in a pass without @@ -1949,6 +1967,24 @@ int vk_dlaa_skip_draw(VkExec *ex, const GfxShader *fs) { uint64_t h = spirv_hash(fs); int known = 0; for (size_t i = 0; i < sizeof FXAA_FS / sizeof FXAA_FS[0]; i++) known |= h == FXAA_FS[i]; + if (fsr_in_place) { + static int logged_fxaa, logged_copy; + if (known && ex->depth.image) { + if (!logged_fxaa) + logged_fxaa = 1, rt_log("dlaa: FSR 3.1 skips the game's FXAA (fragment shader %016llx) and sharpens its " + "own picture (fsr_sharpness)", (unsigned long long)h); + return 1; + } + int copy = 0; + for (size_t i = 0; i < sizeof FXAA_COPY_FS / sizeof FXAA_COPY_FS[0]; i++) copy |= h == FXAA_COPY_FS[i]; + if (copy && ex->color[0].image == D.color.image && vk_exec_draw_samples(ex, fs, D.color.img)) { + if (!logged_copy) + logged_copy = 1, rt_log("dlaa: FSR 3.1 skips the game's copy of the scene target onto itself (fragment " + "shader %016llx)", (unsigned long long)h); + return 1; + } + if (fxaa) return 0; + } if (!known) return 0; if (!ex->depth.image) return D.up; // the scaling pass, which DLSS replaced if (!fxaa && !fx_found) { diff --git a/runtime/vk_fsr3.cpp b/runtime/vk_fsr3.cpp index 2a088a7a..56e50721 100644 --- a/runtime/vk_fsr3.cpp +++ b/runtime/vk_fsr3.cpp @@ -233,8 +233,10 @@ extern "C" int fsr3_dispatch(VkCommandBuffer cb, const Fsr3Frame *f) { dd.motionVectorScale = {1.0f, 1.0f}; // render pixels already dd.renderSize = {f->w, f->h}; dd.upscaleSize = {f->ow, f->oh}; - dd.enableSharpening = false; // the present's RCAS (upscaler = fsr, sharpness) is the one sharpening pass - dd.sharpness = 0.0f; + // FSR's RCAS pass on its output (fsr_sharpness): the game's own sharpening is part of the scaling FXAA draw that + // FSR replaces, and the present's RCAS (upscaler = fsr, sharpness) only runs where it scales to the window + dd.enableSharpening = f->sharpness > 0.0f; + dd.sharpness = f->sharpness > 1.0f ? 1.0f : f->sharpness; dd.frameTimeDelta = f->dt_ms; dd.preExposure = 1.0f; dd.reset = f->reset != 0; diff --git a/runtime/vk_fsr3.h b/runtime/vk_fsr3.h index c367c25b..6cc7b8b0 100644 --- a/runtime/vk_fsr3.h +++ b/runtime/vk_fsr3.h @@ -22,6 +22,7 @@ typedef struct { float near_m, far_m, fov_y; // the camera's planes (m) and vertical field of view (radians) float dt_ms; // time since the last upscaled frame int reset; // no usable history (a cut, a new size, the first frame) + float sharpness; // FSR 3.1's own sharpening (RCAS) on its output, 0..1; 0 leaves the pass out uint64_t fence; // the submission's timeline value (VkExec.fence) } Fsr3Frame; diff --git a/totk.ini.example b/totk.ini.example index 5fdc945c..a1581d3b 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -228,7 +228,7 @@ # Dynamic resolution: 1 lets the game lower the scene to 90 or 80 % of that size, 0 keeps it at 100 %. The game decides # by a cost estimate made for the Switch, which grows with the scene's width and ignores how fast your GPU is: a # scene wider than about 3000 pixels can drop to 80 % on any GPU. 1 is the default. 1.1.0, 1.2.1 and 1.4.3. Changes in -# the menu take effect at once. +# the menu take effect at once. While FSR 3.1 upscales the scene (scene_upscaler = fsr3) it stays at 100 %. # dynamic_res = 1 # Scaling to the window when it is larger than the game resolution: fsr (AMD FSR 1) or bilinear, and FSR's sharpening # from 0 (off) to 100. Changes while the game runs take effect at once. @@ -308,6 +308,10 @@ # upscaler runs; otherwise the scene follows render_scale. Changes while the game runs take effect at once (1.4.3; 1.2.1 # at the next start). # dlss = dlaa +# FSR 3.1's own sharpening of the 3D scene, from 0 (off) to 100. The game's sharpening is part of its FXAA, which FSR +# 3.1 replaces, so at 0 FSR's picture is softer than the game's own. Only with scene_upscaler = fsr3. Changes while the +# game runs take effect at once. +# fsr_sharpness = 80 # The DLSS model: default (NVIDIA's advice per mode: K for dlaa, quality and balanced, M for performance, L for # ultra_performance), k (K in every mode) or j (the other transformer model: slightly less ghosting behind moving # characters, a little more flicker). Any other model by its letter, a to m: on slower RTX cards the older model e is From 28f3fcc8d5cc8f4f0fc13d32e68c82b513167410 Mon Sep 17 00:00:00 2001 From: Valiantsin Dzerakh Date: Fri, 20 Nov 2026 16:21:02 +0300 Subject: [PATCH 3/7] With FSR 3.1 upscaling, the scene's material textures take AMD's mip bias, log2(scene / output) - 1 (-1.58 at quality, -1 in place), where DLSS keeps NVIDIA's log2(scene / output); the bias follows the mode and the upscaler going on or off. Field still view at quality, 1080p, mean absolute Laplacian of luma on the far cliff: 2.31 -> 2.82 against 4.09 with FSR off; grass near Link unchanged (5.53 -> 5.56, its blades are flat-coloured geometry). FSR's auto exposure was tried with it and left out: grass softer (5.53 -> 4.96) with no visible gain. Co-Authored-By: Claude Opus 5.5 --- runtime/vk_dlaa.c | 12 +++++++----- runtime/vk_texture.c | 2 +- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/runtime/vk_dlaa.c b/runtime/vk_dlaa.c index 30ec999e..1929669b 100644 --- a/runtime/vk_dlaa.c +++ b/runtime/vk_dlaa.c @@ -1802,18 +1802,20 @@ void vk_dlaa_pass(VkExec *ex) { } // TOTK_DLSS, read at each present (the menu switches it live): the scene size of the mode (resolution.c) and the -// texture bias that goes with it while DLSS runs. +// texture bias that goes with it while the upscaler runs. DLSS takes NVIDIA's log2(scene / output); FSR 3.1 takes AMD's +// log2(scene / output) - 1 (FidelityFX FSR 3 upscaler docs, "Mipmap biasing"), so -1 also in place. The bias follows +// the mode and the upscaler going on or off; the engine is fixed for the run. static void dlss_mode(void) { static char mode[32]; - static int bias_on = -1; + static float bias; // what the material samplers have (vk_texture.c starts at 0) const char *m = cfg_value("TOTK_DLSS"); if (strcmp(m, mode)) { snprintf(mode, sizeof mode, "%s", m); res_dlss_mode(m); - bias_on = -1; } - int b = dl_active(); - if (b != bias_on) bias_on = b, vk_sampler_dlss_bias(b ? res_dlss_lod_bias() : 0.0f); + float b = 0.0f; + if (dl_active()) b = res_dlss_lod_bias() - (vk_upscaler_engine() == UPSCALER_FSR3 ? 1.0f : 0.0f); + if (b != bias) bias = b, vk_sampler_dlss_bias(b); } diff --git a/runtime/vk_texture.c b/runtime/vk_texture.c index 232b5b42..daad15bd 100644 --- a/runtime/vk_texture.c +++ b/runtime/vk_texture.c @@ -2719,7 +2719,7 @@ void vk_sampler_register(int id, const samp_par *s) { unlock(); } -// DLSS upscaling (vk_sampler_dlss_bias): the scene's material textures, the filtered mipmapped ones that repeat, are +// DLSS or FSR 3.1 upscaling (vk_sampler_dlss_bias): the scene's material textures, the filtered mipmapped ones that repeat, are // sampled for the output's resolution; clamped ones (post effects, LUTs, the UI) keep the game's bias. static float dlss_bias; From 9c0dc49dc5b812e51983022de029be901e6a57ea Mon Sep 17 00:00:00 2001 From: Valiantsin Dzerakh Date: Fri, 20 Nov 2026 19:22:11 +0300 Subject: [PATCH 4/7] On 1.4.3 the per-object motion vectors no longer carry the camera jitter: the motion draws run with the jittered scene camera again, so DLSS stops moving the history of characters by up to a pixel each frame (shaking, softness) (#1126) Since the jitter went into the game's camera (#1284), cam_unjitter writes the scene camera's snapshot back without it from the scene's end, before the DLSS point where vk_mvobj_execute redraws the moving objects through that snapshot. The draws rasterised unjittered and their fragment shader took the jitter off a second time. TOTK_MV_CHECK on a still Link (FSR 3.1 path, task/fsr31) measured the object part equal to the frame's jitter in every check; with the jittered rows written back around the motion draws and taken off after them, object pixels on a still Link fell from 1.2-2.1 % to about 0, and the object vectors beat the camera's (median end-point error 0.68 px against 0.88, before 0.93 against 0.82). Co-Authored-By: Claude Opus 5.5 --- runtime/vk_dlaa.c | 22 +++++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/runtime/vk_dlaa.c b/runtime/vk_dlaa.c index 1929669b..ba9044cd 100644 --- a/runtime/vk_dlaa.c +++ b/runtime/vk_dlaa.c @@ -543,6 +543,7 @@ static void times_begin(VkCommandBuffer cb) { static int cam_mode(void); // the jitter in the game's camera (below, "jitter in the game's camera") static int cam_offset(uint64_t blk, float *sx, float *sy); static int unj_put(VkCommandBuffer cb, const float *blk, float sx, float sy, VkBuffer buf, VkDeviceSize off); +static int unj_rows(VkCommandBuffer cb, const float *blk, float sx, float sy, VkBuffer buf, VkDeviceSize off, int keep); // The camera's motion first (runtime/shaders/dlaa_mv.comp): this frame's scene camera block is copied out of the // replay's uniform snapshot (vk_usnap.c, as of the submit call) into one slot of camb, last frame's stays in the other, // and the compute pass reprojects every pixel's depth through the two (inv4 and mv_pass below). Then the per-object @@ -741,7 +742,16 @@ static int mv_pass(VkExec *ex, struct Size *e, VkImageView zv, float jx, float j vk_mvcheck_camera(cb, e->mv, w, h, jx, jy); // TOTK_MV_CHECK (test) // the characters' own motion over the camera's (vk_exec_draw.c, per-object motion) uint64_t c0 = T.on > 0 ? kern_now_ns() : 0; + // The motion draws rasterise this frame's position through the scene camera's snapshot, and their fragment shader + // takes the jitter back off (vk_mvobj_fs.h). By now cam_unjitter has written that snapshot back without the jitter + // (it runs from the scene's end, for the effects), so the draws landed a jitter away from the scene's depth and + // their vectors carried the jitter: TOTK_MV_CHECK measured the object part equal to this frame's jitter in every + // check on a still Link, which moved the upscaler's history of characters by up to a pixel each frame (shaking, + // softness). The jittered rows go back for these draws and come off again after them. + int rejit = cb_bytes && unj_rows(cb, cb_bytes, 0.0f, 0.0f, cam.buffer, cam.offset, 1); + if (rejit) full_barrier(cb); if (vk_mvobj_execute(ex, D.cam_addr, e->mv_view, zv, D.depth.format, w, h)) full_barrier(cb); + if (rejit && unj_put(cb, cb_bytes, osx, osy, cam.buffer, cam.offset)) full_barrier(cb); if (T.on > 0) T.cpu_mv += kern_now_ns() - c0; times_mark(cb, T_OBJ); if (T.on > 0) T.used[T.slot] = 1; // the DLSS marks follow in evaluate @@ -1172,8 +1182,9 @@ static int cam_offset(uint64_t blk, float *sx, float *sy) { } // Records copies that write a block's view-projection rows 3-4 and projection rows 7-8 back without the offset (blk: -// the block's bytes as the snapshot holds them) into buf at off, the block's place there. 0: no room. -static int unj_put(VkCommandBuffer cb, const float *blk, float sx, float sy, VkBuffer buf, VkDeviceSize off) { +// the block's bytes as the snapshot holds them) into buf at off, the block's place there. keep: the rows as they are, +// with the offset (rejit). 0: no room. +static int unj_rows(VkCommandBuffer cb, const float *blk, float sx, float sy, VkBuffer buf, VkDeviceSize off, int keep) { if (!CJ.unj) { VkBufferCreateInfo bi = {.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .size = UNJ_SLOTS * 64u, .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT}; @@ -1188,7 +1199,8 @@ static int unj_put(VkCommandBuffer cb, const float *blk, float sx, float sy, VkB float v[16]; for (int k = 0; k < 4; k++) v[k] = blk[12 + k] - sx * blk[24 + k], v[4 + k] = blk[16 + k] - sy * blk[24 + k]; memcpy(v + 8, blk + 28, 32); - v[10] = 0.0f, v[14] = 0.0f; + if (keep) memcpy(v, blk + 12, 32); + else v[10] = 0.0f, v[14] = 0.0f; memcpy(CJ.unj_map + (size_t)sl * 64, v, sizeof v); vmaFlushAllocation(vk_ctx()->vma, CJ.unj_mem, (VkDeviceSize)sl * 64, 64); VkBufferCopy r[2] = {{(VkDeviceSize)sl * 64, off + 0x30, 32}, {(VkDeviceSize)sl * 64 + 32, off + 0x70, 32}}; @@ -1196,6 +1208,10 @@ static int unj_put(VkCommandBuffer cb, const float *blk, float sx, float sy, VkB return 1; } +static int unj_put(VkCommandBuffer cb, const float *blk, float sx, float sy, VkBuffer buf, VkDeviceSize off) { + return unj_rows(cb, blk, sx, sy, buf, off, 0); +} + // After the DLSS point, once in each command buffer of the frame: the snapshots of the blocks that took an offset are // written back without it, so the effects drawn over DLSS's picture use the camera unjittered, as before the move. static void cam_unjitter(VkExec *ex) { From 82a1f526a917eb048a3e066540e283f8844322df Mon Sep 17 00:00:00 2001 From: Valiantsin Dzerakh Date: Fri, 20 Nov 2026 19:44:10 +0300 Subject: [PATCH 5/7] The per-object motion keeps last frame's blocks only for the banks its listing looks up (c5, c6, c7, c14, c15 and c16 in the town and the field) instead of every bank a variant reads (c5 to c16 but c12): the scene draws stop probing the c8, c9, c10, c11 and c13 blocks into the table and the snapshot stops copying their neighbours, none of which a lookup ever read (c9 and c11 stay at this frame's block, the others belong to shaders that are not drawn again). The table entries of the banks looked up are the same as before, so the vectors are too. The listing's per-shader memo now comes before the shader's resource list and also keeps the filters' verdict, so a scene draw that is no candidate costs one memo probe. Noting only the candidates' blocks was tried and dropped: the table then misses the other draws' blocks, a sixth of the c7 "nearer" picks became "side" ones, the copies mo_similar refuses doubled and the field still check got 5 of 60 checks with over 0.5 % object pixels fit better by a variant (0 before). Co-Authored-By: Claude Opus 5.5 --- runtime/vk_exec_draw.c | 93 +++++++++++++++++++++++------------------- runtime/vk_mvprev.c | 13 ++++-- 2 files changed, 60 insertions(+), 46 deletions(-) diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index d65e9be5..6af8a2e1 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -3931,6 +3931,16 @@ static int mo_similar(const uint8_t *cur, const uint8_t *old, uint64_t n, int *c return 1; } +// The banks mo_prev_block leaves at this frame's block (TOTK_MVPREV_SKIP, bit n: cn; default c9 and c11, see there). +static uint32_t mo_skip(void) { + static long skip = -2; + if (skip == -2) { + const char *e = cfg_get("TOTK_MVPREV_SKIP"); + skip = e && *e ? strtol(e, NULL, 16) : 1L << 9 | 1L << 11; + } + return (uint32_t)skip; +} + // Last frame's copy of a block, accepted when it is this frame's block a little changed (mo_similar, // which see): a block of another object the address rule found would make motion up. 1 and *out: found (the block itself // when it is unchanged, *changed 0); 0: none, the draw keeps this frame's block there. @@ -3946,12 +3956,7 @@ static int mo_prev_block(int index, const p_bind_buf *u, VkDescriptorBufferInfo // got 1-3 px of motion that flipped direction, three times the warp error of the camera's vectors. With c9 kept too, // the turning run is as good (object warp error 0.46 of the camera's). Why their copies are wrong is not known. // TOTK_MVPREV_SKIP= (test) replaces the default a00 (bit n: cn). - static long skip = -2; - if (skip == -2) { - const char *e = cfg_get("TOTK_MVPREV_SKIP"); - skip = e && *e ? strtol(e, NULL, 16) : 1L << 9 | 1L << 11; - } - if (skip >> (index + 3) & 1) return 0; + if (mo_skip() >> (index + 3) & 1) return 0; uint64_t c0 = __builtin_ia32_rdtsc(); int found = vk_mvprev_find(index, u->addr, u->size, &pa, &how); uint64_t c1 = __builtin_ia32_rdtsc(); @@ -4003,22 +4008,31 @@ static void mvobj_draw_(VkExec *ex, const p_draw_idx *d, VkBuffer ib, VkDeviceSi // solid geometry only, which tests and writes the scene depth: effects, particles and screen quads write none, and // drawn again they would put their motion on the surfaces behind them (DLSS takes those from the surface) if (!D->B.st.ds.dt || !D->B.st.ds.dw) return; - // a vertex shader that reads a user bank besides the camera's (c4) may move on its own - const GfxShaderRes *ur; - int nu = gfx_shader_resources(D->B.st.vs, GFX_RES_UBO, &ur), reads = 0; - for (int i = 0; i < nu; i++) reads |= ur[i].slot >= 3 && ur[i].slot <= 16 && ur[i].slot != 4; - if (!reads) return; + // per vertex shader, kept: whether it reads a user bank besides the camera's (c4), so may move on its own; its + // variant (the translation of the same code and answers) with the banks the position depends on; whether the + // filters below take it (pass); and the binding indices whose last-frame blocks it looks up (look, bit n: index n = + // bank n + 3). The memo comes first: most scene draws are not candidates, and the shader's resource list was read for + // each of them. + static struct { const GfxShader *of, *vs; uint32_t banks, look; uint8_t reads, pass; } vmemo[4096]; + const GfxShader *of = D->B.st.vs; + uint32_t vi = (uint32_t)((uintptr_t)of * 0x9E3779B97F4A7C15ull >> 52); + if (vmemo[vi].of == of && !vmemo[vi].reads) return; + if (vmemo[vi].of != of) { + const GfxShaderRes *ur; + int nu = gfx_shader_resources(of, GFX_RES_UBO, &ur), reads = 0; + for (int i = 0; i < nu; i++) reads |= ur[i].slot >= 3 && ur[i].slot <= 16 && ur[i].slot != 4; + if (!reads) { + vmemo[vi].of = of, vmemo[vi].vs = NULL, vmemo[vi].banks = vmemo[vi].look = 0, vmemo[vi].reads = 0; + return; + } + } MO.cand++; uint64_t tp = t0 ? kern_now_ns() : 0; if (t0) MO.ns_part[0] += tp - t0, MO.n_part[0]++; uint64_t frame = __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED); if (MQ.frame != frame || MQ.fence != ex->fence || MQ.depth_fmt != z->format) mo_begin(ex, frame); if (!__atomic_load_n(&LIM.ubo_max, __ATOMIC_ACQUIRE)) limits_init(); - // the variant: the translation of the same code and answers, kept per shader once found; it names the banks the - // position depends on (0: none, the shader is skipped from then on) - static struct { const GfxShader *of, *vs; uint32_t banks; } vmemo[1024]; - uint32_t vi = (uint32_t)((uintptr_t)D->B.st.vs * 0x9E3779B97F4A7C15ull >> 54); - if (vmemo[vi].of != D->B.st.vs) { + if (vmemo[vi].of != of) { int has, pending = 0; sf_mvprev = 1; const GfxShader *v = shader_for(ex, NVN_STAGE_VS, &has, &pending, 0); @@ -4028,36 +4042,31 @@ static void mvobj_draw_(VkExec *ex, const p_draw_idx *d, VkBuffer ib, VkDeviceSi return; } GfxShaderIo io[32]; - uint32_t extra = gfx_shader_outputs(v, io) & ~gfx_shader_outputs(D->B.st.vs, io); + uint32_t extra = gfx_shader_outputs(v, io) & ~gfx_shader_outputs(of, io); uint32_t banks = extra ? gfx_shader_mvprev_banks(v) & 0x1fff8u : 0; - vmemo[vi].of = D->B.st.vs, vmemo[vi].vs = v, vmemo[vi].banks = banks; - vk_mvprev_want((banks & ~(1u << 4)) >> 3); // binding index = bank - 3 + // a position without the scene camera (c4) has a view of its own (c8 c9 c10 [c13]: its c8 is at a new address + // every frame, last frame's is never found): drawn again it would get this frame's view and no camera motion + // (TOTK_MV_CHECK while turning: 6.2 px end-point error against the camera vectors' 1.7) + static int noc4 = -1; + if (noc4 < 0) noc4 = rt_knob("MVOBJ_NOC4", "0"); // TOTK_MVOBJ_NOC4=1 (test): drawn again all the same + // only positions that read an object's own blocks: bones (c5), place (c7) or c6. The rest (terrain and grass: + // c14 c15 c16, with or without c9) measured no better than the camera's motion (TOTK_MV_CHECK, turning, those + // draws alone: object warp error 0.112 against the camera's 0.113, the object part 0.4 of what the picture + // shows) and were half the draws checked and listed. TOTK_MVOBJ_ALL=1 (test) takes them again. + static int all = -1; + if (all < 0) all = rt_knob("MVOBJ_ALL", "0"); + int pass = banks & ~(1u << 4) && (banks >> 4 & 1 || noc4) && (all || banks & (1u << 5 | 1u << 6 | 1u << 7)); + uint32_t look = pass ? (banks & ~(1u << 4) & ~mo_skip()) >> 3 : 0; // binding index = bank - 3 + vmemo[vi].of = of, vmemo[vi].vs = v, vmemo[vi].banks = banks, vmemo[vi].look = look; + vmemo[vi].reads = 1, vmemo[vi].pass = (uint8_t)pass; + vk_mvprev_want(look); + } + if (!vmemo[vi].pass) { + MO.no_out++; + return; } const GfxShader *vs = vmemo[vi].vs; uint32_t banks = vmemo[vi].banks; - if (!banks || !(banks & ~(1u << 4))) { - MO.no_out++; - return; - } - // a position without the scene camera (c4) has a view of its own (c8 c9 c10 [c13]: its c8 is at a new address every - // frame, last frame's is never found): drawn again it would get this frame's view and no camera motion - // (TOTK_MV_CHECK while turning: 6.2 px end-point error against the camera vectors' 1.7) - static int noc4 = -1; - if (noc4 < 0) noc4 = rt_knob("MVOBJ_NOC4", "0"); // TOTK_MVOBJ_NOC4=1 (test): drawn again all the same - if (!(banks >> 4 & 1) && !noc4) { - MO.no_out++; - return; - } - // only positions that read an object's own blocks: bones (c5), place (c7) or c6. The rest (terrain and grass: c14 - // c15 c16, with or without c9) measured no better than the camera's motion (TOTK_MV_CHECK, turning, those draws - // alone: object warp error 0.112 against the camera's 0.113, the object part 0.4 of what the picture shows) and - // were half the draws checked and listed. TOTK_MVOBJ_ALL=1 (test) takes them again. - static int all = -1; - if (all < 0) all = rt_knob("MVOBJ_ALL", "0"); - if (!all && !(banks & (1u << 5 | 1u << 6 | 1u << 7))) { - MO.no_out++; - return; - } // TOTK_MVOBJ_ONLY= (test): only draws whose position reads no bank outside the mask (bit n: cn) static long only = -2; if (only == -2) { diff --git a/runtime/vk_mvprev.c b/runtime/vk_mvprev.c index 953a18a8..c5e26f92 100644 --- a/runtime/vk_mvprev.c +++ b/runtime/vk_mvprev.c @@ -1,6 +1,11 @@ // Last frame's object and bone blocks, for per-object motion vectors (TOTK_DLAA_OBJMV, on with DLSS or FSR 3.1). The -// banks kept start as c5, c7 and c14 and grow with what the vertex shader variants read (vk_mvprev_want); c7 and c5 are -// described here, the others follow the same two-copy rule. +// banks kept start as c5, c7 and c14 and grow with the banks the per-object listing looks up (vk_exec_draw.c +// mvobj_draw_ calls vk_mvprev_want with them); c7 and c5 are described here, the others follow the same two-copy rule. +// Every scene draw notes its blocks of those banks: which of an object's two copies was last frame's is told apart from +// a neighbour object's copy only by knowing every block bound (noting only the listing's candidates turned a sixth of +// the c7 "nearer" picks into "side" ones and doubled the copies mo_similar refuses). The banks the listing never looks +// up (c9 and c11, which it leaves at this frame's block, and the banks of shaders it does not draw again) are left out: +// probing them for every scene draw, and copying their neighbours into the snapshot, bought nothing. // // The scene's vertex shaders read an object's place from bank c7 (gsys_shape: one 3x4 matrix at the start of a // 0x100 block) and a skinned object's bones from c5 (gsys_skeleton: a run of 3x4 matrices), of this frame only. The @@ -135,8 +140,8 @@ static void mvprev_draw_(VkExec *ex) { const VkExecTarget *z = &ex->depth; if (!z->image || z->width < DLAA_SCENE_MIN_W || z->format != VK_FORMAT_D32_SFLOAT) return; int check = P.bytes[0] != NULL; // TOTK_MVPREV_CHECK=1: the summary's checks (3.6 ms a frame) - for (int index = 0; index < BANKS; index++) { - if (!(P.mask >> index & 1)) continue; + for (uint32_t m = P.mask & ((1u << BANKS) - 1); m; m &= m - 1) { + int index = __builtin_ctz(m); const p_bind_buf *u = &ex->ubo[0][index]; if (!u->addr || !u->size || u->addr == P.last[index]) continue; // the next draws keep the block: noted already P.last[index] = u->addr; From b8edbdd8733f8863b0ec085d53a46a962f73d0cd Mon Sep 17 00:00:00 2001 From: Valiantsin Dzerakh Date: Fri, 20 Nov 2026 19:49:47 +0300 Subject: [PATCH 6/7] The per-object motion reads last frame's object and bone blocks from last frame's uniform snapshot, kept one more frame, instead of having every snapshot copy both neighbours of each such block: the town's snapshot was 2836 KiB a submission with the neighbours and 1916 KiB without, and each byte is copied twice with the motion on (into host memory for the CPU's reads, then into the device copy). vk_mvprev_find still picks the address; the block's bytes and the motion draw's descriptor come from vk_usnap_prev. A block bound at the same address both frames keeps this frame's copy, as before. Lifetime: a scene submission's arena (vk_usnap_scene, from the scene draws vk_mvprev notes) is kept at its vk_usnap_end as the last-frame copy instead of going to the free list at its fence. The next scene submission's end, or any end once the motion is off, hands the kept arena to the completion thread with that submission's fence, then keeps its own. The motion draws that bind the kept arena are listed and recorded within the next scene submission (vk_mvobj_execute drops a list of another fence), so the GPU has read it before that fence; the fences of one queue complete in order, so its own submission's reads are done too. One arena is held beyond those in flight, whatever the session length; vk_usnap_shutdown frees it with the others. A frame whose scene spans two submissions finds only the last one's blocks; the others keep the camera's motion. TOTK_MVPREV_CHECK=1 still copies the neighbours and compares them with the kept copy. Field still view, 28 s: the mv_prev lines intact 100 % in c5, c6, c7, c14, c15 and c16; over whole blocks 87 of 218320 last-frame copies differ from the neighbour copy (the game changed the other copy after last frame's submit; the kept copy is what last frame drew); mv_check 0 of 60 checks with over 0.5 % object pixels fit better by a variant, object end-point error median 0.98 px against the camera's 1.27; the c7 lookups split as before (nearer to side 1.87, reference 1.83). Co-Authored-By: Claude Opus 5.5 --- runtime/vk.h | 7 ++++++ runtime/vk_exec_draw.c | 18 ++++++++++--- runtime/vk_mvprev.c | 29 +++++++++++++-------- runtime/vk_usnap.c | 57 +++++++++++++++++++++++++++++++++++++++--- 4 files changed, 93 insertions(+), 18 deletions(-) diff --git a/runtime/vk.h b/runtime/vk.h index 2ad113f9..e96ae1ad 100644 --- a/runtime/vk.h +++ b/runtime/vk.h @@ -283,12 +283,19 @@ void vk_usnap_drop(uint64_t addr, uint64_t n); // the replay makes the GPU wri void vk_usnap_drop_at(uint64_t addr, uint64_t n, uint32_t at); uint64_t vk_usnap_gen(void); // changes whenever a binding may resolve differently void vk_usnap_shutdown(void); // vk_exec_draw_shutdown: frees the arenas +// The replay drew into the scene depth (vk_mvprev.c): with the per-object motion, this submission's arena is kept as +// the last-frame copy until the next scene submission's fence. +void vk_usnap_scene(void); +// [addr, addr+n) in the last scene submission's snapshot (last frame's blocks for the per-object motion): a descriptor +// (offset a multiple of align) and its bytes in host memory; 0: not in it. +int vk_usnap_prev(uint64_t addr, uint64_t n, uint64_t align, VkDescriptorBufferInfo *out, const uint8_t **bytes); // vk_mvprev.c: last frame's copy of the scene's object (c7) and bone (c5) blocks, for per-object motion vectors. // vk_mvprev_step: the distance of the game's other copy of a vertex-stage block the snapshot also copies, 0: none. // vk_mvprev_find: last frame's block of that object (prev, its address; how, MVPREV_*), 0: none. enum { MVPREV_NONE, MVPREV_SELF, MVPREV_SIDE, MVPREV_NEARER }; uint64_t vk_mvprev_step(int stage, int index, uint64_t size); int vk_mvprev_on(void); +int vk_mvprev_checking(void); // TOTK_MVPREV_CHECK on: the snapshot also copies the blocks' neighbours void vk_mvprev_want(uint32_t index_mask); // also keep these binding indices' last-frame copies (bit n: index n) // DLAA on and TOTK_DLAA_OBJMV not 0, as of the last present int vk_mvprev_find(int index, uint64_t addr, uint64_t size, uint64_t *prev, int *how); void vk_mvprev_frame(void); // each present, beside vk_dlaa_frame diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index 6af8a2e1..305d67a3 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -3575,6 +3575,7 @@ static struct { uint64_t no_out, storage, no_fs; // variant without the extra output, with storage resources; no fs uint64_t other_cam; // listed draws left out: their camera block is not the scene camera uint64_t lk[14][5]; // last-frame lookups per binding index: none, self, side, nearer, refused (another object) + uint64_t pv_cmp, pv_diff; // TOTK_MVPREV_CHECK: last-frame copies compared with this snapshot's neighbour, differing uint64_t e_draws, e_pipe, e_dyn, e_push, e_pushw, e_sets, e_vb, e_setw, e_setreuse; // emitted commands (summary) } MO; @@ -3962,13 +3963,19 @@ static int mo_prev_block(int index, const p_bind_buf *u, VkDescriptorBufferInfo uint64_t c1 = __builtin_ia32_rdtsc(); MO.cyc[0] += c1 - c0, MO.ncyc++, MO.big += n; if (index >= 0 && index < 14) MO.lk[index][found ? how : MVPREV_NONE]++; - if (!found || !vk_usnap_find(pa, n, UINT32_MAX, LIM.ubo_align, out)) return 0; - if (how == MVPREV_SELF) return 1; // bound at the same address last frame: not written again - const uint8_t *map = vk_usnap_map(), *cur = vk_usnap_bytes(u->addr, n); + if (!found) return 0; + // bound at the same address last frame: not written again, this frame's copy + if (how == MVPREV_SELF) return vk_usnap_find(pa, n, UINT32_MAX, LIM.ubo_align, out); + const uint8_t *old, *cur; // last frame's from last frame's snapshot (vk_usnap_prev), this frame's + if (!vk_usnap_prev(pa, n, LIM.ubo_align, out, &old)) return 0; + if (vk_mvprev_checking()) { // the neighbour copy the snapshot took before last frame's was kept: the same bytes? + const uint8_t *nb = vk_usnap_bytes(pa, n); + if (nb) MO.pv_cmp++, MO.pv_diff += memcmp(nb, old, n) != 0; + } + cur = vk_usnap_bytes(u->addr, n); uint64_t c2 = __builtin_ia32_rdtsc(); MO.cyc[1] += c2 - c1; if (!cur) return 0; - const uint8_t *old = map + out->offset; static long trust = -2; // TOTK_MVPREV_TRUST= (test): the copy found is taken without the check if (trust == -2) { const char *e = cfg_get("TOTK_MVPREV_TRUST"); @@ -4248,6 +4255,9 @@ int vk_mvobj_execute(VkExec *ex, uint64_t cam, VkImageView mv, VkImageView depth (unsigned long long)MO.lk[i][1], (unsigned long long)MO.lk[i][2], (unsigned long long)MO.lk[i][3], (unsigned long long)MO.lk[i][4]); if (o) rt_log("vk_exec: per-object motion last-frame lookups (none/self/side/nearer/refused):%s", l); + if (MO.pv_cmp) + rt_log("vk_exec: per-object motion last-frame copies against the neighbour copies: %llu compared, %llu differ", + (unsigned long long)MO.pv_cmp, (unsigned long long)MO.pv_diff); } if (frames % 60 == 0 && MO.ran) rt_log("vk_exec: per-object motion recorded a frame: %.0f draws, %.0f pipeline binds, %.0f dynamic states, %.0f " diff --git a/runtime/vk_mvprev.c b/runtime/vk_mvprev.c index c5e26f92..e38b9c94 100644 --- a/runtime/vk_mvprev.c +++ b/runtime/vk_mvprev.c @@ -5,22 +5,25 @@ // a neighbour object's copy only by knowing every block bound (noting only the listing's candidates turned a sixth of // the c7 "nearer" picks into "side" ones and doubled the copies mo_similar refuses). The banks the listing never looks // up (c9 and c11, which it leaves at this frame's block, and the banks of shaders it does not draw again) are left out: -// probing them for every scene draw, and copying their neighbours into the snapshot, bought nothing. +// probing them for every scene draw bought nothing. // // The scene's vertex shaders read an object's place from bank c7 (gsys_shape: one 3x4 matrix at the start of a // 0x100 block) and a skinned object's bones from c5 (gsys_skeleton: a run of 3x4 matrices), of this frame only. The // game writes both into two copies that take turns, the second right after the first: an object's block is at addr in // one frame and at addr +- step in the next, step its size rounded up to 256 bytes (vk_mvsurvey.c measured it: every -// c7 pair 0x100 apart, c5 pairs their rounded size apart, the pair's contents the same object moved a little). The -// copy this frame does not write still holds last frame's when the frame is submitted, so the uniform snapshot -// (vk_usnap.c) also copies both neighbours of these blocks, and vk_mvprev_find picks last frame's: -// self the block was bound at the same address last frame too (an object the game did not write again): itself +// c7 pair 0x100 apart, c5 pairs their rounded size apart, the pair's contents the same object moved a little). +// vk_mvprev_find picks last frame's address, and the bytes come from last frame's uniform snapshot (vk_usnap_prev: the +// scene submission's arena is kept one more frame), which holds what last frame's draws read there: +// self the block was bound at the same address last frame too (an object the game did not write again): itself, +// from this frame's snapshot // side one neighbour was bound in that bank last frame: that one // nearer both were (the copies of adjacent objects interleave): the one with more of its first 16 words equal to // this frame's // none neither: a new object, no motion of its own -// The pick is checked against what was snapshotted of that block last frame (intact: the same first CHECK bytes), and -// a summary goes to the log every SUMMARY frames: +// Until 2026-11-20 the snapshot copied both neighbours of every such block instead, as the copy this frame does not +// write still holds last frame's when the frame is submitted: a third of the snapshot's bytes. TOTK_MVPREV_CHECK=1 +// still copies them and checks that the neighbour picked holds what was snapshotted of that block last frame (intact: +// the same first CHECK bytes), so the two sources agree; a summary goes to the log every SUMMARY frames: // mv_prev: c: blocks: self a %, side b %, nearer c %, none d %; intact e %; moved: still f %, under // one unit g %, more h % #include @@ -81,6 +84,7 @@ static Seen *find(Seen *t, uint64_t addr, int index, int add) { } int vk_mvprev_on(void) { return P.on > 0; } +int vk_mvprev_checking(void) { return P.on > 0 && P.bytes[0]; } void vk_mvprev_want(uint32_t index_mask) { static int fixed = -1; @@ -89,7 +93,7 @@ void vk_mvprev_want(uint32_t index_mask) { } uint64_t vk_mvprev_step(int stage, int index, uint64_t size) { - if (P.on <= 0 || stage != 0 || index < 0 || index >= BANKS || !(P.mask >> index & 1)) return 0; + if (P.on <= 0 || !P.bytes[0] || stage != 0 || index < 0 || index >= BANKS || !(P.mask >> index & 1)) return 0; return (size + 255) & ~(uint64_t)255; } @@ -113,9 +117,11 @@ int vk_mvprev_find(int index, uint64_t addr, uint64_t size, uint64_t *prev, int if (addr >= step && find(P.t[1], addr - step, index, 0)) cand[n++] = addr - step; if (!n) return 0; if (n == 2) { // the copies of adjacent objects interleave: the one with more words equal to this frame's - const uint32_t *c = (const uint32_t *)vk_usnap_bytes(addr, 64), *a = (const uint32_t *)vk_usnap_bytes(cand[0], 64), - *b = (const uint32_t *)vk_usnap_bytes(cand[1], 64); - if (!c || !a || !b) return 0; + VkDescriptorBufferInfo bi; + const uint8_t *pa, *pb; + const uint32_t *c = (const uint32_t *)vk_usnap_bytes(addr, 64); + if (!c || !vk_usnap_prev(cand[0], 64, 1, &bi, &pa) || !vk_usnap_prev(cand[1], 64, 1, &bi, &pb)) return 0; + const uint32_t *a = (const uint32_t *)pa, *b = (const uint32_t *)pb; int na = 0, nb = 0; for (int w = 0; w < 16; w++) na += c[w] == a[w], nb += c[w] == b[w]; if (nb > na) cand[0] = cand[1]; @@ -139,6 +145,7 @@ void vk_mvprev_draw(VkExec *ex) { static void mvprev_draw_(VkExec *ex) { const VkExecTarget *z = &ex->depth; if (!z->image || z->width < DLAA_SCENE_MIN_W || z->format != VK_FORMAT_D32_SFLOAT) return; + vk_usnap_scene(); // this submission's snapshot is next frame's last-frame copy int check = P.bytes[0] != NULL; // TOTK_MVPREV_CHECK=1: the summary's checks (3.6 ms a frame) for (uint32_t m = P.mask & ((1u << BANKS) - 1); m; m &= m - 1) { int index = __builtin_ctz(m); diff --git a/runtime/vk_usnap.c b/runtime/vk_usnap.c index f360e130..6e5e1ad9 100644 --- a/runtime/vk_usnap.c +++ b/runtime/vk_usnap.c @@ -14,6 +14,12 @@ // A chunked replay (vk_exec.c) records the ops out of order: its scan drops at the position of the op // (vk_usnap_drop_at, scan_writes for the shaders' stores), and a chunk finds a copy only at a position before that. // - The arena goes back to a free list once the submission's fence is done (completion thread). +// - With the per-object motion, a scene submission's arena (vk_usnap_scene: the replay drew into the scene depth) is +// kept past its fence as the last-frame copy (PV): the next scene submission's motion draws bind last frame's blocks +// from it (vk_usnap_prev). It goes back to the free list at the fence of the submission that replaces or drops it, +// which is the submission whose motion draws read it (or a later one): its lists are recorded and run within that +// submission (vk_exec_draw.c vk_mvobj_execute drops a list of another fence), and the GPU finishes a submission's +// work, and every earlier one's, before its fence. One arena held beyond those in flight, whatever the session length. // The design follows MacNativeGames' TOTK_UBO_SNAPSHOT (games/totk/third_party/d2r_gfx/gfx/nvn/nvn_mtl.m usnap_take, // usnap_drop; MIT, Copyright (c) 2026 jhaizhou); the code is ours. // The copy is taken where vk_exec_record starts: at the submit call when the replay runs on the submitting thread, later @@ -64,6 +70,13 @@ static struct { } U; static Arena *free_arenas; +// the last scene submission's arena and regions (vk_usnap_prev); its regions' drop_at final +static struct { + Arena *arena; + Reg *reg; + int nreg, creg; +} PV; +static int scene; // vk_usnap_scene since the last vk_usnap_begin static PlatMutex free_lock = PLAT_MUTEX_INIT; static PlatMutex drop_lock = PLAT_MUTEX_INIT; // threads recording chunks of one submission drop concurrently @@ -131,8 +144,8 @@ static void collect(const op_hdr *h, int depth) { const p_bind_buf *b = a; if (b->addr && b->size) { uint64_t n = b->size < MAX_RANGE ? b->size : MAX_RANGE; - // the vertex stage's object and bone blocks: also the game's other copy on either side, which still - // holds last frame's (vk_mvprev.c) + // TOTK_MVPREV_CHECK: the vertex stage's object and bone blocks, also the game's other copy on either + // side, which still holds last frame's (vk_mvprev.c compares it with the last-frame copy) uint64_t step = vk_mvprev_step(b->stage, b->index, b->size); // which neighbours lie in an imported pool, per block and vk_mem_gen: the same blocks are bound by // many draws, and two resolves for each binding were a quarter of the snapshot's time @@ -303,10 +316,47 @@ void vk_usnap_begin(const uint64_t *handles, int n, uint64_t fence) { } void vk_usnap_end(uint64_t fence) { - if (U.arena) vk_completion_add(fence, arena_done, U.arena), U.arena = NULL; + int keep = __atomic_load_n(&scene, __ATOMIC_RELAXED) && U.arena && U.arena->cpu; + // a scene submission replaces the last-frame copy (or drops it, without a snapshot of its own); so does the motion + // going off, which no longer reads it + if (PV.arena && (__atomic_load_n(&scene, __ATOMIC_RELAXED) || !vk_mvprev_on())) + vk_completion_add(fence, arena_done, PV.arena), PV.arena = NULL, PV.nreg = 0; + if (keep) { + Reg *r = PV.reg; + int c = PV.creg; + PV.arena = U.arena, PV.reg = U.reg, PV.nreg = U.nreg, PV.creg = U.creg; + U.reg = r, U.creg = c, U.nreg = 0; + } else if (U.arena) { + vk_completion_add(fence, arena_done, U.arena); + } + U.arena = NULL; + __atomic_store_n(&scene, 0, __ATOMIC_RELAXED); U.on = 0, U.gen++; } +void vk_usnap_scene(void) { + if (!__atomic_load_n(&scene, __ATOMIC_RELAXED)) __atomic_store_n(&scene, 1, __ATOMIC_RELAXED); +} + +int vk_usnap_prev(uint64_t addr, uint64_t n, uint64_t align, VkDescriptorBufferInfo *out, const uint8_t **bytes) { + if (!PV.arena || !n) return 0; + int lo = 0, hi = PV.nreg; + while (lo < hi) { // first region whose end is above addr + int m = (lo + hi) / 2; + if (PV.reg[m].hi <= addr) lo = m + 1; + else hi = m; + } + if (lo >= PV.nreg) return 0; + const Reg *r = &PV.reg[lo]; + // a region a GPU write dropped held other bytes for the draws after it: left out, as vk_usnap_bytes does + if (r->drop_at != UINT64_MAX || addr < r->lo || addr + n > r->hi) return 0; + uint64_t off = r->off + (addr - r->lo); + if (off % align) return 0; + *out = (VkDescriptorBufferInfo){PV.arena->buf, off, n}; + *bytes = PV.arena->cpu + off; + return 1; +} + // First region whose end is above a. static int first_above(uint64_t a) { int lo = 0, hi = U.nreg; @@ -364,6 +414,7 @@ const uint8_t *vk_usnap_bytes(uint64_t addr, uint64_t n) { // The arenas back on the free list (vk_exec_draw_shutdown: the device is idle, every completion ran). void vk_usnap_shutdown(void) { plat_mutex_lock(&free_lock); + if (PV.arena) PV.arena->next = free_arenas, free_arenas = PV.arena, PV.arena = NULL; for (Arena *a = free_arenas, *next; a; a = next) next = a->next, vmaDestroyBuffer(vk_ctx()->vma, a->buf, a->alloc), free(a->cpu), free(a); free_arenas = NULL; plat_mutex_unlock(&free_lock); From 5e3475c58309317a60d721184a0bb33442474969 Mon Sep 17 00:00:00 2001 From: Valiantsin Dzerakh Date: Fri, 20 Nov 2026 19:53:34 +0300 Subject: [PATCH 7/7] With the per-object motion on, the uniform snapshot copies into host memory only the regions the CPU reads back (those holding a vertex-stage block of a bank the motion compares, or of the camera, c4) and writes the rest straight into the device copy, as with the motion off; before, the whole snapshot went through host memory, every byte copied twice. A host region is still copied into host memory first and from there into the device copy, so both hold the same bytes while the game writes guest memory. vk_usnap_bytes reads a host region's host copy and any other from the device copy (slow through the BAR, which only rare readers reach: the merged uniform updates and the test surveys), so every reader gets the bytes it got before. The last-frame copy (vk_usnap_prev) takes host regions only. The snapshot summary gives the bytes copied into host memory. Field still view, 28 s, TOTK_MVPREV_CHECK=1: mv_check 0 of 60 checks with over 0.5 % object pixels fit better by a variant; mv_prev intact 100 % in c5, c6, c7, c14, c15 and c16; 0 of 214238 last-frame copies differ from the neighbour copies. Co-Authored-By: Claude Opus 5.5 --- runtime/vk.h | 2 +- runtime/vk_mvprev.c | 1 + runtime/vk_mvsurvey.c | 5 ++- runtime/vk_usnap.c | 72 ++++++++++++++++++++++++++----------------- 4 files changed, 47 insertions(+), 33 deletions(-) diff --git a/runtime/vk.h b/runtime/vk.h index e96ae1ad..55094c1d 100644 --- a/runtime/vk.h +++ b/runtime/vk.h @@ -275,7 +275,6 @@ void vk_usnap_begin(const uint64_t *handles, int n, uint64_t fence); void vk_usnap_end(uint64_t fence); // at: the copies dropped at or before it are not found (vk_usnap_drop_at); UINT32_MAX outside a chunked replay. int vk_usnap_find(uint64_t addr, uint64_t n, uint64_t at, uint64_t align, VkDescriptorBufferInfo *out); -const uint8_t *vk_usnap_map(void); // a host copy of the current arena, at the offsets vk_usnap_find gives const uint8_t *vk_usnap_bytes(uint64_t addr, uint64_t n); // the copy of [addr, addr+n) as of the submit, NULL: none void vk_usnap_drop(uint64_t addr, uint64_t n); // the replay makes the GPU write [addr, addr+n) of guest memory // The state scan of a chunked replay (vk_exec.c): the op that writes [addr, addr+n) is the at-th that may; the chunks @@ -296,6 +295,7 @@ enum { MVPREV_NONE, MVPREV_SELF, MVPREV_SIDE, MVPREV_NEARER }; uint64_t vk_mvprev_step(int stage, int index, uint64_t size); int vk_mvprev_on(void); int vk_mvprev_checking(void); // TOTK_MVPREV_CHECK on: the snapshot also copies the blocks' neighbours +int vk_mvprev_kept(int index); // a vertex-stage binding index whose blocks the per-object motion compares void vk_mvprev_want(uint32_t index_mask); // also keep these binding indices' last-frame copies (bit n: index n) // DLAA on and TOTK_DLAA_OBJMV not 0, as of the last present int vk_mvprev_find(int index, uint64_t addr, uint64_t size, uint64_t *prev, int *how); void vk_mvprev_frame(void); // each present, beside vk_dlaa_frame diff --git a/runtime/vk_mvprev.c b/runtime/vk_mvprev.c index e38b9c94..a4262b04 100644 --- a/runtime/vk_mvprev.c +++ b/runtime/vk_mvprev.c @@ -85,6 +85,7 @@ static Seen *find(Seen *t, uint64_t addr, int index, int add) { int vk_mvprev_on(void) { return P.on > 0; } int vk_mvprev_checking(void) { return P.on > 0 && P.bytes[0]; } +int vk_mvprev_kept(int index) { return P.on > 0 && index >= 0 && index < BANKS && P.mask >> index & 1; } void vk_mvprev_want(uint32_t index_mask) { static int fixed = -1; diff --git a/runtime/vk_mvsurvey.c b/runtime/vk_mvsurvey.c index 293ddcb8..e70949a9 100644 --- a/runtime/vk_mvsurvey.c +++ b/runtime/vk_mvsurvey.c @@ -156,11 +156,10 @@ void vk_mvsurvey_draw(VkExec *ex) { if (k->n++) continue; k->size = (uint32_t)u->size; uint32_t want = u->size < SNAP ? (uint32_t)u->size : SNAP; - VkDescriptorBufferInfo bi; - const uint8_t *src = vk_usnap_find(u->addr, want, UINT32_MAX, 1, &bi) ? vk_usnap_map() + bi.offset : NULL; + const uint8_t *src = vk_usnap_bytes(u->addr, want); k->have = src ? want : 0; if (src) memcpy(k->bytes, src, want); - const uint8_t *all = vk_usnap_find(u->addr, u->size, UINT32_MAX, 1, &bi) ? vk_usnap_map() + bi.offset : NULL; + const uint8_t *all = vk_usnap_bytes(u->addr, u->size); k->mats = all ? lead_mats((const float *)all, (uint32_t)(u->size / 4)) : 0; if (all) { Stat *s = &S.st[b]; diff --git a/runtime/vk_usnap.c b/runtime/vk_usnap.c index 6e5e1ad9..3a7b3d34 100644 --- a/runtime/vk_usnap.c +++ b/runtime/vk_usnap.c @@ -43,15 +43,17 @@ typedef struct Arena { VkBuffer buf; VmaAllocation alloc; uint8_t *map; - uint8_t *cpu; // with the per-object motion (vk_objmv_wanted: DLSS or FSR 3.1), the same bytes in host memory for - // the CPU's reads (vk_usnap_bytes): map is often device memory through the BAR, written fast but - // read back at about a microsecond a cache line. Without it nothing reads them back, and the bytes - // go into map in one copy. + uint8_t *cpu; // with the per-object motion (vk_objmv_wanted: DLSS or FSR 3.1), the bytes of the regions the CPU + // reads back many times (Reg.host) in host memory too, at the same offsets (vk_usnap_bytes): map + // is often device memory through the BAR, written fast but read back at about a microsecond a + // cache line. The other regions go into map alone, as without the motion. uint64_t size; } Arena; -typedef struct { uint64_t lo, hi; } Rng; -typedef struct { uint64_t lo, hi, off, drop_at; } Reg; // drop_at: dropped from this position on; UINT64_MAX not +// host: a vertex-stage binding of a bank the per-object motion compares (vk_mvprev_kept) or of the camera (c4), whose +// bytes the CPU reads (vk_exec_draw.c mo_prev_block, vk_mvprev_find, vk_dlaa.c): its region also gets a host copy +typedef struct { uint64_t lo, hi; uint32_t host; } Rng; +typedef struct { uint64_t lo, hi, off, drop_at; uint32_t host; } Reg; // drop_at: dropped from this position on; UINT64_MAX not typedef struct { uint64_t lo, hi, fence; } Wrote; static struct { @@ -66,7 +68,7 @@ static struct { Wrote *wr; // GPU writes of submissions not known to be complete int nwr, cwr; // since the last summary - uint64_t subs, regions, bytes, copy_ns, hits, drops, inflight, refused, off_subs; + uint64_t subs, regions, bytes, hbytes, copy_ns, hits, drops, inflight, refused, off_subs; } U; static Arena *free_arenas; @@ -147,6 +149,7 @@ static void collect(const op_hdr *h, int depth) { // TOTK_MVPREV_CHECK: the vertex stage's object and bone blocks, also the game's other copy on either // side, which still holds last frame's (vk_mvprev.c compares it with the last-frame copy) uint64_t step = vk_mvprev_step(b->stage, b->index, b->size); + uint32_t host = b->stage == 0 && (b->index == 1 || vk_mvprev_kept(b->index)); // which neighbours lie in an imported pool, per block and vk_mem_gen: the same blocks are bound by // many draws, and two resolves for each binding were a quarter of the snapshot's time static struct { uint64_t addr, size, gen; int ok; } nc[1024]; @@ -169,7 +172,7 @@ static void collect(const op_hdr *h, int depth) { ok |= 1 << (k + 1); } if (U.ncol == U.ccol) U.col = grow(U.col, &U.ccol, sizeof *U.col); - U.col[U.ncol++] = (Rng){at & ~(uint64_t)(ALIGN - 1), at + n}; + U.col[U.ncol++] = (Rng){at & ~(uint64_t)(ALIGN - 1), at + n, host}; } if (step && !known) nc[ci].addr = b->addr, nc[ci].size = n, nc[ci].gen = gen, nc[ci].ok = ok; } @@ -257,12 +260,12 @@ static int wr_hits(uint64_t lo, uint64_t hi) { // wr_prune ran: disjoint, sort static void summary(void) { if (U.subs + U.off_subs < 3600) return; double s = U.subs ? (double)U.subs : 1.0; - rt_log("vk_usnap: %llu submissions with a snapshot, %llu without; per submission %.0f ranges, %.1f KiB copied in " - "%.3f ms, %.0f uniform bindings from the copy, %.1f dropped by GPU writes, %.1f left out (GPU writes in " - "flight), %.1f refused (not an imported pool)", + rt_log("vk_usnap: %llu submissions with a snapshot, %llu without; per submission %.0f ranges, %.1f KiB copied " + "(%.1f KiB of it into host memory too) in %.3f ms, %.0f uniform bindings from the copy, %.1f dropped by GPU " + "writes, %.1f left out (GPU writes in flight), %.1f refused (not an imported pool)", (unsigned long long)U.subs, (unsigned long long)U.off_subs, U.regions / s, U.bytes / s / 1024.0, - U.copy_ns / s / 1e6, U.hits / s, U.drops / s, U.inflight / s, U.refused / s); - U.subs = U.off_subs = U.regions = U.bytes = U.copy_ns = U.hits = U.drops = U.inflight = U.refused = 0; + U.hbytes / s / 1024.0, U.copy_ns / s / 1e6, U.hits / s, U.drops / s, U.inflight / s, U.refused / s); + U.subs = U.off_subs = U.regions = U.bytes = U.hbytes = U.copy_ns = U.hits = U.drops = U.inflight = U.refused = 0; } void vk_usnap_begin(const uint64_t *handles, int n, uint64_t fence) { @@ -284,8 +287,11 @@ void vk_usnap_begin(const uint64_t *handles, int n, uint64_t fence) { uint64_t total = 0; for (int i = 0; i < U.ncol;) { uint64_t lo = U.col[i].lo, hi = U.col[i].hi; - for (i++; i < U.ncol && U.col[i].lo <= hi; i++) + uint32_t host = U.col[i].host; + for (i++; i < U.ncol && U.col[i].lo <= hi; i++) { if (U.col[i].hi > hi) hi = U.col[i].hi; + host |= U.col[i].host; + } VkMemSpan sp; if (!vk_mem_resolve(lo, hi - lo, &sp) || sp.alloc || !sp.pool || sp.avail < hi - lo || (sp.cls != VK_MCLS_HOST_CACHED && sp.cls != VK_MCLS_HOST_UNC)) { @@ -297,22 +303,30 @@ void vk_usnap_begin(const uint64_t *handles, int n, uint64_t fence) { continue; } if (U.nreg == U.creg) U.reg = grow(U.reg, &U.creg, sizeof *U.reg); - U.reg[U.nreg++] = (Reg){lo, hi, total, UINT64_MAX}; + U.reg[U.nreg++] = (Reg){lo, hi, total, UINT64_MAX, host}; total += (hi - lo + ALIGN - 1) & ~(uint64_t)(ALIGN - 1); } if (!U.nreg) return; if (!(U.arena = arena_get(total))) return; - uint8_t *dst = U.arena->map; + uint8_t *map = U.arena->map, *cpu = NULL; if (vk_objmv_wanted()) { if (!U.arena->cpu && !(U.arena->cpu = malloc(U.arena->size))) rt_fatal("vk_usnap: out of memory"); - dst = U.arena->cpu; + cpu = U.arena->cpu; + } else { + for (int i = 0; i < U.nreg; i++) U.reg[i].host = 0; // nothing reads them back: the device copy alone + } + // a host region into host memory first and from there into the device copy, so both hold the same bytes while + // the game writes guest memory on other threads + uint64_t hbytes = 0; + for (int i = 0; i < U.nreg; i++) { + const Reg *r = &U.reg[i]; + uint64_t len = r->hi - r->lo; + if (r->host) memcpy(cpu + r->off, (const void *)(uintptr_t)r->lo, len), memcpy(map + r->off, cpu + r->off, len), hbytes += len; + else memcpy(map + r->off, (const void *)(uintptr_t)r->lo, len); } - for (int i = 0; i < U.nreg; i++) - memcpy(dst + U.reg[i].off, (const void *)(uintptr_t)U.reg[i].lo, U.reg[i].hi - U.reg[i].lo); - if (dst != U.arena->map) memcpy(U.arena->map, dst, total); // one sequential write into the device copy vmaFlushAllocation(vk_ctx()->vma, U.arena->alloc, 0, total); // a no-op on coherent memory U.on = 1; - U.subs++, U.regions += (uint64_t)U.nreg, U.bytes += total, U.copy_ns += kern_now_ns() - t0; + U.subs++, U.regions += (uint64_t)U.nreg, U.bytes += total, U.hbytes += hbytes, U.copy_ns += kern_now_ns() - t0; } void vk_usnap_end(uint64_t fence) { @@ -349,7 +363,7 @@ int vk_usnap_prev(uint64_t addr, uint64_t n, uint64_t align, VkDescriptorBufferI if (lo >= PV.nreg) return 0; const Reg *r = &PV.reg[lo]; // a region a GPU write dropped held other bytes for the draws after it: left out, as vk_usnap_bytes does - if (r->drop_at != UINT64_MAX || addr < r->lo || addr + n > r->hi) return 0; + if (r->drop_at != UINT64_MAX || !r->host || addr < r->lo || addr + n > r->hi) return 0; uint64_t off = r->off + (addr - r->lo); if (off % align) return 0; *out = (VkDescriptorBufferInfo){PV.arena->buf, off, n}; @@ -401,14 +415,14 @@ void vk_usnap_drop_at(uint64_t addr, uint64_t n, uint32_t at) { drop(addr, n, at uint64_t vk_usnap_gen(void) { return __atomic_load_n(&U.gen, __ATOMIC_RELAXED); } -// the host copy where there is one (DLSS), else the device copy -static uint8_t *host_copy(void) { return U.arena->cpu ? U.arena->cpu : U.arena->map; } - -const uint8_t *vk_usnap_map(void) { return U.arena ? host_copy() : NULL; } - +// the host copy of a host region, else the device copy (slow to read through the BAR, read rarely) const uint8_t *vk_usnap_bytes(uint64_t addr, uint64_t n) { - VkDescriptorBufferInfo bi; - return vk_usnap_find(addr, n, UINT32_MAX, 1, &bi) ? host_copy() + bi.offset : NULL; + if (!U.on || !n) return NULL; + int i = first_above(addr); + if (i >= U.nreg) return NULL; + const Reg *r = &U.reg[i]; + if (__atomic_load_n(&r->drop_at, __ATOMIC_RELAXED) != UINT64_MAX || addr < r->lo || addr + n > r->hi) return NULL; + return (r->host && U.arena->cpu ? U.arena->cpu : U.arena->map) + r->off + (addr - r->lo); } // The arenas back on the free list (vk_exec_draw_shutdown: the device is idle, every completion ran).